Val Town Code SearchReturn to Val Town

5import { secp256k1 } from "npm:@noble/curves/secp256k1";
6
7export function decompressPoint(bytes: Uint8Array, curve: string) {
8  if (curve === "P-256") {
9    const point = p256.ProjectivePoint.fromHex(bytes);
17}
18
19function pointToBytes<T>(point: ProjPointType<T>, Fp: IField<T>) {
20  const x = Fp.toBytes(point.x);
21  const y = Fp.toBytes(point.y);
24
25// @see: https://stackoverflow.com/questions/17171542/algorithm-for-elliptic-curve-point-compression
26export function compressPoint({ x, y }: { x: Uint8Array; y: Uint8Array }) {
27  const compressed = new Uint8Array(x.length + 1);
28  compressed[0] = 2 + (y.at(-1) & 1);

5
6// borrowed from: https://github.com/benvinegar/counterscale/blob/main/app/analytics/query.ts#L24
7function accumulateCountsFromRowResult(
8  counts,
9  row: {
22}
23
24export default async function(interval: Interval) {
25  // you need to declare these two environment variables:
26

1import { fetch } from "https://esm.town/v/std/fetch";
2
3export async function uploadTo0x0(data, name) {
4  const blob = new Blob([data]);
5  const formData = new FormData();

11};
12
13export async function prompt(
14  text,
15  { mode = "text", model = "opus", max_tokens = 1024, messages = [] } = {},

3import { escape } from "npm:html-sloppy-escaper";
4
5export default async function viewSource(req: Request) {
6  const pathname = new URL(req.url).pathname;
7  const html = await fetchText(

218];
219
220async function migrate() {
221  await std_sqlite.execute(`
222    create table if not exists tracing_schema (
369}
370
371export async function init(
372  url: string | URL,
373): Promise<void> {
394}
395
396export function tracer(): Tracer {
397  return otelTrace.getTracer("val.town");
398}
399
400export function attribute(name: string, value: string): void {
401  otelTrace.getActiveSpan()?.setAttribute(name, value);
402}
403
404export function event(name: string, attrs: Record<string, string>): void {
405  otelTrace.getActiveSpan()?.addEvent(name, attrs);
406}
407
408export function trace<
409  // deno-lint-ignore no-explicit-any
410  F extends (...args: any[]) => any,
428}
429
430export async function traceAsync<
431  // deno-lint-ignore no-explicit-any
432  F extends (...args: any[]) => any,
454}
455
456export function traced<
457  // deno-lint-ignore no-explicit-any
458  F extends (...args: any[]) => any,
459>(name: string, f: F) {
460  return async function (
461    ...args: Parameters<F>
462  ): Promise<Awaited<ReturnType<F>>> {
470 * be tied together.
471 */
472export async function fetch(
473  input: string | URL,
474  init?: RequestInit,
511}
512
513async function tracedExecute(statement: InStatement): Promise<ResultSet> {
514  return await tracer().startActiveSpan(
515    `sqlite:execute`,
544}
545
546async function tracedBatch(
547  statements: InStatement[],
548  mode?: TransactionMode,
603 * Takes an http handler and returns a new handler that
604 * traces the request.
605 * @returns {Function} A new handler that traces the request.
606 */
607export function tracedHandler(
608  handler: (req: Request) => Promise<Response>,
609): (req: Request) => Promise<Response> {
610  async function _tracedHandler(req: Request): Promise<Response> {
611    let active_context = null;
612    const prop_header = req.headers.get("b3");
930
931  const render_spans: SelectSpan[] = [];
932  function push_span(span_id: string) {
933    const span = spans_by_id.get(span_id)!;
934    render_spans.push(span);
1069
1070  const render_spans: SelectSpan[] = [];
1071  function push_span(span_id: string) {
1072    const span = spans_by_id.get(span_id)!;
1073    render_spans.push(span);
1246});
1247
1248export async function traceViewer(req: Request): Promise<Response> {
1249  await migrate();
1250  return await app.fetch(req);

1import { command_processor } from "https://esm.town/v/curtcox/command_processor?v=14";
2
3function tail(text: string): string {
4  const trimmed = text.trimStart();
5  const index = trimmed.indexOf(" ");

19await init(import.meta.url);
20
21async function handler(req: Request): Promise<Response> {
22  // whatever else you do.
23  return 
63```
64
65* `traced` wraps an async function in tracing.
66
67```typescript
68import { traceAsync } from "https://esm.town/v/saolsen/telemetry";
69
70const myTracedFunction: () => Promise<string> = traced(
71  "myTracedFunction",
72  async () => {
73    // await sleep(100);
77```
78
79* `fetch` is a traced version of the builtin `fetch` function that traces the request. Just import it and use it like you would use `fetch`.
80
81* `sqlite` is a traced version of the val town sqlite client. Just import it and use it like you would use [https://www.val.town/v/std/sqlite](https://www.val.town/v/std/sqlite)

9    user: "website that shows the current time",
10    content: `/** @jsxImportSource npm:react */
11export default function() {
12  return <h1>{new Date().toLocaleTimeString()}</h1>;
13}`,
66  );
67});
68export async function compile(description: string) {
69  const messages = [
70    {
74        You write Deno TypeScript.
75        Reply ONLY with valid Typescript.
76        Export the fetch function to run the server.
77        Only use web standard fetch. Export the fetch function to start the server.
78        Add extensive comments`,
79    },

1export default async function handler(req: Request) {
2  if (req.method !== 'POST') {
3    return new Response('Method not allowed', { status: 405 });