nanocodex 0.5.0 → 0.6.0

package/runtime/quickjs-evaluator.mjs

@@ -0,0 +1,236 @@
+const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
+const DEFAULT_INTERRUPT_CYCLES = 1_000_000;
+
+/**
+ * Builds a Code Mode evaluator for runtimes that reject eval/new Function.
+ * Pass an asyncified QuickJS WASM module from quickjs-emscripten-core.
+ */
+export function createQuickJsEvaluator(quickJs, options = {}) {
+  if (!quickJs || typeof quickJs.newContext !== "function") {
+    throw new TypeError("quickJs must be an asyncified QuickJS WASM module");
+  }
+  let queue = Promise.resolve();
+
+  return (source, environment) => {
+    const evaluation = queue.then(() => evaluate(quickJs, source, environment, options));
+    queue = evaluation.catch(() => {});
+    return evaluation;
+  };
+}
+
+async function evaluate(quickJs, source, environment, options) {
+  environment.signal?.throwIfAborted();
+  const vm = quickJs.newContext();
+  const runtime = vm.runtime;
+  runtime.setMemoryLimit(options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES);
+  runtime.setMaxStackSize(options.stackLimitBytes ?? DEFAULT_STACK_LIMIT_BYTES);
+  let interruptCycles = 0;
+  const maxInterruptCycles = options.maxInterruptCycles ?? DEFAULT_INTERRUPT_CYCLES;
+  let aborted = environment.signal?.aborted === true;
+  const onAbort = () => { aborted = true; };
+  environment.signal?.addEventListener("abort", onAbort, { once: true });
+  runtime.setInterruptHandler(() => aborted || ++interruptCycles > maxInterruptCycles);
+  let closed = false;
+
+  try {
+    expose(vm, "__nanocodex_call_tool", (nameHandle, inputHandle) => {
+      const name = vm.getString(nameHandle);
+      const input = vm.getString(inputHandle);
+      const deferred = vm.newPromise();
+      invokeTool(environment, name, input).then((encoded) => {
+        if (closed) return;
+        vm.newString(encoded).consume(deferred.resolve);
+        runtime.executePendingJobs().unwrap();
+      });
+      return deferred.handle;
+    });
+    expose(vm, "__nanocodex_emit", (kindHandle, payloadHandle) => {
+      const kind = vm.getString(kindHandle);
+      const payload = JSON.parse(vm.getString(payloadHandle));
+      if (kind === "text") environment.text(payload);
+      else if (kind === "image") environment.image(payload.value, payload.detail);
+      else if (kind === "audio") environment.audio(payload);
+      else if (kind === "notify") environment.notify(payload);
+      else if (kind === "yield_control") environment.yield_control();
+      else if (kind === "generatedImage") environment.generatedImage(payload);
+      else throw new Error(`unknown Code Mode output kind: ${kind}`);
+    });
+    expose(vm, "__nanocodex_sleep", (delayHandle) => {
+      const deferred = vm.newPromise();
+      environment.setTimeout(() => {
+        if (closed) return;
+        deferred.resolve();
+        runtime.executePendingJobs().unwrap();
+      }, vm.getNumber(delayHandle));
+      return deferred.handle;
+    });
+    expose(vm, "__nanocodex_store", (keyHandle, valueHandle) => {
+      const key = vm.getString(keyHandle);
+      const envelope = JSON.parse(vm.getString(valueHandle));
+      environment.store(key, envelope.value);
+    });
+    expose(vm, "__nanocodex_load", (keyHandle) => {
+      const value = environment.load(vm.getString(keyHandle));
+      return vm.newString(JSON.stringify({ value }));
+    });
+    expose(vm, "__nanocodex_log", (levelHandle, valuesHandle) => {
+      const level = vm.getString(levelHandle);
+      const values = JSON.parse(vm.getString(valuesHandle));
+      const logger = typeof environment.console?.[level] === "function"
+        ? environment.console[level]
+        : environment.console?.log;
+      logger?.(...values);
+    });
+
+    const setup = guestSource(
+      source,
+      Object.keys(environment.tools),
+      environment.toolDefinitions,
+    );
+    const started = await vm.evalCodeAsync(setup, "nanocodex-code-mode.js");
+    const promise = unwrap(vm, started);
+    try {
+      const settling = vm.resolvePromise(promise);
+      runtime.executePendingJobs().unwrap();
+      const settled = await abortable(settling, environment.signal);
+      unwrap(vm, settled).dispose();
+    } finally {
+      promise.dispose();
+    }
+  } finally {
+    closed = true;
+    environment.signal?.removeEventListener("abort", onAbort);
+    vm.dispose();
+  }
+}
+
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("Code Mode execution was cancelled"));
+    const settle = (callback, value) => {
+      signal.removeEventListener("abort", onAbort);
+      callback(value);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => settle(resolve, value),
+      (error) => settle(reject, error),
+    );
+  });
+}
+
+function expose(vm, name, handler) {
+  vm.newFunction(name, handler).consume((handle) => vm.setProp(vm.global, name, handle));
+}
+
+function exposeAsync(vm, name, handler) {
+  if (typeof vm.newAsyncifiedFunction !== "function") {
+    throw new TypeError("QuickJS module must use an asyncify variant");
+  }
+  vm.newAsyncifiedFunction(name, handler).consume((handle) => vm.setProp(vm.global, name, handle));
+}
+
+function unwrap(vm, result) {
+  if (result.error) {
+    const dumped = vm.dump(result.error);
+    result.error.dispose();
+    throw new Error(formatQuickJsError(dumped));
+  }
+  return result.value;
+}
+
+function formatQuickJsError(error) {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    if (typeof error.stack === "string") {
+      return typeof error.message === "string" && !error.stack.includes(error.message)
+        ? `${error.message}\n${error.stack}`
+        : error.stack;
+    }
+    if (typeof error.message === "string") return error.message;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+function guestSource(source, toolNames, toolDefinitions) {
+  return `
+const __nanocodex_exit = Symbol("exit");
+const __nanocodex_stringify = (value) => {
+  if (typeof value === "string") return value;
+  if (value === undefined) return "undefined";
+  try { return JSON.stringify(value); } catch { return String(value); }
+};
+const __nanocodex_decode = (encoded) => {
+  const result = JSON.parse(encoded);
+  if (!result.ok) throw new Error(result.error);
+  return result.value;
+};
+const tools = Object.freeze(Object.fromEntries(
+  ${JSON.stringify(toolNames)}.map((name) => [name, (input) =>
+    __nanocodex_call_tool(name, JSON.stringify(input ?? null)).then(__nanocodex_decode)])
+));
+const ALL_TOOLS = Object.freeze(${JSON.stringify(toolDefinitions)});
+const text = (value) => __nanocodex_emit("text", JSON.stringify(__nanocodex_stringify(value)));
+const image = (value, detail) =>
+  __nanocodex_emit("image", JSON.stringify({ value, detail }));
+const audio = (value) => __nanocodex_emit("audio", JSON.stringify(value));
+const notify = (value) => __nanocodex_emit("notify", JSON.stringify(__nanocodex_stringify(value)));
+const yield_control = () => __nanocodex_emit("yield_control", "null");
+const __nanocodex_timers = new Map();
+let __nanocodex_next_timer = 1;
+const setTimeout = (callback, delay = 0) => {
+  const id = __nanocodex_next_timer++;
+  __nanocodex_timers.set(id, callback);
+  __nanocodex_sleep(Number(delay) || 0).then(() => {
+    const callback = __nanocodex_timers.get(id);
+    __nanocodex_timers.delete(id);
+    callback?.();
+  });
+  return id;
+};
+const clearTimeout = (id) => __nanocodex_timers.delete(id);
+const generatedImage = (value) =>
+  __nanocodex_emit("generatedImage", JSON.stringify(value));
+const store = (key, value) => {
+  if (typeof key !== "string") throw new TypeError("store key must be a string");
+  __nanocodex_store(key, JSON.stringify({ value }));
+};
+const load = (key) => JSON.parse(__nanocodex_load(key)).value;
+const exit = () => { throw __nanocodex_exit; };
+const require = undefined;
+const console = Object.freeze(Object.fromEntries(
+  ["debug", "info", "log", "warn", "error"].map((level) => [level, (...values) =>
+    __nanocodex_log(level, JSON.stringify(values.map(__nanocodex_stringify)))])
+));
+(async () => {
+  try {
+${source}
+  } catch (error) {
+    if (error !== __nanocodex_exit) throw error;
+  }
+})()
+`;
+}
+
+function errorMessage(error) {
+  if (error && (error.stack || error.message)) return error.stack || error.message;
+  return String(error);
+}
+
+async function invokeTool(environment, name, encodedInput) {
+  try {
+    const tool = environment.tools[name];
+    if (typeof tool !== "function") throw new Error(`unknown application tool: ${name}`);
+    const value = await tool(JSON.parse(encodedInput));
+    return JSON.stringify({ ok: true, value });
+  } catch (error) {
+    return JSON.stringify({ ok: false, error: errorMessage(error) });
+  }
+}

package/runtime/response-controls.mjs

@@ -0,0 +1,42 @@
+/** Apply stable managed response policy at the provider wire boundary, including replay. */
+export function responseControlsSocket(socket, controls = {}) {
+  if (controls.promptCacheKey !== undefined && (typeof controls.promptCacheKey !== "string" || controls.promptCacheKey.length === 0 || controls.promptCacheKey.length > 64)) {
+    throw new TypeError("invalid prompt cache key");
+  }
+  if (controls.promptCache !== undefined && !["implicit", "explicit"].includes(controls.promptCache)) {
+    throw new TypeError("invalid prompt cache mode");
+  }
+  if (controls.outputSchema !== undefined && (!controls.outputSchema || typeof controls.outputSchema !== "object" || Array.isArray(controls.outputSchema))) {
+    throw new TypeError("output schema must be an object");
+  }
+  return new Proxy({}, {
+    get(_target, property) {
+      const target = socket;
+      if (property === "send") return (data, ...args) => {
+        const body = typeof data === "string" ? JSON.parse(data) : undefined;
+        if (body?.type === "response.create") {
+          if (controls.promptCacheKey !== undefined) body.prompt_cache_key = controls.promptCacheKey;
+          if (controls.outputSchema !== undefined) body.text = {
+            ...body.text, format: { type: "json_schema", name: "managed_output", strict: true, schema: controls.outputSchema },
+          };
+          if (controls.promptCache !== undefined) {
+            body.prompt_cache_options = { mode: controls.promptCache, ttl: "30m" };
+            if (controls.promptCache === "explicit") {
+              // Cache the developer context without marking changing user input.
+              // Continuations with no prefix intentionally do not write new cache entries.
+              const developers = (Array.isArray(body.input) ? body.input : []).filter(item => item.role === "developer");
+              const text = developers.flatMap(item => Array.isArray(item.content) ? item.content : [])
+                .filter(part => part.type === "input_text").at(-1);
+              if (text) text.prompt_cache_breakpoint = { mode: "explicit" };
+            }
+          }
+          return target.send(JSON.stringify(body), ...args);
+        }
+        return target.send(data, ...args);
+      };
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    set(_target, property, value) { return Reflect.set(socket, property, value, socket); },
+  });
+}

package/runtime/response-lanes.mjs

@@ -0,0 +1,72 @@
+/** Multiplex an already authenticated Responses WebSocket. The caller owns its lifetime. */
+export function multiplex(socket) {
+  if (!socket || typeof socket.addEventListener !== "function" || typeof socket.send !== "function") throw new TypeError("multiplex requires a WebSocket");
+  const lanes = new Map();
+  const used = new Set();
+  const broadcast = event => { for (const lane of lanes.values()) lane.dispatchEvent(event()); };
+  const onMessage = event => {
+    try {
+      const data = typeof event.data === "string" ? event.data
+        : new TextDecoder().decode(event.data instanceof ArrayBuffer ? event.data : new Uint8Array(event.data.buffer, event.data.byteOffset, event.data.byteLength));
+      const message = JSON.parse(data);
+      if (message.stream_id !== undefined) lanes.get(message.stream_id)?.dispatchEvent(new MessageEvent("message", { data }));
+      else if (message.type === "error") broadcast(() => new MessageEvent("message", { data }));
+    } catch { broadcast(() => new Event("error")); }
+  };
+  const onOpen = () => broadcast(() => new Event("open"));
+  const onError = () => broadcast(() => new Event("error"));
+  const onClose = event => { for (const lane of [...lanes.values()]) lane.close(event.code, event.reason); };
+  socket.addEventListener("message", onMessage);
+  socket.addEventListener("open", onOpen);
+  socket.addEventListener("error", onError);
+  socket.addEventListener("close", onClose);
+  return Object.freeze({
+    lane(id) {
+      if (typeof id !== "string" || !/^[A-Za-z0-9_.-]{1,256}$/.test(id)) throw new TypeError("invalid Responses stream ID");
+      if (lanes.has(id)) return lanes.get(id);
+      if (!used.has(id) && used.size >= 32) throw new RangeError("a Responses socket supports 32 distinct named streams");
+      if (socket.readyState > 1) throw new Error("Responses socket is closed");
+      used.add(id);
+      let closed = false;
+      const lane = new EventTarget();
+      for (const type of ["open", "message", "error", "close"]) {
+        let handler = null;
+        Object.defineProperty(lane, `on${type}`, { configurable: true, enumerable: true,
+          get: () => handler,
+          set(value) { if (handler) lane.removeEventListener(type, handler); handler = typeof value === "function" ? value : null; if (handler) lane.addEventListener(type, handler); },
+        });
+      }
+      Object.defineProperties(lane, {
+        url: { get: () => socket.url },
+        protocol: { get: () => socket.protocol ?? "" },
+        extensions: { get: () => socket.extensions ?? "" },
+        CONNECTING: { value: 0 }, OPEN: { value: 1 }, CLOSING: { value: 2 }, CLOSED: { value: 3 },
+        readyState: { get: () => closed ? 3 : socket.readyState },
+        bufferedAmount: { get: () => socket.bufferedAmount },
+        binaryType: { get: () => socket.binaryType, set: value => { socket.binaryType = value; } },
+        send: { value: data => {
+          if (closed || socket.readyState !== 1) throw new Error("Responses lane is not open");
+          const body = JSON.parse(data);
+          if (body.type !== "response.create") throw new TypeError("multiplexed lanes accept response.create only");
+          if (body.stream_id !== undefined && body.stream_id !== id) throw new TypeError("request belongs to a different lane");
+          delete body.stream; delete body.background;
+          // Lineage is caller-owned; never substitute the most recent response on another lane.
+          socket.send(JSON.stringify({ ...body, stream_id: id }));
+        } },
+        close: { value: (code = 1000, reason = "lane released") => {
+          if (closed) return; closed = true; lanes.delete(id);
+          const event = new Event("close"); Object.assign(event, { code, reason, wasClean: code === 1000 });
+          lane.dispatchEvent(event);
+        } },
+      });
+      lanes.set(id, lane);
+      return lane;
+    },
+    close(code = 1000, reason = "Responses pool closed") {
+      for (const lane of [...lanes.values()]) lane.close(code, reason);
+      socket.removeEventListener("message", onMessage); socket.removeEventListener("open", onOpen);
+      socket.removeEventListener("error", onError); socket.removeEventListener("close", onClose);
+      socket.close(code, reason);
+    },
+  });
+}

package/runtime/responses-transport.mjs

@@ -0,0 +1,22 @@
+const responsesTransports = new WeakMap();
+
+export function createResponsesTransport(setup) {
+  const transport = Object.freeze({});
+  responsesTransports.set(transport, Object.freeze({ ...setup }));
+  return transport;
+}
+
+export function resolveResponsesTransport(transport) {
+  const setup = responsesTransports.get(transport);
+  if (setup === undefined) {
+    throw new TypeError("Agent.create requires a Responses transport");
+  }
+  return setup;
+}
+
+export function nonEmpty(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}

package/runtime/subagents.d.mts

@@ -0,0 +1,107 @@
+import type { DefaultAgent, Thinking } from "../types.mjs";
+
+// Adapter-specific extend() signatures do not change subagent ownership.
+type SubagentOwner = Omit<DefaultAgent, "extend">;
+
+declare const subagentToolBrand: unique symbol;
+
+/** Opaque selector for the Rust-owned subagent tool set. */
+export type Tool = Readonly<{
+  [subagentToolBrand]: true;
+}>;
+
+export type Subagents = readonly [Tool];
+
+export interface Options {
+  /** Optional finite concurrency limit. Omit for unlimited active turns. */
+  maxConcurrency?: number | undefined;
+}
+
+export type AgentId = number;
+export type AgentStatus =
+  | Readonly<{ state: "pending" | "running" | "interrupted" | "closing" | "closed" }>
+  | Readonly<{ state: "completed"; output: unknown }>
+  | Readonly<{ state: "failed"; error: string }>;
+export type AgentSummary = Readonly<{
+  agent_id: AgentId;
+  role: string;
+  task: string;
+  parent_agent_id: AgentId | null;
+  status: AgentStatus;
+  last_output?: unknown;
+}>;
+export type JsonSchema = boolean | Readonly<Record<string, unknown>>;
+export type SpawnOptions = Readonly<{
+  role: string;
+  task: string;
+  model?: "sol" | "terra" | "luna" | "astra" | undefined;
+  thinking?: Thinking | undefined;
+  outputSchema: JsonSchema;
+}>;
+export type BatchSpawnOptions = Readonly<{
+  role: string;
+  task: string;
+  outputSchema: JsonSchema;
+}>;
+export type SpawnReport = Readonly<{
+  agent_id: AgentId;
+  role: string;
+  status: Readonly<{ state: "running" }>;
+}>;
+export type WaitOptions = Readonly<{
+  agentIds: readonly AgentId[];
+  timeoutMs?: number | undefined;
+}>;
+export type WaitReport = Readonly<{
+  agents: readonly AgentSummary[];
+  timed_out: boolean;
+}>;
+export type LifecycleReport = Readonly<{ agents: readonly AgentSummary[] }>;
+export type DirectoryEntry = AgentSummary & Readonly<{
+  can_message: boolean;
+  can_manage: boolean;
+}>;
+export type DirectoryOptions = Readonly<{
+  includeCompleted?: boolean | undefined;
+  includeSelf?: boolean | undefined;
+}>;
+export type DirectoryReport = Readonly<{ agents: readonly DirectoryEntry[] }>;
+export type MessagePriority = "deferred" | "urgent";
+export type MessagePurpose = "delegate" | "coordinate" | "finding" | "question" | "reply";
+export type MessageSender =
+  | Readonly<{ kind: "root" }>
+  | Readonly<{ kind: "agent"; agent_id: AgentId }>;
+export type SendOptions = Readonly<{
+  agentId: AgentId;
+  message: string;
+  priority?: MessagePriority | undefined;
+  purpose?: MessagePurpose | undefined;
+  inReplyTo?: number | undefined;
+}>;
+export type MessageReceipt = Readonly<{
+  message_id: number;
+  thread_id: number;
+  from: MessageSender;
+  to_agent_id: AgentId;
+  disposition: "started" | "queued" | "steered";
+}>;
+
+/** Returns a spreadable Rust-backed tool extension for an Agent's tools array. */
+export function create(options?: Options): Subagents;
+/** Directly invokes the canonical Rust spawn_agent handler. */
+export function spawn(agent: SubagentOwner, options: SpawnOptions): Promise<SpawnReport>;
+/** Atomically reserves and starts an ordered batch of canonical Rust subagents. */
+export function spawnMany(
+  agent: SubagentOwner,
+  options: readonly BatchSpawnOptions[],
+): Promise<readonly SpawnReport[]>;
+/** Directly invokes the canonical Rust wait_agent handler. */
+export function wait(agent: SubagentOwner, options: WaitOptions): Promise<WaitReport>;
+/** Directly invokes the canonical Rust list_agents handler. */
+export function list(agent: SubagentOwner, options?: DirectoryOptions): Promise<DirectoryReport>;
+/** Directly invokes the canonical Rust send_agent_message handler. */
+export function send(agent: SubagentOwner, options: SendOptions): Promise<MessageReceipt>;
+/** Directly invokes the canonical Rust interrupt_agent handler. */
+export function interrupt(agent: SubagentOwner, agentId: AgentId): Promise<LifecycleReport>;
+/** Directly invokes the canonical Rust close_agent handler. */
+export function close(agent: SubagentOwner, agentId: AgentId): Promise<LifecycleReport>;

package/runtime/subagents.mjs

@@ -0,0 +1,54 @@
+import {
+  closeSubagent,
+  interruptSubagent,
+  listSubagents,
+  sendSubagentMessage,
+  spawnSubagent,
+  spawnSubagents,
+  waitSubagents,
+} from "../internal.mjs";
+import {
+  defaultSubagentMaxConcurrency,
+  subagentsBrand,
+} from "./tool-configuration.mjs";
+
+export function create(options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("Subagents.create options must be an object");
+  }
+  const maxConcurrency = options.maxConcurrency ?? defaultSubagentMaxConcurrency;
+  if (maxConcurrency !== undefined && (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1)) {
+    throw new TypeError("subagents maxConcurrency must be a positive safe integer");
+  }
+  return Object.freeze([Object.freeze({
+    [subagentsBrand]: Object.freeze({ maxConcurrency }),
+  })]);
+}
+
+export function spawn(agent, options) {
+  return spawnSubagent(agent, options);
+}
+
+export function spawnMany(agent, options) {
+  return spawnSubagents(agent, options);
+}
+
+export function wait(agent, options) {
+  return waitSubagents(agent, options);
+}
+
+export function list(agent, options) {
+  return listSubagents(agent, options);
+}
+
+export function send(agent, options) {
+  return sendSubagentMessage(agent, options);
+}
+
+export function interrupt(agent, agentId) {
+  return interruptSubagent(agent, agentId);
+}
+
+export function close(agent, agentId) {
+  return closeSubagent(agent, agentId);
+}

package/runtime/subscription-store.d.mts

@@ -0,0 +1,8 @@
+export declare function subscriptionRevision(
+  value: string | bigint,
+): import("../types.mjs").SubscriptionRevision;
+
+export declare function createMemoryChatGptSubscriptionStore(
+  id: string,
+  initial?: import("../types.mjs").SubscriptionStoredValue,
+): import("../types.mjs").MemoryChatGptSubscriptionStore;

package/runtime/subscription-store.mjs

@@ -0,0 +1,42 @@
+const MAX_REVISION = 18_446_744_073_709_551_615n;
+
+export function subscriptionRevision(value) {
+  const revision = String(value);
+  if (!/^(0|[1-9][0-9]*)$/.test(revision) || BigInt(revision) > MAX_REVISION) {
+    throw new TypeError("subscription revision must be an unsigned 64-bit decimal string");
+  }
+  return revision;
+}
+
+export function createMemoryChatGptSubscriptionStore(id, initial) {
+  if (typeof id !== "string" || !id.trim()) {
+    throw new TypeError("subscription ID must be a non-empty string");
+  }
+  let stored = Object.freeze({
+    revision: subscriptionRevision(initial?.revision ?? 0n),
+    ...(initial?.payload === undefined ? {} : { payload: initial.payload }),
+  });
+  const select = (selected) => {
+    if (selected !== id) throw new Error(`unknown ChatGPT subscription: ${selected}`);
+  };
+  return Object.freeze({
+    id,
+    load(selected) {
+      select(selected);
+      return stored;
+    },
+    compareAndSwap(selected, request) {
+      select(selected);
+      const expectedRevision = subscriptionRevision(request.expectedRevision);
+      if (expectedRevision !== stored.revision) {
+        return { status: "conflict", actualRevision: stored.revision };
+      }
+      const revision = subscriptionRevision(BigInt(stored.revision) + 1n);
+      stored = Object.freeze({ revision, payload: request.payload });
+      return { status: "committed", revision };
+    },
+    snapshot() {
+      return stored;
+    },
+  });
+}