iterate 0.3.0 → 0.4.0

package/dist/{next/client → client}/socket.d.ts

@@ -1,5 +1,6 @@
 export declare function openSocketWithRetry(url: string | URL, options?: {
     delaysMs?: readonly number[];
+    handshakeTimeoutMs?: number;
     /** the constructor to use — a test's fake, `WebSocket` otherwise */
     WebSocket?: typeof WebSocket;
     sleep?: (ms: number) => Promise<void>;

package/dist/client.mjs

@@ -1,4 +1,156 @@
-import { a as disconnectIterateSession, c as reconnectIterateSession, d as retryFailedIterateSession, l as releaseItxConnection, m as watchItxConnection, n as connectIterateSession, o as isItxTransportError, r as connectItx, t as configureIterateSession, u as reportTransportSuspicion } from "./itx-session-sjud8GiT.mjs";
-import "./live-state-BJNqOwFw.mjs";
-import { o as applyPatch, r as createLiveStateStore, s as diff } from "./protocol-DnK_f2m6.mjs";
-export { applyPatch, configureIterateSession, connectIterateSession, connectItx, createLiveStateStore, diff, disconnectIterateSession, isItxTransportError, reconnectIterateSession, releaseItxConnection, reportTransportSuspicion, retryFailedIterateSession, watchItxConnection };
+import { applyPatch } from "./lib.mjs";
+import { z } from "zod";
+//#region src/client/live-state.ts
+/** The delta as it arrives over the wire — PARSED, never cast: `from`/`to` MUST be real numbers (a
+*  non-numeric rev would poison the held revision and silently wedge every later frame), and each
+*  patch op is a known RFC-6902-subset shape. A frame that fails this heals by re-reading the seed
+*  rather than being applied — the same recovery the store already runs on a revision gap. */
+const LiveStateDeltaMessage = z.object({
+	key: z.string(),
+	from: z.number(),
+	to: z.number(),
+	patch: z.array(z.union([
+		z.object({
+			op: z.literal("add"),
+			path: z.string(),
+			value: z.unknown()
+		}),
+		z.object({
+			op: z.literal("replace"),
+			path: z.string(),
+			value: z.unknown()
+		}),
+		z.object({
+			op: z.literal("remove"),
+			path: z.string()
+		})
+	])).nullable()
+});
+function createLiveStateStore() {
+	let held = {
+		rev: null,
+		state: void 0
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => listeners.forEach((l) => l());
+	return {
+		get: () => held.state,
+		rev: () => held.rev,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		},
+		seed: (seed) => {
+			if (held.rev !== null && seed.rev < held.rev) return;
+			held = {
+				rev: seed.rev,
+				state: seed.state
+			};
+			notify();
+		},
+		apply: (delta, resync) => {
+			if (held.rev !== null && delta.to <= held.rev) return;
+			if (delta.from !== held.rev || !delta.patch) {
+				resync();
+				return;
+			}
+			held = {
+				rev: delta.to,
+				state: applyPatch(held.state, delta.patch)
+			};
+			notify();
+		}
+	};
+}
+/** Subscribe to a producer's live state and reduce it into a store. `readSeed` reads the seed
+*  (`itx.invoke("itx.facets.get('slug').liveSnapshot()")` for a processor, or a mini-app's
+*  own `state()` method). Subscribe happens BEFORE the first seed, so a delta racing the seed just
+*  triggers one seed re-read — never a lost update. Gap heals are SINGLE-FLIGHT (a burst of gapped
+*  frames triggers one seed read, not one per frame); a failed heal is reported through `onResync`
+*  and retried by the next delivered delta (its `from` still mismatches, so it re-triggers). */
+async function connectLiveState(itx, opts) {
+	const store = createLiveStateStore();
+	let healing = false;
+	let healWantedAgain = false;
+	let disposed = false;
+	const reseed = () => {
+		if (disposed) return;
+		if (healing) {
+			healWantedAgain = true;
+			return;
+		}
+		healing = true;
+		const settled = () => {
+			healing = false;
+			if (disposed || !healWantedAgain) return;
+			healWantedAgain = false;
+			reseed();
+		};
+		opts.readSeed().then((s) => {
+			if (!disposed) {
+				store.seed(s);
+				opts.onResync?.("healed");
+			}
+			settled();
+		}, (e) => {
+			if (!disposed) opts.onResync?.(e instanceof Error ? e : new Error(String(e)));
+			settled();
+		});
+	};
+	const subscription = await itx.subscribe({
+		name: opts.name,
+		consumes: ["events.iterate.com/itx/live-state-changed"],
+		target: (events) => {
+			if (disposed) return;
+			for (const e of events) {
+				let parsed;
+				try {
+					parsed = LiveStateDeltaMessage.safeParse(JSON.parse(JSON.stringify(e.payload)));
+				} catch {
+					parsed = void 0;
+				}
+				if (!parsed?.success) {
+					reseed();
+					continue;
+				}
+				if (parsed.data.key !== opts.key) continue;
+				try {
+					store.apply(parsed.data, reseed);
+				} catch {
+					reseed();
+				}
+			}
+		}
+	});
+	try {
+		const seed = opts.readSeed();
+		const { signal } = opts;
+		const aborted = signal && new Promise((_, reject) => {
+			const abort = () => reject(signal.reason ?? /* @__PURE__ */ new Error("connectLiveState: aborted while the first seed was pending"));
+			if (signal.aborted) abort();
+			else signal.addEventListener("abort", abort, { once: true });
+		});
+		if (aborted) seed.catch(() => void 0);
+		store.seed(await (aborted ? Promise.race([seed, aborted]) : seed));
+	} catch (error) {
+		disposed = true;
+		try {
+			subscription[Symbol.dispose]();
+		} catch {}
+		throw error;
+	}
+	return {
+		store,
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			try {
+				subscription[Symbol.dispose]();
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { connectLiveState, createLiveStateStore };
+
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../src/client/live-state.ts"],"sourcesContent":["// client/live-state.ts — THE CLIENT HALF of live state (`iterate/client`), framework-free, for\n// browsers and node test clients. Two concepts:\n//   live state store  — `createLiveStateStore`: the pure reduce — seed from the producer, apply each delta, heal on a gap\n//   live state client — `connectLiveState`: wire an itx session's `subscribe` + a seed read to the store\n\nimport { z } from \"zod\";\nimport { applyPatch, type PatchOp } from \"../lib.ts\";\n\n// ── live state store ── THE CLIENT HALF of live state, for browsers and node test clients.\n// A deliberately small store for the platform's live-state wire:\n//\n//   • SEED from the producer — `{rev, state}` read via an RPC method (a processor's\n//     `liveSnapshot()`, a mini-app's `state()`).\n//   • APPLY each `{key, from, to, patch}` delta the subscription delivers: a patch lands only when\n//     its `from` matches the held rev; a mismatch means a missed delta (or a reborn producer's fresh\n//     epoch) — resync by re-reading the seed.\n//\n// The patch format is lib.ts (an RFC-6902 subset), so this store shares ONE applyPatch with\n// the producer — no second diff implementation. No capnweb import: a caller wires the transport and\n// hands deltas in, so the same store backs a node test client and the React hook (client/react.tsx).\n\n/** One live-state delta off the wire — the payload of an `events.iterate.com/itx/live-state-changed`\n *  ephemeral event, delivered raw to the subscriber. `patch: null` = the change was too large to\n *  send — the rev moved, re-read the seed. */\nexport type LiveStateDelta = { key: string; from: number; to: number; patch: PatchOp[] | null };\n\n/** The delta as it arrives over the wire — PARSED, never cast: `from`/`to` MUST be real numbers (a\n *  non-numeric rev would poison the held revision and silently wedge every later frame), and each\n *  patch op is a known RFC-6902-subset shape. A frame that fails this heals by re-reading the seed\n *  rather than being applied — the same recovery the store already runs on a revision gap. */\nconst LiveStateDeltaMessage: z.ZodType<LiveStateDelta> = z.object({\n  key: z.string(),\n  from: z.number(),\n  to: z.number(),\n  patch: z\n    .array(\n      z.union([\n        z.object({ op: z.literal(\"add\"), path: z.string(), value: z.unknown() }),\n        z.object({ op: z.literal(\"replace\"), path: z.string(), value: z.unknown() }),\n        z.object({ op: z.literal(\"remove\"), path: z.string() }),\n      ]),\n    )\n    .nullable(),\n});\n\n/** What the producer's seed read returns: the current revision paired with the current value. */\nexport type LiveStateSeed<S> = { rev: number; state: S };\n\nexport type LiveStateStore<S> = {\n  /** The current value, or undefined until the first seed lands. */\n  get(): S | undefined;\n  /** The held revision, or null before the first seed. */\n  rev(): number | null;\n  /** Subscribe to changes (for React's useSyncExternalStore, or a test's await-loop). */\n  subscribe(listener: () => void): () => void;\n  /** Seed (or re-seed) from a seed read — the first paint, and the heal after a gap. */\n  seed(seed: LiveStateSeed<S>): void;\n  /** Reduce one delta in; on a revision gap call `resync` and hold the value until a fresh seed. */\n  apply(delta: LiveStateDelta, resync: () => void): void;\n};\n\nexport function createLiveStateStore<S>(): LiveStateStore<S> {\n  // `rev: null` until the first seed lands.\n  let held: { rev: number | null; state: S | undefined } = { rev: null, state: undefined };\n  const listeners = new Set<() => void>();\n  const notify = () => listeners.forEach((l) => l());\n  return {\n    get: () => held.state,\n    rev: () => held.rev,\n    subscribe: (listener) => {\n      listeners.add(listener);\n      return () => void listeners.delete(listener);\n    },\n    seed: (seed) => {\n      // MONOTONIC: a late-resolving OLDER seed read must never move the store backwards past state\n      // deltas have already advanced (a delta-triggered resync can race the initial seed). Revisions\n      // are time-seeded epochs plus increments, so \"newer\" is numeric.\n      if (held.rev !== null && seed.rev < held.rev) return;\n      held = { rev: seed.rev, state: seed.state };\n      notify();\n    },\n    apply: (delta, resync) => {\n      // A delta at-or-behind the held rev is a duplicate/out-of-order frame — drop it silently.\n      // (Epochs are minted from the clock, so a reborn producer's fresh chain sits numerically above\n      // every rev an old chain handed out; a frame wholly behind us is genuinely old. The one\n      // exception is a clock that regressed across a producer rebirth — accepted: the next applied\n      // or gapped frame resyncs from a fresh seed anyway.)\n      if (held.rev !== null && delta.to <= held.rev) return;\n      // A gap (its `from` is not the held rev — including \"no seed yet\") means a missed delta or a\n      // reborn epoch, and a `null` patch means the change was too large to send — either way re-read\n      // the seed instead of applying onto a diverged base.\n      if (delta.from !== held.rev || !delta.patch) {\n        resync();\n        return;\n      }\n      held = { rev: delta.to, state: applyPatch(held.state as S, delta.patch) };\n      notify();\n    },\n  };\n}\n\n// ── live state client ── wire an itx session's `subscribe` + a seed read to a LiveStateStore.\n// This is the whole cleanroom client: a subscription that consumes the one live-state event type\n// (`itx.subscribe({ target, consumes: [\"events.iterate.com/itx/live-state-changed\"] })`) delivers every\n// key's deltas in batches; this filters the watched `key` and reduces each delta into the store; a\n// `readSeed` thunk reads `{rev, state}` for the first paint and every gap heal. Transport lives here so\n// the store above and the React hook stay pure.\n\n/** The slice of an itx session this needs — a capnweb `IterateContextRpcTarget` proxy satisfies it structurally:\n *  `subscribe` hands back a DISPOSABLE handle (disposing it removes the subscription server-side). */\nexport type LiveStateItx = {\n  subscribe(input: {\n    name?: string;\n    consumes?: string[];\n    target: (events: unknown[], range: unknown) => void;\n  }): Promise<{ [Symbol.dispose](): void }>;\n};\n\n/** A connected live-state subscription: the store rendering it, and the dispose that removes the\n *  server-side subscription (the handle's disposer; the session's end does the same). */\nexport type LiveStateConnection<S> = {\n  store: LiveStateStore<S>;\n  /** Unsubscribe on the server and stop reducing deltas. Safe to call more than once. */\n  dispose(): Promise<void>;\n};\n\n/** Subscribe to a producer's live state and reduce it into a store. `readSeed` reads the seed\n *  (`itx.invoke(\"itx.facets.get('slug').liveSnapshot()\")` for a processor, or a mini-app's\n *  own `state()` method). Subscribe happens BEFORE the first seed, so a delta racing the seed just\n *  triggers one seed re-read — never a lost update. Gap heals are SINGLE-FLIGHT (a burst of gapped\n *  frames triggers one seed read, not one per frame); a failed heal is reported through `onResync`\n *  and retried by the next delivered delta (its `from` still mismatches, so it re-triggers). */\nexport async function connectLiveState<S>(\n  itx: LiveStateItx,\n  opts: {\n    key: string;\n    name?: string;\n    readSeed: () => Promise<LiveStateSeed<S>>;\n    /** Called after each gap heal attempt: \"healed\" on a fresh seed, the error when the seed read\n     *  failed (the store keeps its last value; the next delta retries). */\n    onResync?: (result: \"healed\" | Error) => void;\n    /** Abort while the FIRST seed is still pending (a component unmounting): the row just configured\n     *  is recalled and the connect rejects — a seed read that never answers leaves nothing lent. */\n    signal?: AbortSignal;\n  },\n): Promise<LiveStateConnection<S>> {\n  const store = createLiveStateStore<S>();\n  let healing = false;\n  let healWantedAgain = false; // a gap seen WHILE a heal was in flight: the seed may predate it\n  let disposed = false;\n  const reseed = () => {\n    if (disposed) return;\n    if (healing) {\n      healWantedAgain = true;\n      return;\n    }\n    healing = true;\n    const settled = () => {\n      healing = false;\n      if (disposed || !healWantedAgain) return;\n      healWantedAgain = false;\n      reseed();\n    };\n    void opts.readSeed().then(\n      (s) => {\n        if (!disposed) {\n          store.seed(s);\n          opts.onResync?.(\"healed\");\n        }\n        settled();\n      },\n      (e: unknown) => {\n        if (!disposed) opts.onResync?.(e instanceof Error ? e : new Error(String(e)));\n        settled();\n      },\n    );\n  };\n  const subscription = await itx.subscribe({\n    name: opts.name,\n    consumes: [\"events.iterate.com/itx/live-state-changed\"],\n    // A batch of live-state deltas (every key's); keep the watched key's.\n    target: (events: unknown[]) => {\n      if (disposed) return;\n      for (const e of events) {\n        // capnweb hands each event as a live proxy value — deep-copy to a plain object, then PARSE\n        // the frame (never cast network data). The whole decode is guarded: an ABSENT payload makes\n        // `JSON.parse(JSON.stringify(undefined))` throw before validation, and any throw here would\n        // skip every later delta in the batch. A malformed OR undecodable frame heals from a fresh seed\n        // instead of poisoning the held rev or escaping this callback.\n        let parsed: ReturnType<(typeof LiveStateDeltaMessage)[\"safeParse\"]> | undefined;\n        try {\n          parsed = LiveStateDeltaMessage.safeParse(\n            JSON.parse(JSON.stringify((e as { payload: unknown }).payload)),\n          );\n        } catch {\n          parsed = undefined;\n        }\n        if (!parsed?.success) {\n          reseed();\n          continue;\n        }\n        if (parsed.data.key !== opts.key) continue;\n        // `store.apply` runs `applyPatch`, which THROWS on a patch it refuses (a `/__proto__` path a\n        // legitimate state with an own `__proto__` key produces, say). Contain it per frame: heal from\n        // a fresh seed — which re-seeds the state DIRECTLY, no patch to reject — instead of escaping this\n        // callback and skipping every later frame.\n        try {\n          store.apply(parsed.data, reseed);\n        } catch {\n          reseed();\n        }\n      }\n    },\n  });\n  try {\n    const seed = opts.readSeed();\n    const { signal } = opts;\n    const aborted =\n      signal &&\n      new Promise<never>((_, reject) => {\n        const abort = () =>\n          reject(\n            signal.reason ??\n              new Error(\"connectLiveState: aborted while the first seed was pending\"),\n          );\n        if (signal.aborted) abort();\n        else signal.addEventListener(\"abort\", abort, { once: true });\n      });\n    if (aborted) seed.catch(() => undefined); // the seed read may still settle after the abort — quietly\n    store.seed(await (aborted ? Promise.race([seed, aborted]) : seed));\n  } catch (error) {\n    // The seed failed after the row was configured: recall it, or the server keeps delivering to a\n    // callback no one holds (and the session's other rows wait behind it).\n    disposed = true;\n    try {\n      subscription[Symbol.dispose]();\n    } catch {\n      // a dead session has already removed it\n    }\n    throw error;\n  }\n  return {\n    store,\n    async dispose() {\n      if (disposed) return;\n      disposed = true;\n      try {\n        subscription[Symbol.dispose](); // the server removes the row and recalls the lent callback\n      } catch {\n        // a dead session has already removed it — the socket close disposed every handle\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/{next/expression.d.ts → expression.d.ts}

@@ -4,13 +4,13 @@ import { RpcTarget } from "capnweb";
  *  is `["itx","builtins","rpcStubs",["get","cam"],["",1,2]]` — what a `provide(stub)` rule spells when
  *  the lent stub is called with args. */
 export type ItxExpressionStep = string | [method: string, ...args: unknown[]];
-/** An itx expression as data: the scope root (`itx`) then get/call steps. THE parsed form every door
- *  works on. */
+/** An itx expression as data: the scope root (`itx`) then get/call steps. THE parsed form every
+ *  dispatching method works on. */
 export type ItxExpression = ItxExpressionStep[];
 /** THE dispatch target, in EITHER codec half — a dotted string that starts with the scope root
  *  (`"itx.facets.get('core')"`) OR the parsed structured form (`["itx","facets",["get","core"]]`).
  *  Both carry call args (the string via `.method(args)`), and `normalizedItxExpression` normalizes
- *  either to the structured form — so either works wherever one works, at every door that dispatches. */
+ *  either to the structured form — so either works wherever one works, in every method that dispatches. */
 export type ItxExpressionInput = string | ItxExpression;
 /** An itx-expression PREFIX — a rewrite rule's `match`: dotted names, any of which may be a call step
  *  PINNING literal args — `itx.ai.run` or `itx.ai.run('gpt-5')` or `itx.repo.get('main').files`. A
@@ -20,7 +20,7 @@ export type ItxExpressionInput = string | ItxExpression;
 export type ItxExpressionPrefix = ItxExpression;
 /** The name a step carries: the property itself, or a call step's method. */
 export declare const itxExpressionStepName: (step: ItxExpressionStep | undefined) => string | undefined;
-/** The merge entry's key — `...@` — read by rule 7. */
+/** The merge entry's key — `...@` — read by apps/os `fillItxExpressionHoles`. */
 export declare const ITX_EXPRESSION_MERGE_KEY = "...@";
 /** Is `value` the marker literal `{ "@": true }`? */
 export declare const isItxExpressionHole: (value: unknown) => boolean;
@@ -32,8 +32,8 @@ export declare function containsItxExpressionHole(value: unknown): boolean;
 export declare function parse(source: string, options?: {
     holes?: boolean;
 }): ItxExpression;
-/** THE ONE NORMALIZING DOOR: either half, normalized to the array half and checked — a string is
- *  parsed (short by rule), an array is shape-checked in place. Every door that takes an
+/** THE ONE NORMALIZER: either half, normalized to the array half and checked — a string is
+ *  parsed (short by rule), an array is shape-checked in place. Every function that takes an
  *  `ItxExpressionInput` (the edge `invoke`, the resolver, the event builders, the prefix parser
  *  below) enters through it. */
 export declare function normalizedItxExpression(input: ItxExpressionInput, options?: {
@@ -60,33 +60,6 @@ export declare function parseItxExpressionPrefix(source: ItxExpressionInput): It
  *  stub is keyed by through `provide`'s sugar: parsed, then printed (dotted names; pinned args as JSON5
  *  literals). */
 export declare function canonicalItxExpressionPrefix(source: ItxExpressionInput): string;
-/** Register a pipelinable promise brand (the workerd entrypoint's two calls at boot). */
-export declare function registerPipelinedRpcBrand(brand: abstract new (...args: never[]) => unknown): void;
-/**
- * THE step walk: property steps `Reflect.get` with the receiver carried; call steps `Reflect.apply`
- * ON that receiver (detaching a method from a Workers-RPC receiver breaks it); an ordinary promise
- * is awaited between steps, a branded one (PIPELINED_RPC_BRANDS, above) is not.
- *
- * ⚠️  DataCloneError LEARNING:
- * invoke facet/RPC-stub methods with `Reflect.apply(fn, receiver, args)`, NEVER `stub[m].apply(stub,
- * args)`. Reading `.apply` off an RPC stub's method proxy is a capnweb PIPELINED REMOTE PATH;
- * calling it passes the stub as an argument, so workerd serializes it — and a Worker-Loader facet
- * stub may never be serialized (`requireAllowsTransfer()` throws unconditionally) → `DataCloneError:
- * Durable Object Facet stubs cannot be transferred between Workers`. Do not "simplify" this away.
- */
-export declare function walkSteps(start: {
-    value: unknown;
-    receiver: unknown;
-}, steps: ItxExpression): Promise<{
-    value: unknown;
-    receiver: unknown;
-}>;
-/** Apply `args` to a resolved value on its carried receiver, or a LOUD error if it is not callable
- *  (never the silent arg-drop apps/os shipped). An `InvokeHandle` is NOT a JS function (a real
- *  RpcTarget so dotted access pipelines — the invoke handle section), so ROOT-calling it dispatches
- *  those args at its EMPTY path: `handle(events,range)` ⇒ the bare callback the handle fronts. The one
- *  bridge between "callable capability" and "pipelinable RpcTarget". */
-export declare function callOn(value: unknown, receiver: unknown, args: unknown[]): Promise<unknown>;
 /** Install the hop drawn in the header on a class's PROTOTYPE CHAIN, with the scope `root` (`["itx"]`
  *  for the edge context, `[]` for a handle). Call ONCE per class. Constructor inheritance is
  *  untouched — only `Class.prototype`'s parent link changes, and the hop forwards everything it does
@@ -100,47 +73,16 @@ export declare function installPrototypeInvokeFallback<T extends abstract new (.
 export declare class InvokeHandle extends RpcTarget {
     #private;
     constructor(dispatchItxExpressionSteps: (itxExpressionSteps: ItxExpression) => unknown);
-    /** THE reduce door the prototype hop dispatches onto; the expression is RELATIVE to this handle. */
+    /** THE dispatch method the prototype hop reduces onto; the expression is RELATIVE to this handle. */
     invoke(itxExpressionSteps: ItxExpression): unknown;
-    /** Call the bare capability this handle fronts — the ANONYMOUS call step (`callOn` in the dispatch section
-     *  uses it when a rewritten call's target IS a handle: `handle(events, range)`). */
+    /** Call the bare capability this handle fronts — the ANONYMOUS call step (how a rewritten call
+     *  whose target IS a handle calls it: `handle(events, range)`). */
     applyRoot(args: unknown[]): unknown;
 }
 /** Walk itx-expression steps off a capnweb stub; the ANONYMOUS call step (`""`) calls the value
  *  itself (a bare function lent as a capability). NO await inside the loop: on a capnweb stub every
  *  step is a PIPELINED path, so an n-step chain costs ONE round trip, flushed by the caller's single
  *  await. A DIRECT call on the stub, never `.apply`: reading `.apply` off a capnweb stub's method is
- *  itself a pipelined remote path (`walkSteps`'s DataCloneError learning). Exported for the library
- *  tier, which may import this module only. */
+ *  itself a pipelined remote path, and calling it sends the stub as an argument, which a facet stub
+ *  refuses with a DataCloneError. What a connector over a lent stub or a remote capnweb API walks. */
 export declare function walkStepsOnRpcStub(stub: unknown, steps: ItxExpression): unknown;
-/** `itx.facets.get(name)` / `itx.facets.get(name, { source, className })` — a facet of this context. */
-export declare class FacetHandle extends InvokeHandle {
-}
-/** A HANDLE ON THE WIRE IS THE EXPRESSION THAT NAMES IT. An `InvokeHandle` a context mints (`repos.get(path)`,
- *  `workspaces.get(path)`, `facets.get(name)`, `cd(path)`, `workers.get(spec)`) holds no state — it is a
- *  dispatch closure over a path — yet as a Workers-RPC result it would cross a hop as a LIVE stub whose
- *  session keeps the context's actor resident for as long as the holder keeps it (prd 2026-09-22: ~125
- *  such sessions parked around the clock). So the context's RPC door answers with THIS instead: the
- *  caller's own expression, which from the caller's root denotes the same handle; the caller mints its
- *  own handle over it (`materializeItxHandleReference`), and every later verb is one whole call the
- *  context resolves from scratch. Nothing outlives a call. A lent client stub (`RpcStubHandle`) is the
- *  one handle that IS live and crosses as itself. */
-export declare const ITX_HANDLE_REFERENCE_KEY = "$itxHandleExpression";
-export type ItxHandleReference = {
-    [ITX_HANDLE_REFERENCE_KEY]: ItxExpression;
-};
-export declare const isItxHandleReference: (value: unknown) => value is ItxHandleReference;
-/** What a context's RPC door hands back for `expression`'s result: a reference when the result is a
- *  path-shaped handle (an `InvokeHandle` that is not a lent stub) or a reference from a hop below —
- *  re-rooted, since `expression` is how THIS caller reached it — else nothing (the result crosses as it
- *  is). Runtime args that fold into a terminal NAME fold here exactly as the resolver folds them, so the
- *  reference is the call the resolver ran; args left over apply to the value and never name a handle. */
-export declare function itxHandleReferenceOf(result: unknown, expression: ItxExpression, args?: unknown[]): ItxHandleReference | undefined;
-/** The holder's side: a reference becomes a handle of the HOLDER's own whose every dotted call is one
- *  whole expression through `invoke` — the reference's expression plus the steps. Anything else passes
- *  through untouched. The proxy hands relative steps; a caller's own `.invoke("itx.whoami()")` is a
- *  whole call, spelled from the root. */
-export declare function materializeItxHandleReference(result: unknown, invoke: (expression: ItxExpression) => unknown): unknown;
-/** `itx.rpcStubs.get(key)` — a live stub lent to the registry. */
-export declare class RpcStubHandle extends InvokeHandle {
-}

package/dist/{next/expression.mjs → expression.mjs}

@@ -1,11 +1,11 @@
 import { codedError, jsonEqual } from "./lib.mjs";
 import { RpcTarget } from "capnweb";
 import JSON5 from "json5";
-//#region src/next/expression.ts
+//#region src/expression.ts
 /** A STRING expression is for what a person types: short. Anything bigger — a worker's source, a large
 *  literal — rides the PARSED form (`["itx","workers",["get",{ source }]]`), which is plain data and never
 *  meets json5. The cap is O(1), before any parsing (stock json5 allocates per character and a
-*  multi-megabyte literal kills a 128 MiB isolate — the 2026-09-07 wave-0 plan, issue 2). */
+*  multi-megabyte literal kills a 128 MiB isolate). */
 const ITX_EXPRESSION_STRING_MAX_CHARS = 2048;
 /** The name a step carries: the property itself, or a call step's method. */
 const itxExpressionStepName = (step) => Array.isArray(step) ? step[0] : step;
@@ -17,7 +17,7 @@ const RESERVED = new Set([
 ]);
 /** The marker's array-half spelling, the one reserved literal. */
 const ITX_EXPRESSION_HOLE = { "@": true };
-/** The merge entry's key — `...@` — read by rule 7. */
+/** The merge entry's key — `...@` — read by apps/os `fillItxExpressionHoles`. */
 const ITX_EXPRESSION_MERGE_KEY = "...@";
 /** A single- or double-quoted string literal (escapes honored) or a JSON5 comment (block or line):
 *  THE one pattern every walk that must skip what is inside them is built from — the marker lex, the
@@ -131,8 +131,8 @@ function assertItxExpressionShape(expression) {
 		if (i === 0) fail("a call on the root itself");
 	});
 }
-/** THE ONE NORMALIZING DOOR: either half, normalized to the array half and checked — a string is
-*  parsed (short by rule), an array is shape-checked in place. Every door that takes an
+/** THE ONE NORMALIZER: either half, normalized to the array half and checked — a string is
+*  parsed (short by rule), an array is shape-checked in place. Every function that takes an
 *  `ItxExpressionInput` (the edge `invoke`, the resolver, the event builders, the prefix parser
 *  below) enters through it. */
 function normalizedItxExpression(input, options) {
@@ -178,68 +178,6 @@ function parseItxExpressionPrefix(source) {
 function canonicalItxExpressionPrefix(source) {
 	return print(parseItxExpressionPrefix(source));
 }
-const PIPELINED_RPC_BRANDS = [];
-/** Register a pipelinable promise brand (the workerd entrypoint's two calls at boot). */
-function registerPipelinedRpcBrand(brand) {
-	PIPELINED_RPC_BRANDS.push(brand);
-}
-const pipelined = (v) => PIPELINED_RPC_BRANDS.some((b) => v instanceof b);
-/** Resolve one step's property. `__proto__` / `constructor` / `prototype` never resolve — `constructor`
-*  would hand out the class itself (trusted clients or not, that is not a step anyone means). */
-function stepGet(value, key) {
-	if (key === "__proto__" || key === "constructor" || key === "prototype") return void 0;
-	return Reflect.get(value, key);
-}
-/**
-* THE step walk: property steps `Reflect.get` with the receiver carried; call steps `Reflect.apply`
-* ON that receiver (detaching a method from a Workers-RPC receiver breaks it); an ordinary promise
-* is awaited between steps, a branded one (PIPELINED_RPC_BRANDS, above) is not.
-*
-* ⚠️  DataCloneError LEARNING:
-* invoke facet/RPC-stub methods with `Reflect.apply(fn, receiver, args)`, NEVER `stub[m].apply(stub,
-* args)`. Reading `.apply` off an RPC stub's method proxy is a capnweb PIPELINED REMOTE PATH;
-* calling it passes the stub as an argument, so workerd serializes it — and a Worker-Loader facet
-* stub may never be serialized (`requireAllowsTransfer()` throws unconditionally) → `DataCloneError:
-* Durable Object Facet stubs cannot be transferred between Workers`. Do not "simplify" this away.
-*/
-async function walkSteps(start, steps) {
-	let { value, receiver } = start;
-	for (const [stepIndex, step] of steps.entries()) {
-		if (!pipelined(value)) value = await value;
-		if (value == null) throw new Error(`hit ${String(value)} at step ${stepIndex + 1} of ${print(steps)} (${JSON.stringify(step)})`);
-		if (typeof step === "string") {
-			receiver = value;
-			value = stepGet(value, step);
-		} else {
-			const [method, ...args] = step;
-			if (method === "") {
-				value = callOn(value, receiver, args);
-				receiver = void 0;
-				if (!pipelined(value)) value = await value;
-				continue;
-			}
-			const fn = stepGet(value, method);
-			if (typeof fn !== "function") throw codedError("NOT_A_METHOD", `${JSON.stringify(method)} is not a method at step ${stepIndex + 1} of ${print(steps)}`);
-			receiver = void 0;
-			value = Reflect.apply(fn, value, args);
-			if (!pipelined(value)) value = await value;
-		}
-	}
-	return {
-		value: pipelined(value) ? value : await value,
-		receiver
-	};
-}
-/** Apply `args` to a resolved value on its carried receiver, or a LOUD error if it is not callable
-*  (never the silent arg-drop apps/os shipped). An `InvokeHandle` is NOT a JS function (a real
-*  RpcTarget so dotted access pipelines — the invoke handle section), so ROOT-calling it dispatches
-*  those args at its EMPTY path: `handle(events,range)` ⇒ the bare callback the handle fronts. The one
-*  bridge between "callable capability" and "pipelinable RpcTarget". */
-async function callOn(value, receiver, args) {
-	if (typeof value === "function") return Reflect.apply(value, receiver, args);
-	if (value instanceof InvokeHandle) return value.applyRoot(args);
-	throw codedError("NOT_A_METHOD", `target is not callable but ${args.length} arg(s) were passed`);
-}
 /** Names that must NEVER become dynamic capability segments — a dispatcher answering them would turn
 *  a plain property probe into a live capability call. Enforced at the prototype-chain hop and at
 *  every depth of the path proxies it hands out. Two kinds, one set: */
@@ -331,12 +269,12 @@ var InvokeHandle = class extends RpcTarget {
 		super();
 		this.#dispatchItxExpressionSteps = dispatchItxExpressionSteps;
 	}
-	/** THE reduce door the prototype hop dispatches onto; the expression is RELATIVE to this handle. */
+	/** THE dispatch method the prototype hop reduces onto; the expression is RELATIVE to this handle. */
 	invoke(itxExpressionSteps) {
 		return this.#dispatchItxExpressionSteps(itxExpressionSteps);
 	}
-	/** Call the bare capability this handle fronts — the ANONYMOUS call step (`callOn` in the dispatch section
-	*  uses it when a rewritten call's target IS a handle: `handle(events, range)`). */
+	/** Call the bare capability this handle fronts — the ANONYMOUS call step (how a rewritten call
+	*  whose target IS a handle calls it: `handle(events, range)`). */
 	applyRoot(args) {
 		return this.#dispatchItxExpressionSteps([["", ...args]]);
 	}
@@ -346,8 +284,8 @@ installPrototypeInvokeFallback(InvokeHandle, []);
 *  itself (a bare function lent as a capability). NO await inside the loop: on a capnweb stub every
 *  step is a PIPELINED path, so an n-step chain costs ONE round trip, flushed by the caller's single
 *  await. A DIRECT call on the stub, never `.apply`: reading `.apply` off a capnweb stub's method is
-*  itself a pipelined remote path (`walkSteps`'s DataCloneError learning). Exported for the library
-*  tier, which may import this module only. */
+*  itself a pipelined remote path, and calling it sends the stub as an argument, which a facet stub
+*  refuses with a DataCloneError. What a connector over a lent stub or a remote capnweb API walks. */
 function walkStepsOnRpcStub(stub, steps) {
 	let value = stub;
 	for (const step of steps) if (typeof step === "string") value = value[step];
@@ -357,43 +295,7 @@ function walkStepsOnRpcStub(stub, steps) {
 	}
 	return value;
 }
-/** `itx.facets.get(name)` / `itx.facets.get(name, { source, className })` — a facet of this context. */
-var FacetHandle = class extends InvokeHandle {};
-/** A HANDLE ON THE WIRE IS THE EXPRESSION THAT NAMES IT. An `InvokeHandle` a context mints (`repos.get(path)`,
-*  `workspaces.get(path)`, `facets.get(name)`, `cd(path)`, `workers.get(spec)`) holds no state — it is a
-*  dispatch closure over a path — yet as a Workers-RPC result it would cross a hop as a LIVE stub whose
-*  session keeps the context's actor resident for as long as the holder keeps it (prd 2026-09-22: ~125
-*  such sessions parked around the clock). So the context's RPC door answers with THIS instead: the
-*  caller's own expression, which from the caller's root denotes the same handle; the caller mints its
-*  own handle over it (`materializeItxHandleReference`), and every later verb is one whole call the
-*  context resolves from scratch. Nothing outlives a call. A lent client stub (`RpcStubHandle`) is the
-*  one handle that IS live and crosses as itself. */
-const ITX_HANDLE_REFERENCE_KEY = "$itxHandleExpression";
-const isItxHandleReference = (value) => Boolean(value) && typeof value === "object" && Array.isArray(value["$itxHandleExpression"]);
-/** What a context's RPC door hands back for `expression`'s result: a reference when the result is a
-*  path-shaped handle (an `InvokeHandle` that is not a lent stub) or a reference from a hop below —
-*  re-rooted, since `expression` is how THIS caller reached it — else nothing (the result crosses as it
-*  is). Runtime args that fold into a terminal NAME fold here exactly as the resolver folds them, so the
-*  reference is the call the resolver ran; args left over apply to the value and never name a handle. */
-function itxHandleReferenceOf(result, expression, args = []) {
-	const last = expression.at(-1);
-	const folded = args.length > 0 && typeof last === "string" && expression.length > 1 ? [...expression.slice(0, -1), [last, ...args]] : args.length > 0 ? void 0 : expression;
-	if (!folded) return void 0;
-	if (!(result instanceof InvokeHandle && !(result instanceof RpcStubHandle)) && !isItxHandleReference(result)) return void 0;
-	return { [ITX_HANDLE_REFERENCE_KEY]: folded };
-}
-/** The holder's side: a reference becomes a handle of the HOLDER's own whose every dotted call is one
-*  whole expression through `invoke` — the reference's expression plus the steps. Anything else passes
-*  through untouched. The proxy hands relative steps; a caller's own `.invoke("itx.whoami()")` is a
-*  whole call, spelled from the root. */
-function materializeItxHandleReference(result, invoke) {
-	if (!isItxHandleReference(result)) return result;
-	const expression = result[ITX_HANDLE_REFERENCE_KEY];
-	return new InvokeHandle((steps) => invoke(typeof steps === "string" || steps[0] === "itx" ? normalizedItxExpression(steps) : [...expression, ...steps]));
-}
-/** `itx.rpcStubs.get(key)` — a live stub lent to the registry. */
-var RpcStubHandle = class extends InvokeHandle {};
 //#endregion
-export { FacetHandle, ITX_EXPRESSION_MERGE_KEY, ITX_HANDLE_REFERENCE_KEY, InvokeHandle, RpcStubHandle, callOn, canonicalItxExpressionPrefix, containsItxExpressionHole, installPrototypeInvokeFallback, isItxExpressionHole, isItxHandleReference, itxExpressionStepName, itxHandleReferenceOf, keySortedForPrint, materializeItxHandleReference, normalizedItxExpression, parse, parseItxExpressionPrefix, print, registerPipelinedRpcBrand, walkSteps, walkStepsOnRpcStub };
+export { ITX_EXPRESSION_MERGE_KEY, InvokeHandle, canonicalItxExpressionPrefix, containsItxExpressionHole, installPrototypeInvokeFallback, isItxExpressionHole, itxExpressionStepName, keySortedForPrint, normalizedItxExpression, parse, parseItxExpressionPrefix, print, walkStepsOnRpcStub };
 
 //# sourceMappingURL=expression.mjs.map

package/dist/expression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.mjs","names":["#dispatchItxExpressionSteps"],"sources":["../src/expression.ts"],"sourcesContent":["// expression.ts — THE expression codec: the STRING half (itx.facets.get(\"core\")) ⇄ the\n// STRUCTURED half ([\"itx\", \"facets\", [\"get\", \"core\"]]). Args are ONE JSON5 grammar, comments included\n// (no hand-rolled number/object parser; __proto__-safe); expressions are persisted NAMES, so deleting\n// one IS revocation. One more concept rides with the codec, because user code speaks it too:\n//   invoke handle — `InvokeHandle` + the prototype hop: the DOTTED SURFACE, every unknown chain one\n//                   `invoke(expression)` — what `itx.facets.get(name)` and every other mid-chain\n//                   capability of api.ts is, and what a connector builds over a remote API\n// What the PLATFORM does with an expression is apps/os: the rewrite rules (match, rank, rewrite) are\n// src/context/itx-expression-rewriting.ts, and executing a rewritten call against a live object graph\n// (`walkSteps`, the answer a context hands back) is src/context/dispatch.ts.\nimport JSON5 from \"json5\";\nimport { RpcTarget } from \"capnweb\";\nimport { codedError, jsonEqual } from \"./lib.ts\";\n\n/** A STRING expression is for what a person types: short. Anything bigger — a worker's source, a large\n *  literal — rides the PARSED form (`[\"itx\",\"workers\",[\"get\",{ source }]]`), which is plain data and never\n *  meets json5. The cap is O(1), before any parsing (stock json5 allocates per character and a\n *  multi-megabyte literal kills a 128 MiB isolate). */\nconst ITX_EXPRESSION_STRING_MAX_CHARS = 2048;\n\n/** One step: a property read (string) or a call (`[method, ...args]`). Args are plain JSON. The\n *  method `\"\"` is the ANONYMOUS call — call the value itself: `itx.builtins.rpcStubs.get('cam')(1, 2)`\n *  is `[\"itx\",\"builtins\",\"rpcStubs\",[\"get\",\"cam\"],[\"\",1,2]]` — what a `provide(stub)` rule spells when\n *  the lent stub is called with args. */\nexport type ItxExpressionStep = string | [method: string, ...args: unknown[]];\n/** An itx expression as data: the scope root (`itx`) then get/call steps. THE parsed form every\n *  dispatching method works on. */\nexport type ItxExpression = ItxExpressionStep[];\n/** THE dispatch target, in EITHER codec half — a dotted string that starts with the scope root\n *  (`\"itx.facets.get('core')\"`) OR the parsed structured form (`[\"itx\",\"facets\",[\"get\",\"core\"]]`).\n *  Both carry call args (the string via `.method(args)`), and `normalizedItxExpression` normalizes\n *  either to the structured form — so either works wherever one works, in every method that dispatches. */\nexport type ItxExpressionInput = string | ItxExpression;\n/** An itx-expression PREFIX — a rewrite rule's `match`: dotted names, any of which may be a call step\n *  PINNING literal args — `itx.ai.run` or `itx.ai.run('gpt-5')` or `itx.repo.get('main').files`. A\n *  pinned arg must equal the call's arg at that position for the rule to match, and is CONSUMED by\n *  the match (partial application): `itx.ai.run('gpt-5') ⇒ itx.openai.chat` makes\n *  `itx.ai.run('gpt-5', inputs)` into `itx.openai.chat(inputs)`. */\nexport type ItxExpressionPrefix = ItxExpression;\n/** The name a step carries: the property itself, or a call step's method. */\nexport const itxExpressionStepName = (step: ItxExpressionStep | undefined): string | undefined =>\n  Array.isArray(step) ? step[0] : step;\n\nconst IDENT = /^[A-Za-z_$][A-Za-z0-9_$-]*/;\nconst RESERVED = new Set([\"__proto__\", \"constructor\", \"prototype\"]);\n\n// ── `@`, THE CALLER'S INPUT — a rewrite rule's target may hold it, nothing else may ──\n// In the string half a bare `@` outside a string literal is the marker (`'@cf/…'` inside quotes is a\n// string like any other); `...@` as an object-literal entry is the merge form. In the array half the\n// marker is ONE reserved literal, `{ \"@\": true }`, and the merge entry the key `\"...@\"` with the value\n// `true` — so the stored form is plain JSON, and those two spellings are unspellable as literals in a\n// target (the codec's one reservation). What `@` MEANS is `fillItxExpressionHoles` in\n// apps/os/src/context/itx-expression-rewriting.ts; here it is only lexed (parse, targets only) and\n// printed back (print, targets only).\n/** The marker's array-half spelling, the one reserved literal. */\nconst ITX_EXPRESSION_HOLE = { \"@\": true } as const;\n/** The merge entry's key — `...@` — read by apps/os `fillItxExpressionHoles`. */\nexport const ITX_EXPRESSION_MERGE_KEY = \"...@\";\n\n/** A single- or double-quoted string literal (escapes honored) or a JSON5 comment (block or line):\n *  THE one pattern every walk that must skip what is inside them is built from — the marker lex, the\n *  marker print, the paren matcher. In an alternation a span is consumed whole, so nothing inside one\n *  (a quote in a comment, an `@` in a string) is ever seen by the other alternatives. */\nconst STRING_OR_COMMENT = String.raw`\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"|'(?:[^'\\\\]|\\\\[\\s\\S])*'|/\\*[\\s\\S]*?\\*/|//[^\\n]*`;\nconst isStringOrComment = (match: string): boolean =>\n  match[0] === '\"' || match[0] === \"'\" || match[0] === \"/\";\n/** In call args: a literal (kept verbatim) or a marker — `...@` before `@`, so the merge form wins. */\nconst MARKERS_IN_ARGS = new RegExp(`${STRING_OR_COMMENT}|\\\\.\\\\.\\\\.@|@`, \"g\");\n/** In JSON5's printed output: the marker literal `{'@':true}` and the merge entry `'...@':true` are\n *  spelled with a single-quoted key and matched on those exact boundaries — listed BEFORE the literal\n *  alternative so the entry's `'...@'` is read as the entry, not as a string. A user's string that\n *  merely contains those characters is emitted by JSON5 as a longer (double-quoted) literal and is\n *  consumed whole. */\nconst MARKERS_IN_PRINT = new RegExp(`\\\\{'@':true\\\\}|'\\\\.\\\\.\\\\.@':true|${STRING_OR_COMMENT}`, \"g\");\n/** A bracket outside a literal. */\nconst BRACKETS = new RegExp(`${STRING_OR_COMMENT}|[()[\\\\]{}]`, \"g\");\n\n/** Is `value` the marker literal `{ \"@\": true }`? */\nexport const isItxExpressionHole = (value: unknown): boolean =>\n  jsonEqual(value, ITX_EXPRESSION_HOLE);\n\n/** Does `value` (a step, an arg tree, a whole expression) hold the marker or a merge entry anywhere? */\nexport function containsItxExpressionHole(value: unknown): boolean {\n  if (isItxExpressionHole(value)) return true;\n  if (Array.isArray(value)) return value.some(containsItxExpressionHole);\n  // oxlint-disable-next-line iterate/simple-truthiness-check -- `value` is `unknown`; the typeof separates real objects from primitives (a bare truthiness check would recurse into strings/numbers)\n  if (value !== null && typeof value === \"object\")\n    return (\n      (value as Record<string, unknown>)[ITX_EXPRESSION_MERGE_KEY] === true ||\n      Object.values(value).some(containsItxExpressionHole)\n    );\n  return false;\n}\n\n/** Index of the `)` closing the `(` at `open`; tracks bracket depth, skipping quoted string args. */\nfunction matchingParen(source: string, open: number): number {\n  let depth = 0;\n  BRACKETS.lastIndex = open;\n  for (let bracket = BRACKETS.exec(source); bracket; bracket = BRACKETS.exec(source)) {\n    if (isStringOrComment(bracket[0])) continue;\n    if (\"([{\".includes(bracket[0])) depth++;\n    else if (--depth === 0) return bracket.index;\n  }\n  throw new Error(`expression: unbalanced \"(\" in ${JSON.stringify(source)}`);\n}\n\n/** Parse the STRING half: dotted names + `.method(args)` calls (args JSON5-parsed); rejects reserved\n *  names + bare scope calls. `holes: true` — a rewrite rule's TARGET only — lexes `@` / `...@` into\n *  the marker literals; anywhere else a bare `@` is refused. */\nexport function parse(source: string, options?: { holes?: boolean }): ItxExpression {\n  if (source.length > ITX_EXPRESSION_STRING_MAX_CHARS)\n    throw codedError(\n      \"EXPRESSION_TOO_LONG\",\n      `itx expression: ${source.length} chars is over the ${ITX_EXPRESSION_STRING_MAX_CHARS}-char limit for the string form — a string expression is for what a person types; pass the parsed form instead: [\"itx\",\"workers\",[\"get\",{ source: … }]]`,\n    );\n  const s = source.trim();\n  const steps: ItxExpression = [];\n  let i = 0;\n  function fail(m: string): never {\n    throw new Error(`expression: ${m} in ${JSON.stringify(source)}`); // decl, not arrow: TS never-narrows\n  }\n  const readName = (): string => {\n    const m = IDENT.exec(s.slice(i));\n    if (!m) fail(`name expected at ${i}`);\n    if (RESERVED.has(m[0])) fail(`reserved name \"${m[0]}\"`);\n    i += m[0].length;\n    return m[0];\n  };\n  steps.push(readName()); // the scope root (itx)\n  while (i < s.length) {\n    const c = s[i];\n    if (/\\s/.test(c)) i++;\n    else if (c === \".\") steps.push((i++, readName()));\n    else if (c === \"(\") {\n      const end = matchingParen(s, i);\n      const raw = s.slice(i + 1, end).trim();\n      // `@` outside a string literal: the marker (targets only), a refusal everywhere else.\n      const inner = raw.replace(MARKERS_IN_ARGS, (match) => {\n        if (isStringOrComment(match)) return match;\n        if (!options?.holes)\n          fail(\"`@` (the caller's input) is legal only in a rewrite rule's target\");\n        return match === \"@\"\n          ? JSON.stringify(ITX_EXPRESSION_HOLE)\n          : `${JSON.stringify(ITX_EXPRESSION_MERGE_KEY)}:true`;\n      });\n      let args: unknown[] = [];\n      try {\n        if (inner !== \"\") args = JSON5.parse(`[${inner}]`) as unknown[];\n      } catch (e) {\n        fail(`call args are not JSON5 (${(e as Error).message})`);\n      }\n      const previous = steps.at(-1);\n      if (Array.isArray(previous))\n        steps.push([\"\", ...args]); // `f(x)(y)`: call the result itself\n      else {\n        const name = steps.pop();\n        if (typeof name !== \"string\") fail(\"a call must follow a name\");\n        if (steps.length === 0) fail(\"cannot call the scope symbol itself\");\n        steps.push([name, ...args]);\n      }\n      i = end + 1;\n    } else fail(`unexpected ${JSON.stringify(c)} at ${i}`);\n  }\n  return steps;\n}\n\n/** The array half, checked the way the parser checks the string half — every name step an identifier\n *  that is not reserved, every call step `[method, ...args]` with an identifier method (or `\"\"`, the\n *  anonymous call, only right after a call) — WITHOUT printing and re-parsing: a stored target carries a worker's whole source as\n *  data, and that data must never meet the string codec (the 2 KiB cap, json5). Throws in the\n *  parser's words. */\nfunction assertItxExpressionShape(expression: ItxExpression): void {\n  const fail = (m: string): never => {\n    throw new Error(`expression: ${m} in ${JSON.stringify(expression).slice(0, 200)}`);\n  };\n  // oxlint-disable-next-line iterate/simple-truthiness-check -- runtime shape validation of wire/stored data; the ItxExpression array type is a claim here, not a guarantee\n  if (!Array.isArray(expression) || expression.length === 0)\n    fail(\"an expression is a non-empty array\");\n  const name = (step: string, what: string) => {\n    if (!IDENT.test(step) || IDENT.exec(step)![0] !== step)\n      fail(`${what} ${JSON.stringify(step)} is not an identifier`);\n    if (RESERVED.has(step)) fail(`reserved name \"${step}\"`);\n  };\n  expression.forEach((step, i) => {\n    if (typeof step === \"string\") {\n      name(step, i === 0 ? \"the root\" : \"a name step\");\n      return;\n    }\n    // oxlint-disable-next-line iterate/simple-truthiness-check -- runtime shape validation of wire/stored data; the step's static array type is a claim here, not a guarantee\n    if (!Array.isArray(step) || typeof step[0] !== \"string\")\n      fail(`step ${i} is neither a name nor [method, ...args]`);\n    const [method] = step;\n    if (method === \"\") {\n      if (i === 0 || !Array.isArray(expression[i - 1]))\n        fail(\"the anonymous call `f(x)(y)` follows a call\");\n    } else name(method, \"a method\");\n    if (i === 0) fail(\"a call on the root itself\");\n  });\n  // No hole check on the array half: `{ \"@\": true }` carried as DATA is data (edge#6) — only the\n  // STRING form lexes a bare `@` into the marker, and only for a rule's target.\n}\n\n/** THE ONE NORMALIZER: either half, normalized to the array half and checked — a string is\n *  parsed (short by rule), an array is shape-checked in place. Every function that takes an\n *  `ItxExpressionInput` (the edge `invoke`, the resolver, the event builders, the prefix parser\n *  below) enters through it. */\nexport function normalizedItxExpression(\n  input: ItxExpressionInput,\n  options?: { holes?: boolean },\n): ItxExpression {\n  if (typeof input === \"string\") return parse(input, options);\n  assertItxExpressionShape(input);\n  return input;\n}\n\n/** Object args print with their keys SORTED, so two spellings of one object are one canonical string\n *  — one rewrite-rule row, one facet memo, one library connection memo (library.ts) — the way\n *  `jsonEqual` already matches them. A `JSON.stringify` / `JSON5.stringify` replacer. */\nexport const keySortedForPrint = (_key: string, value: unknown): unknown =>\n  // oxlint-disable-next-line iterate/simple-truthiness-check -- `value` is `unknown` (a JSON replacer arg); the typeof discriminates real objects from primitive values\n  value !== null && typeof value === \"object\" && !Array.isArray(value)\n    ? Object.fromEntries(\n        Object.keys(value as Record<string, unknown>)\n          .sort()\n          .map((k) => [k, (value as Record<string, unknown>)[k]]),\n      )\n    : value;\n\n/** Canonical stored form: dotted path + `.method(args)` calls (args `JSON5.stringify`d, object keys\n *  sorted). `holes: true` — a rewrite rule's TARGET only — spells the marker literals back as `@` /\n *  `...@`, and `parse(print(e, { holes: true }), { holes: true })` round-trips; without it the\n *  reserved literals print as the plain JSON5 they are, so a CALL that happens to carry `{ \"@\": true }`\n *  as data round-trips through `parse` (no holes) unchanged — the resolve/invoke law holds for it. */\nexport function print(expr: ItxExpression, options?: { holes?: boolean }): string {\n  return expr\n    .map((step, i) => {\n      const dot = i ? \".\" : \"\";\n      if (typeof step === \"string\") return dot + step;\n      const json = JSON5.stringify(step.slice(1), keySortedForPrint).slice(1, -1);\n      const args = options?.holes\n        ? json.replace(MARKERS_IN_PRINT, (match) =>\n            match === \"{'@':true}\" ? \"@\" : match === \"'...@':true\" ? \"...@\" : match,\n          )\n        : json;\n      return step[0] === \"\" ? `(${args})` : `${dot}${step[0]}(${args})`;\n    })\n    .join(\"\");\n}\n\n/** Parse an itx-expression prefix (either codec half) — `normalizedItxExpression` (so every step is\n *  an identifier that is not reserved, in either half) plus the two refusals only a PREFIX has: the\n *  anonymous call step (`f(x)(y)` — a prefix cannot call a result), and a call step with NO args,\n *  which pins nothing and is the same prefix as the plain name: spell `itx.ai.run`. */\nexport function parseItxExpressionPrefix(source: ItxExpressionInput): ItxExpressionPrefix {\n  const expr = normalizedItxExpression(source);\n  const spelled = typeof source === \"string\" ? source : print(expr);\n  for (const step of expr) {\n    if (!Array.isArray(step)) continue;\n    if (step[0] === \"\")\n      throw new Error(`an itx-expression prefix cannot call a result — ${JSON.stringify(spelled)}`);\n    if (step.length === 1)\n      throw new Error(\n        `an itx-expression prefix pins literal args with a call step — ${JSON.stringify(spelled)} has \"${step[0]}()\" with none; spell \"${step[0]}\"`,\n      );\n  }\n  return expr;\n}\n\n/** THE ONE canonical spelling of an itx-expression prefix — the rewrite-rule table's key, what a lent\n *  stub is keyed by through `provide`'s sugar: parsed, then printed (dotted names; pinned args as JSON5\n *  literals). */\nexport function canonicalItxExpressionPrefix(source: ItxExpressionInput): string {\n  return print(parseItxExpressionPrefix(source));\n}\n\n// ── invoke handle ── THE DOTTED SURFACE: how a surface that declares only fixed methods is\n// spoken as deep dotted access (`itx.slack.chat.postMessage({...})`), every unknown segment\n// accumulating into ONE `invoke(expression)` dispatch, `[...root, ...prefix, [method, ...args]]`.\n// Declared members always win. The pieces: the reserved names, the function-backed PATH PROXY, the\n// PROTOTYPE HOP that installs the fallback on a class, `InvokeHandle` (the genuine RpcTarget a\n// mid-chain capability is handed back as), and `walkStepsOnRpcStub`.\n//\n// WHY A PROTOTYPE HOP AND NOT A PROXY AROUND THE INSTANCE (tried FIRST and reverted): workerd RPC\n// classifies a call's RESULT for promise pipelining with native brand checks a JS Proxy can never\n// pass (`serializeJsValueWithPipeline` in worker-rpc.c++ → `NonPipelinable`; cloudflare/workerd#6873).\n// So a surface returned FROM A METHOD must hand back a REAL, unproxied instance or every pipelined\n// call on it dies with \"The RPC receiver does not implement the method ...\". A mid-chain call\n// returns its handle ACROSS an RPC boundary (`itx.facets.get('b').hello()` is two dispatches), and\n// capnweb's RpcTarget IS the native `cloudflare:workers` RpcTarget on workerd, so a real RpcTarget\n// passes on both hops. The hop squares that with dynamic dispatch by inserting one proxied link\n// BETWEEN `Class.prototype` and its parent:\n//\n//   instance ──proto──▶ Class.prototype ──proto──▶ Proxy(hop) ──proto──▶ parent\n//\n// - The instance is a genuine, natively-branded RpcTarget → the pipeline classifier accepts it.\n// - Declared members resolve BEFORE the hop — built-ins win, so a dynamic capability can never\n//   shadow a declared name (the deliberate trade-off).\n// - Unknown string keys reach the hop's `get` trap and become path proxies, dispatched via the\n//   receiver's own `invoke`; the receiver IS the invoker, so it wires with zero glue.\n// - Instances stay clean of own properties, so Workers RPC's instance-property protection needs\n//   no `getOwnPropertyDescriptor` help.\n//\n// KNOWN QUIRKS: no `has` trap on the hop, so `\"x\" in instance`\n// reflects DECLARED members only while `instance.x` conjures a dispatcher — feature-detect with\n// access, not `in`; a typo'd built-in (`itx.strems`) is a syntactically valid dynamic dispatch that\n// fails at the capability table, not a crisp missing-method error.\n//\n// apps/os's library tier (src/library.ts) builds its connectors on this section and the codec, as a\n// userspace worker would (library.test.ts pins that).\n\n/** The dispatch method every dotted miss collapses onto. `IterateContextRpcTarget` implements it directly (root\n *  `itx`); a mid-chain `InvokeHandle` implements it relative to itself (empty root). */\ntype InvokeTarget = {\n  invoke(itxExpression: ItxExpression): unknown;\n};\n\n/** Names that must NEVER become dynamic capability segments — a dispatcher answering them would turn\n *  a plain property probe into a live capability call. Enforced at the prototype-chain hop and at\n *  every depth of the path proxies it hands out. Two kinds, one set: */\nconst RESERVED_SEGMENT_NAMES: ReadonlySet<string> = new Set([\n  // JS/RPC protocol machinery a framework or capnweb probes on any object (`then` above all: an\n  // instance must never look thenable, or every `await` of it would resolve a capability).\n  \"__defineGetter__\",\n  \"__defineSetter__\",\n  \"__lookupGetter__\",\n  \"__lookupSetter__\",\n  \"__proto__\",\n  \"apply\",\n  \"bind\",\n  \"call\",\n  \"catch\",\n  \"constructor\",\n  \"dup\",\n  \"finally\",\n  \"hasOwnProperty\",\n  \"isPrototypeOf\",\n  \"map\",\n  \"onRpcBroken\",\n  \"propertyIsEnumerable\",\n  \"prototype\",\n  \"then\",\n  \"toLocaleString\",\n  \"toString\",\n  \"valueOf\",\n  // Names common protocols LOOK UP on arbitrary objects and CALL if callable: JSON.stringify\n  // (toJSON) and vitest/jest equality (asymmetricMatch). The asymmetricMatch case is worse than\n  // noise — vitest treats any object with a callable asymmetricMatch as an asymmetric matcher, and\n  // a dispatcher returning a (truthy) Promise makes the equality SPURIOUSLY PASS. The bar for this\n  // half is HIGH (these names become unreachable as dotted segments; explicit invoke still\n  // reaches them): probed-and-called by ubiquitous protocols AND implausible as capability names.\n  \"toJSON\",\n  \"asymmetricMatch\",\n]);\n\n/** The path proxy: a function-backed Proxy (not an RpcTarget instance) — each missing property\n *  extends `path`, and applying the function reduces the whole accumulated access into ONE\n *  `invoke(expression)` call, `[...root, ...path.slice(0, -1), [path.at(-1), ...args]]`. */\nfunction createItxExpressionPathProxy(\n  invoker: InvokeTarget,\n  root: readonly string[],\n  path: string[],\n): unknown {\n  const valueFor = (key: string) => createItxExpressionPathProxy(invoker, root, [...path, key]);\n  return new Proxy(function () {}, {\n    apply(_target, _thisArg, args) {\n      const method = path[path.length - 1];\n      const expr: ItxExpression = [...root, ...path.slice(0, -1), [method, ...(args as unknown[])]];\n      return invoker.invoke(expr);\n    },\n    get(target, key, receiver) {\n      if (typeof key === \"symbol\") return Reflect.get(target, key, receiver);\n      if (RESERVED_SEGMENT_NAMES.has(key)) return undefined;\n      return valueFor(key);\n    },\n    getOwnPropertyDescriptor(target, key) {\n      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);\n      if (descriptor) return descriptor;\n      if (typeof key === \"symbol\" || RESERVED_SEGMENT_NAMES.has(key)) return undefined;\n      // Cap'n Web's server-side path traversal probes own descriptors before reading a segment, so\n      // dynamic roots must look discoverable here to reach the apply trap.\n      return { configurable: true, enumerable: true, value: valueFor(key), writable: false };\n    },\n    has(target, key) {\n      if (typeof key === \"symbol\") return key in target;\n      return !RESERVED_SEGMENT_NAMES.has(key);\n    },\n  });\n}\n\n/** Install the hop drawn in the header on a class's PROTOTYPE CHAIN, with the scope `root` (`[\"itx\"]`\n *  for the edge context, `[]` for a handle). Call ONCE per class. Constructor inheritance is\n *  untouched — only `Class.prototype`'s parent link changes, and the hop forwards everything it does\n *  not intercept. */\nexport function installPrototypeInvokeFallback<T extends abstract new (...args: never[]) => object>(\n  cls: T,\n  root: readonly string[],\n): void {\n  const parentPrototype = Object.getPrototypeOf(cls.prototype) as object;\n  const hop = new Proxy(Object.create(parentPrototype) as object, {\n    get(hopTarget, key, receiver) {\n      // Symbols and anything the parent chain already answers (dispose protocol, capnweb\n      // internals, Object.prototype) pass through with the instance as receiver.\n      if (typeof key === \"symbol\" || key in hopTarget) {\n        return Reflect.get(hopTarget, key, receiver);\n      }\n      if (RESERVED_SEGMENT_NAMES.has(key)) return undefined;\n      // The dynamic fallback exists for INSTANCES. A lookup whose receiver is not one — someone\n      // probing `Class.prototype.foo` directly, a framework walking prototypes — must see plain\n      // \"undefined\", not conjure a dispatcher over an uninitialized receiver.\n      if (!(receiver instanceof (cls as unknown as abstract new (...args: never[]) => object))) {\n        return undefined;\n      }\n      // The receiver IS the invoker (it implements invoke). Its method resolves at CALL\n      // time, so a trap firing mid-construction (a property miss on `this` before field initializers\n      // ran) can't bake a dispatcher over half-initialized state into the path proxy.\n      return createItxExpressionPathProxy(receiver as unknown as InvokeTarget, root, [key]);\n    },\n  });\n  Object.setPrototypeOf(cls.prototype, hop);\n}\n\n/** A branded, pipelinable handle for a MID-CHAIN capability (`facets.get(name)`, `cd(path)`,\n *  `workers.get(spec)`, a lent stub) whose unknown dotted members reduce into ONE dispatch of the\n *  itx-expression STEPS relative to it; the constructor's `dispatch` routes those steps into the\n *  underlying object. Declared members (`invoke` / `applyRoot`) win over the fallback, so a\n *  capability cannot be named either — the two reserved words this wrapper adds. */\nexport class InvokeHandle extends RpcTarget {\n  readonly #dispatchItxExpressionSteps: (itxExpressionSteps: ItxExpression) => unknown;\n  constructor(dispatchItxExpressionSteps: (itxExpressionSteps: ItxExpression) => unknown) {\n    super();\n    this.#dispatchItxExpressionSteps = dispatchItxExpressionSteps;\n  }\n  /** THE dispatch method the prototype hop reduces onto; the expression is RELATIVE to this handle. */\n  invoke(itxExpressionSteps: ItxExpression): unknown {\n    return this.#dispatchItxExpressionSteps(itxExpressionSteps);\n  }\n  /** Call the bare capability this handle fronts — the ANONYMOUS call step (how a rewritten call\n   *  whose target IS a handle calls it: `handle(events, range)`). */\n  applyRoot(args: unknown[]): unknown {\n    return this.#dispatchItxExpressionSteps([[\"\", ...args]]);\n  }\n}\ninstallPrototypeInvokeFallback(InvokeHandle, []);\n\n/** Walk itx-expression steps off a capnweb stub; the ANONYMOUS call step (`\"\"`) calls the value\n *  itself (a bare function lent as a capability). NO await inside the loop: on a capnweb stub every\n *  step is a PIPELINED path, so an n-step chain costs ONE round trip, flushed by the caller's single\n *  await. A DIRECT call on the stub, never `.apply`: reading `.apply` off a capnweb stub's method is\n *  itself a pipelined remote path, and calling it sends the stub as an argument, which a facet stub\n *  refuses with a DataCloneError. What a connector over a lent stub or a remote capnweb API walks. */\nexport function walkStepsOnRpcStub(stub: unknown, steps: ItxExpression): unknown {\n  let value: unknown = stub;\n  for (const step of steps) {\n    if (typeof step === \"string\") value = (value as Record<string, unknown>)[step];\n    else {\n      const [method, ...args] = step;\n      value =\n        method === \"\"\n          ? (value as (...a: unknown[]) => unknown)(...args)\n          : (value as Record<string, (...a: unknown[]) => unknown>)[method](...args);\n    }\n  }\n  return value;\n}\n"],"mappings":"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"}

package/dist/lib-BWr-5mFO.mjs

@@ -0,0 +1,36 @@
+//#region src/lib.ts
+/** A plain Error carrying `code` (+ optional `data`) as own enumerable properties. */
+function codedError(code, message, data) {
+	return Object.assign(new Error(message), data === void 0 ? { code } : {
+		code,
+		data
+	});
+}
+const isRecord = (v) => typeof v === "object" && !!v && !Array.isArray(v);
+/** Structural deep-equal over plain JSON values — order-insensitive, unbudgeted (JSON is acyclic).
+*  THE one deep-equal: the live-state diff's "don't emit" test AND the idempotency-body compare
+*  (re-exported through stream/processor.ts). The `Object.hasOwn(b, k)` guard is load-bearing — without
+*  it, two objects with the same key COUNT but different key SETS compare equal. */
+function jsonEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
+	if (isRecord(a) && isRecord(b)) {
+		const ka = Object.keys(a);
+		return ka.length === Object.keys(b).length && ka.every((k) => Object.hasOwn(b, k) && jsonEqual(a[k], b[k]));
+	}
+	return false;
+}
+async function withTimeout(promise, ms, what) {
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(codedError("TIMEOUT", `${typeof what === "function" ? what() : what}: no answer in ${ms / 1e3}s`)), ms);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+//#endregion
+export { jsonEqual as n, withTimeout as r, codedError as t };
+
+//# sourceMappingURL=lib-BWr-5mFO.mjs.map