@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/pkg-web/nanocodex_bg.wasm.d.ts

@@ -0,0 +1,105 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_browservoice_free: (a: number, b: number) => void;
+export const __wbg_chatgptsubscription_free: (a: number, b: number) => void;
+export const __wbg_managedbrowservoice_free: (a: number, b: number) => void;
+export const __wbg_nanocodex_free: (a: number, b: number) => void;
+export const __wbg_turn_free: (a: number, b: number) => void;
+export const __wbg_turnresult_free: (a: number, b: number) => void;
+export const applyBrowserPatch: (a: number, b: number, c: number, d: number) => number;
+export const browservoice_agentEvent: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_appendContext: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_appendSpeech: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_appendText: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const browservoice_callBody: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_cancel: (a: number) => number;
+export const browservoice_completeCall: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const browservoice_configure: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_flush: (a: number, b: number, c: number) => void;
+export const browservoice_framesSent: (a: number, b: number) => void;
+export const browservoice_preferredPhysicalInput: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const browservoice_realtimeMessage: (a: number, b: number, c: number) => number;
+export const browservoice_requiresAgentAdmission: (a: number, b: number, c: number) => number;
+export const browservoice_sidebandClosed: (a: number, b: number, c: number) => void;
+export const browservoice_sidebandOpened: (a: number, b: number) => void;
+export const browservoice_sidebandUrl: (a: number, b: number, c: number, d: number) => void;
+export const browservoice_start: (a: number) => number;
+export const browservoice_stop: (a: number) => number;
+export const chatgptsubscription_credential: (a: number) => number;
+export const chatgptsubscription_logout: (a: number) => number;
+export const chatgptsubscription_open: (a: number, b: number) => number;
+export const chatgptsubscription_recover: (a: number, b: number, c: number) => number;
+export const chatgptsubscription_startLogin: (a: number) => number;
+export const chatgptsubscription_status: (a: number) => number;
+export const managedBootstrapPlan: (a: number, b: number, c: number) => void;
+export const managedbrowservoice_agentEvent: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_appendContext: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_appendSpeech: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_appendText: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const managedbrowservoice_callBody: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const managedbrowservoice_completeCall: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const managedbrowservoice_configure: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_flush: (a: number, b: number, c: number) => void;
+export const managedbrowservoice_framesSent: (a: number, b: number) => void;
+export const managedbrowservoice_managedEvent: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_new: (a: number, b: number, c: number) => void;
+export const managedbrowservoice_preferredPhysicalInput: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const managedbrowservoice_realtimeMessage: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_requiresAgentAdmission: (a: number, b: number, c: number) => number;
+export const managedbrowservoice_sidebandClosed: (a: number, b: number, c: number) => void;
+export const managedbrowservoice_sidebandOpened: (a: number, b: number) => void;
+export const managedbrowservoice_sidebandUrl: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const managedbrowservoice_start: (a: number, b: number, c: number, d: number) => void;
+export const managedbrowservoice_stop: (a: number, b: number) => void;
+export const nanocodex_agentId: (a: number, b: number) => void;
+export const nanocodex_appendDeveloperMessage: (a: number, b: number, c: number) => number;
+export const nanocodex_browserVoice: (a: number, b: number, c: number, d: number) => void;
+export const nanocodex_closeSubagent: (a: number, b: number, c: number) => number;
+export const nanocodex_compact: (a: number) => number;
+export const nanocodex_compactOutcome: (a: number) => number;
+export const nanocodex_context: (a: number) => number;
+export const nanocodex_create: (a: number, b: number) => number;
+export const nanocodex_createWithChatGpt: (a: number, b: number, c: number) => number;
+export const nanocodex_endRealtimeConversation: (a: number) => number;
+export const nanocodex_fork: (a: number) => number;
+export const nanocodex_forkFrom: (a: number, b: number) => number;
+export const nanocodex_interruptSubagent: (a: number, b: number, c: number) => number;
+export const nanocodex_listSubagents: (a: number, b: number, c: number) => number;
+export const nanocodex_prompt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const nanocodex_promptContent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const nanocodex_realtimeDelegation: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const nanocodex_realtimeTailDelegation: (a: number, b: number, c: number, d: number) => void;
+export const nanocodex_restoreSubagents: (a: number, b: number, c: number, d: number, e: number) => number;
+export const nanocodex_routePrompt: (a: number, b: number, c: number) => number;
+export const nanocodex_sendSubagentMessage: (a: number, b: number, c: number) => number;
+export const nanocodex_sessionId: (a: number, b: number) => void;
+export const nanocodex_setEventForwarding: (a: number, b: number) => void;
+export const nanocodex_setFastMode: (a: number, b: number) => number;
+export const nanocodex_setModel: (a: number, b: number, c: number) => number;
+export const nanocodex_setThinking: (a: number, b: number, c: number) => number;
+export const nanocodex_shutdown: (a: number) => number;
+export const nanocodex_snapshot: (a: number) => number;
+export const nanocodex_spawn: (a: number) => number;
+export const nanocodex_spawnSubagent: (a: number, b: number, c: number) => number;
+export const nanocodex_spawnSubagents: (a: number, b: number, c: number) => number;
+export const nanocodex_startRealtimeConversation: (a: number) => number;
+export const nanocodex_waitSubagents: (a: number, b: number, c: number) => number;
+export const pruneDurableReceipts: (a: number, b: number, c: number, d: number, e: number) => number;
+export const turn_accepted: (a: number) => number;
+export const turn_cancel: (a: number) => number;
+export const turn_result: (a: number) => number;
+export const turn_steer: (a: number, b: number, c: number) => number;
+export const turn_steerContent: (a: number, b: number, c: number) => number;
+export const turnresult_finalMessage: (a: number, b: number) => void;
+export const turnresult_snapshot: (a: number, b: number) => void;
+export const turnresult_usage: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_20354: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_20356: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_4730: (a: number, b: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export5: (a: number, b: number, c: number) => void;

package/vendor/nanocodex/pkg-web/nanocodex_worker.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./nanocodex.d.ts" */
+import * as wasm from "./nanocodex_bg.wasm";
+import { __wbg_set_wasm } from "./nanocodex_bg.js";
+
+__wbg_set_wasm(wasm);
+
+export {
+    BrowserVoice, ChatGptSubscription, ManagedBrowserVoice, Nanocodex, Turn, TurnResult, applyBrowserPatch, managedBootstrapPlan, pruneDurableReceipts
+} from "./nanocodex_bg.js";

package/vendor/nanocodex/pkg-web/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/vendor/nanocodex/runtime/chatgpt-subscription.mjs

@@ -0,0 +1,212 @@
+const hosts = new Map();
+const RAW_SUBSCRIPTION = Symbol.for("nanocodex.chatgpt.subscription");
+const DEFAULT_MAX_RESPONSE_BYTES = 16 * 1024;
+
+export async function openSubscription(options, openRaw, { replaceHost = false } = {}) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("ChatGptSubscription.open requires options");
+  }
+  const id = requiredId(options.id);
+  const fetch = options.fetch;
+  const host = {
+    store: options.store,
+    // Cloudflare's global fetch requires the Worker global as its receiver.
+    // Keep the stored capability receiver-neutral so calling it through the
+    // host record cannot accidentally bind `this` to that record.
+    fetch: fetch === undefined
+      ? (...args) => globalThis.fetch(...args)
+      : (...args) => fetch(...args),
+    references: 0,
+  };
+  validateHost(host);
+  bind(id, host, replaceHost);
+  try {
+    const raw = await openRaw(JSON.stringify({
+      id,
+      ...(options.issuer === undefined ? {} : { issuer: options.issuer }),
+      ...(options.seed === undefined ? {} : { seed: options.seed }),
+    }));
+    const view = Object.freeze({
+      id,
+      [RAW_SUBSCRIPTION]: raw,
+      async startLogin() {
+        return JSON.parse(await raw.startLogin());
+      },
+      async status() {
+        return JSON.parse(await raw.status());
+      },
+      async credential() {
+        return parseCredential(await raw.credential());
+      },
+      async recover(rejectedRevision) {
+        return parseCredential(await raw.recover(revision(
+          rejectedRevision,
+          "rejected credential revision",
+        )));
+      },
+      async logout() {
+        await raw.logout();
+      },
+      dispose() {
+        release(id, host);
+        raw.free();
+      },
+    });
+    host.references += 1;
+    return view;
+  } catch (error) {
+    release(id, host);
+    throw error;
+  }
+}
+
+export function rawSubscription(subscription) {
+  const raw = subscription?.[RAW_SUBSCRIPTION];
+  if (!raw || typeof raw.status !== "function") {
+    throw new TypeError("subscription must be an open ChatGptSubscription");
+  }
+  return raw;
+}
+
+export async function load(subscriptionId) {
+  const stored = await requiredHost(subscriptionId).store.load(subscriptionId);
+  if (!stored || typeof stored !== "object") {
+    throw new TypeError("subscription store load() must return { revision, payload? }");
+  }
+  return JSON.stringify({
+    revision: revision(stored.revision, "subscription load revision"),
+    ...(stored.payload === undefined || stored.payload === null
+      ? {}
+      : { payload: requiredString(stored.payload, "subscription payload") }),
+  });
+}
+
+export async function compareAndSwap(subscriptionId, expectedRevision, payload) {
+  const result = await requiredHost(subscriptionId).store.compareAndSwap(subscriptionId, {
+    expectedRevision,
+    payload,
+  });
+  if (result?.status === "committed") {
+    return JSON.stringify({
+      status: "committed",
+      revision: revision(result.revision, "subscription commit revision"),
+    });
+  }
+  if (result?.status === "conflict") {
+    return JSON.stringify({
+      status: "conflict",
+      actual_revision: revision(result.actualRevision, "subscription conflict revision"),
+    });
+  }
+  throw new TypeError("subscription compareAndSwap() must return committed or conflict");
+}
+
+export async function request(subscriptionId, encoded) {
+  const host = requiredHost(subscriptionId);
+  const request = JSON.parse(encoded);
+  if (request.method !== "POST") throw new TypeError("subscription HTTP method must be POST");
+  const url = new URL(request.url);
+  if (url.origin !== "https://auth.openai.com" && url.hostname !== "127.0.0.1") {
+    throw new TypeError("subscription HTTP is restricted to auth.openai.com");
+  }
+  const maxResponseBytes = positiveInteger(
+    request.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+    "subscription response limit",
+  );
+  const response = await host.fetch(url, {
+    method: "POST",
+    headers: { "content-type": requiredString(request.contentType, "subscription content type") },
+    body: requiredString(request.body, "subscription request body"),
+    redirect: "manual",
+  });
+  if (!(response instanceof Response)) {
+    throw new TypeError("subscription fetch() must return a Response");
+  }
+  return JSON.stringify({
+    status: response.status,
+    body: await readBoundedText(response, maxResponseBytes),
+  });
+}
+
+function bind(id, host, replaceHost) {
+  if (!replaceHost && hosts.has(id)) {
+    throw new Error(`ChatGPT subscription is already open: ${id}`);
+  }
+  hosts.set(id, host);
+}
+
+function release(id, host) {
+  if (hosts.get(id) !== host) return;
+  if (host.references > 0) host.references -= 1;
+  if (host.references === 0) hosts.delete(id);
+}
+
+function requiredHost(id) {
+  const host = hosts.get(id);
+  if (!host) throw new Error(`no host owns ChatGPT subscription: ${id}`);
+  return host;
+}
+
+function validateHost(host) {
+  if (!host.store || typeof host.store.load !== "function"
+      || typeof host.store.compareAndSwap !== "function") {
+    throw new TypeError("ChatGPT subscription requires load and compareAndSwap storage");
+  }
+  if (typeof host.fetch !== "function") {
+    throw new TypeError("ChatGPT subscription requires a fetch capability");
+  }
+}
+
+async function readBoundedText(response, limit) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let size = 0;
+  let body = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) return body + decoder.decode();
+    size += value.byteLength;
+    if (size > limit) {
+      await reader.cancel();
+      throw new Error(`subscription response exceeded ${limit} bytes`);
+    }
+    body += decoder.decode(value, { stream: true });
+  }
+}
+
+function revision(value, name) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new TypeError(`${name} must be an unsigned decimal string`);
+  }
+  return value;
+}
+
+function requiredId(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9._:-]{1,200}$/.test(value)) {
+    throw new TypeError("subscription id must be a bounded stable identifier");
+  }
+  return value;
+}
+
+function requiredString(value, name) {
+  if (typeof value !== "string") throw new TypeError(`${name} must be a string`);
+  return value;
+}
+
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be positive`);
+  return value;
+}
+
+function parseCredential(encoded) {
+  const credential = JSON.parse(encoded);
+  if (credential?.kind !== "chatgpt" || typeof credential.accessToken !== "string"
+      || typeof credential.accountId !== "string" || typeof credential.fedramp !== "boolean") {
+    throw new TypeError("Rust returned an invalid ChatGPT credential");
+  }
+  return Object.freeze({
+    ...credential,
+    revision: revision(credential.revision, "credential revision"),
+  });
+}

package/vendor/nanocodex/runtime/cloudflare-durability-store.d.mts

@@ -0,0 +1,26 @@
+import type {
+  DurabilitySqliteRow,
+  DurabilitySqliteValue,
+  DurabilityPortableStore,
+} from "../types.mjs";
+
+export type CloudflareDurableObjectStorage = Readonly<{
+  sql: Readonly<{
+    exec<Row extends DurabilitySqliteRow>(
+      sql: string,
+      ...bindings: readonly DurabilitySqliteValue[]
+    ): Readonly<{
+      toArray(): readonly Row[];
+      [Symbol.iterator](): IterableIterator<Row>;
+    }>;
+  }>;
+  transactionSync<Result>(callback: () => Result): Result;
+}>;
+
+/**
+ * Initializes and adapts one Durable Object's colocated SQLite durable state.
+ * Rust owns the opaque total-state payload; the host only provides atomic storage.
+ */
+export declare function createCloudflareDurabilityStore(
+  storage: CloudflareDurableObjectStorage,
+): DurabilityPortableStore;

package/vendor/nanocodex/runtime/cloudflare-durability-store.mjs

@@ -0,0 +1,168 @@
+import { createSqliteDurabilityStore, sqliteDurabilitySchema } from "./durability-store.mjs";
+
+const DIRECT_PAYLOAD_BYTES = 1_000_000;
+const PAYLOAD_CHUNK_CODE_UNITS = 256_000;
+const encoder = new TextEncoder();
+
+const cloudflareDurabilitySchema = Object.freeze([
+  ...sqliteDurabilitySchema,
+  `CREATE TABLE IF NOT EXISTS nanocodex_durable_chunk_heads (
+     state_id TEXT PRIMARY KEY,
+     revision TEXT NOT NULL,
+     chunk_count INTEGER NOT NULL CHECK (chunk_count > 0)
+   )`,
+  `CREATE TABLE IF NOT EXISTS nanocodex_durable_state_chunks (
+     state_id TEXT NOT NULL,
+     revision TEXT NOT NULL,
+     chunk_index INTEGER NOT NULL,
+     payload TEXT NOT NULL,
+     PRIMARY KEY (state_id, revision, chunk_index)
+   )`,
+]);
+
+/** Adapts one Cloudflare Durable Object's colocated SQLite to Nanocodex. */
+export function createCloudflareDurabilityStore(storage) {
+  if (
+    !storage?.sql
+    || typeof storage.sql.exec !== "function"
+    || typeof storage.transactionSync !== "function"
+  ) {
+    throw new TypeError("Cloudflare durability requires Durable Object storage with SQLite");
+  }
+  const raw = (sql, args) => {
+    const cursor = storage.sql.exec(sql, ...args);
+    if (typeof cursor?.[Symbol.iterator] !== "function") return cursor.toArray();
+    return [...cursor];
+  };
+  for (const statement of cloudflareDurabilitySchema) storage.sql.exec(statement);
+  validateSchema(raw);
+  const query = (sql, args) => {
+    if (sql.startsWith("INSERT INTO nanocodex_durable_states")) {
+      return replaceState(raw, sql, args);
+    }
+    const rows = raw(sql, args);
+    return sql.startsWith("SELECT revision, payload FROM nanocodex_durable_states")
+      ? hydrateState(raw, args[0], rows)
+      : rows;
+  };
+  return createSqliteDurabilityStore({
+    transaction: (callback) => storage.transactionSync(() => callback(query)),
+  });
+}
+
+function validateSchema(query) {
+  const tables = [
+    ["nanocodex_durable_owners", [
+      ["state_id", "TEXT", 0, 1], ["owner_id", "TEXT", 1, 0], ["fence", "TEXT", 1, 0],
+    ]],
+    ["nanocodex_durable_states", [
+      ["state_id", "TEXT", 0, 1], ["revision", "TEXT", 1, 0], ["payload", "TEXT", 1, 0],
+    ]],
+    ["nanocodex_durable_chunk_heads", [
+      ["state_id", "TEXT", 0, 1], ["revision", "TEXT", 1, 0], ["chunk_count", "INTEGER", 1, 0],
+    ]],
+    ["nanocodex_durable_state_chunks", [
+      ["state_id", "TEXT", 1, 1], ["revision", "TEXT", 1, 2],
+      ["chunk_index", "INTEGER", 1, 3], ["payload", "TEXT", 1, 0],
+    ]],
+  ];
+  for (const [table, expected] of tables) {
+    const rows = query(`PRAGMA table_info('${table}')`, []);
+    const valid = rows.length === expected.length && rows.every((row, index) => {
+      const shape = expected[index];
+      return row.name === shape[0]
+        && String(row.type).toUpperCase() === shape[1]
+        && Number(row.notnull) === shape[2]
+        && Number(row.pk) === shape[3];
+    });
+    if (!valid) {
+      throw new Error(`incompatible Cloudflare durability schema for ${table}; recreate it`);
+    }
+  }
+}
+
+function replaceState(query, sql, [stateId, revision, payload]) {
+  if (typeof payload !== "string") {
+    throw new TypeError("durability state payload must be a string");
+  }
+  query("DELETE FROM nanocodex_durable_chunk_heads WHERE state_id = ?", [stateId]);
+  query("DELETE FROM nanocodex_durable_state_chunks WHERE state_id = ?", [stateId]);
+  // UTF-8 needs at least one byte per UTF-16 code unit. Do not allocate
+  // another full-state byte buffer just to decide an already-large payload
+  // needs chunks. The remaining encoding is bounded by the inline threshold.
+  if (payload.length <= DIRECT_PAYLOAD_BYTES
+    && encoder.encode(payload).byteLength <= DIRECT_PAYLOAD_BYTES) {
+    return query(sql, [stateId, revision, payload]);
+  }
+  const result = query(sql, [stateId, revision, ""]);
+  const chunks = payloadChunks(payload);
+  query(
+    `INSERT INTO nanocodex_durable_chunk_heads (state_id, revision, chunk_count)
+     VALUES (?, ?, ?)`,
+    [stateId, revision, chunks.length],
+  );
+  for (let index = 0; index < chunks.length; index += 1) {
+    query(
+      `INSERT INTO nanocodex_durable_state_chunks
+       (state_id, revision, chunk_index, payload) VALUES (?, ?, ?, ?)`,
+      [stateId, revision, index, chunks[index]],
+    );
+  }
+  return result;
+}
+
+function hydrateState(query, stateId, rows) {
+  if (rows.length === 0) return rows;
+  if (rows.length !== 1) throw new Error("Cloudflare durability retained duplicate states");
+  const row = rows[0];
+  const head = query(
+    `SELECT revision, chunk_count FROM nanocodex_durable_chunk_heads
+     WHERE state_id = ?`,
+    [stateId],
+  )[0];
+  if (!head) return rows;
+  if (head.revision !== row.revision || row.payload !== "") {
+    throw new Error("invalid Cloudflare durability chunk head");
+  }
+  const chunks = query(
+    `SELECT revision, chunk_index, payload FROM nanocodex_durable_state_chunks
+     WHERE state_id = ? ORDER BY chunk_index`,
+    [stateId],
+  );
+  if (chunks.length !== head.chunk_count) {
+    throw new Error(`missing Cloudflare durability chunks for revision ${row.revision} (expected ${head.chunk_count}, found ${chunks.length})`);
+  }
+  for (let index = 0; index < chunks.length; index += 1) {
+    const chunk = chunks[index];
+    if (chunk.revision !== row.revision || chunk.chunk_index !== index
+      || typeof chunk.payload !== "string") {
+      throw new Error(`invalid Cloudflare durability chunks for revision ${row.revision}`);
+    }
+  }
+  return [{ ...row, payload: chunks.map((chunk) => chunk.payload).join("") }];
+}
+
+function payloadChunks(payload) {
+  const chunks = [];
+  for (let offset = 0; offset < payload.length;) {
+    let end = Math.min(offset + PAYLOAD_CHUNK_CODE_UNITS, payload.length);
+    if (
+      end < payload.length
+      && isHighSurrogate(payload.charCodeAt(end - 1))
+      && isLowSurrogate(payload.charCodeAt(end))
+    ) {
+      end -= 1;
+    }
+    chunks.push(payload.slice(offset, end));
+    offset = end;
+  }
+  return chunks;
+}
+
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}

package/vendor/nanocodex/runtime/code-evaluator.worker.mjs

@@ -0,0 +1,137 @@
+import { installBrowserEgressFetch } from "../tools/browser/browserEgress.mjs";
+
+const WORKER_PROTOCOL = "nanocodex.code-evaluator.v1";
+const pendingTools = new Map();
+const toolInvocations = [];
+let nextToolCall = 1;
+let evaluating = false;
+let evaluationId;
+
+globalThis.onmessage = ({ data }) => {
+  if (data?.protocol !== WORKER_PROTOCOL) return;
+  if (data.type === "tool.result") {
+    if (data.evaluationId !== evaluationId) return;
+    const pending = pendingTools.get(data.id);
+    if (!pending) return;
+    pendingTools.delete(data.id);
+    (data.ok ? pending.resolve : pending.reject)(data.value);
+    return;
+  }
+  if (data.type !== "evaluate" || evaluating) return;
+  if (data.egress) installBrowserEgressFetch(data.egress);
+  evaluating = true;
+  evaluationId = data.evaluationId;
+  void evaluate(data).then(
+    (storedWrites) => post("completed", { storedWrites }),
+    ({ error, storedWrites }) => post("failed", { error: errorMessage(error), storedWrites }),
+  );
+};
+
+async function evaluate({ source, storedEntries = [], toolDefinitions = [], toolNames = [] }) {
+  const stored = new Map(storedEntries);
+  const storedWrites = new Map();
+  const tools = Object.create(null);
+  for (const name of toolNames) tools[name] = (input) => callTool(name, input);
+  const callableTools = new Proxy(tools, {
+    get(target, property) {
+      if (typeof property !== "string") return Reflect.get(target, property);
+      return target[property] ?? ((input) => callTool(property, input));
+    },
+  });
+  Object.freeze(tools);
+
+  const text = (value) => post("output", { kind: "text", value });
+  const image = (value, detail) => post("output", {
+    kind: "image",
+    value,
+    detail,
+  });
+  const audio = (value) => post("output", { kind: "audio", value });
+  const notify = (value) => post("output", { kind: "notify", value });
+  const yield_control = () => post("output", { kind: "yield_control" });
+  const generatedImage = (value) => post("output", { kind: "generatedImage", value });
+  const store = (key, value) => {
+    if (typeof key !== "string") throw new TypeError("store key must be a string");
+    const snapshot = structuredClone(value);
+    stored.set(key, snapshot);
+    storedWrites.set(key, snapshot);
+  };
+  const load = (key) => stored.has(key) ? structuredClone(stored.get(key)) : undefined;
+  const EXIT = Symbol("exit");
+  const exit = () => { throw EXIT; };
+  const guestConsole = Object.freeze(Object.fromEntries(
+    ["debug", "info", "log", "warn", "error"].map((level) => [level, (...values) => {
+      post("console", { level, values: values.map(stringify) });
+    }]),
+  ));
+
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+    const script = new AsyncFunction(
+      "tools",
+      "ALL_TOOLS",
+      "text",
+      "image",
+      "generatedImage",
+      "audio",
+      "notify",
+      "yield_control",
+      "store",
+      "load",
+      "exit",
+      "require",
+      "console",
+      source,
+    );
+    try {
+      await script(
+        callableTools,
+        Object.freeze(toolDefinitions),
+        text,
+        image,
+        generatedImage,
+        audio,
+        notify,
+        yield_control,
+        store,
+        load,
+        exit,
+        undefined,
+        guestConsole,
+      );
+    } finally {
+      // Discarding a tool Promise or calling exit() must not orphan parent-held
+      // work. The evaluator remains alive until each invocation receives its
+      // terminal response, or its supervisor terminates this cell on cancel.
+      await Promise.allSettled(toolInvocations);
+    }
+    return [...storedWrites];
+  } catch (error) {
+    if (error === EXIT) return [...storedWrites];
+    throw { error, storedWrites: [...storedWrites] };
+  }
+}
+
+function callTool(name, input) {
+  const id = nextToolCall++;
+  const invocation = new Promise((resolve, reject) => {
+    pendingTools.set(id, { resolve, reject });
+    post("tool.call", { id, input: input ?? null, name });
+  });
+  toolInvocations.push(invocation.then(() => undefined, () => undefined));
+  return invocation;
+}
+
+function post(type, value = {}) {
+  globalThis.postMessage({ protocol: WORKER_PROTOCOL, evaluationId, type, ...value });
+}
+
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (value === undefined) return "undefined";
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+
+function errorMessage(error) {
+  return error && (error.stack || error.message) ? error.stack || error.message : String(error);
+}

package/vendor/nanocodex/runtime/code-runtime.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/runtime/code-runtime.mjs";