iterate 0.2.7 → 0.3.0

package/dist/sdk-DMB-IM11.mjs

@@ -0,0 +1,933 @@
+import { a as createStreamProcessorRegistry, c as compactPatch, d as disposeIgnoredRpcResult, f as isThenable, l as applyPatch, n as ProcessorFacet, o as LiveState, p as retainCallback, s as applyCompactPatch, u as diff } from "./cloudflare-BTm90gQ4.mjs";
+import { DurableObject, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
+import { RpcTarget as RpcTarget$1 } from "@iterate-com/capnweb";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region src/sdk/capnweb/live-state/store.ts
+function createLiveStateStore() {
+	let held = {
+		revision: -1,
+		state: void 0
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => listeners.forEach((listener) => listener());
+	return {
+		getState: () => held.state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		},
+		reset: () => {
+			held = {
+				revision: -1,
+				state: void 0
+			};
+			notify();
+		},
+		apply: (update, resync) => {
+			if ("s" in update) held = {
+				revision: update.s[0],
+				state: update.s[1]
+			};
+			else if ("p" in update) {
+				if (update.p[0] !== held.revision) {
+					resync();
+					return;
+				}
+				held = {
+					revision: update.p[1],
+					state: applyCompactPatch(held.state, update.p[2])
+				};
+			} else if (update.type === "snapshot") held = {
+				revision: update.revision,
+				state: update.state
+			};
+			else if (update.from !== held.revision) {
+				resync();
+				return;
+			} else held = {
+				revision: update.to,
+				state: applyPatch(held.state, update.patch)
+			};
+			notify();
+		}
+	};
+}
+//#endregion
+//#region src/sdk/capnweb/live-state/protocol.ts
+function isLiveStateSnapshot(update) {
+	return "s" in update || "type" in update && update.type === "snapshot";
+}
+function liveStateRevision(update) {
+	if ("s" in update) return update.s[0];
+	if ("p" in update) return update.p[1];
+	return update.type === "snapshot" ? update.revision : update.to;
+}
+//#endregion
+//#region src/sdk/capnweb/live-state/index.ts
+/**
+* Expose mutable server state as a read-only Cap'n Web capability.
+* Pass an in-memory `LiveState`, or a stream-processor registry whose engine
+* must hydrate before its first snapshot.
+*/
+var LiveStateRpcTarget = class extends RpcTarget$1 {
+	#live;
+	#beforeRead;
+	constructor(source) {
+		super();
+		if ("loadAndRefreshLive" in source) {
+			this.#live = source.live;
+			this.#beforeRead = () => source.loadAndRefreshLive();
+		} else {
+			this.#live = source;
+			this.#beforeRead = void 0;
+		}
+	}
+	async get() {
+		const loading = this.#beforeRead?.();
+		if (isThenable(loading)) await loading;
+		return this.#live.getState();
+	}
+	async subscribe(onUpdate, options) {
+		const loading = this.#beforeRead?.();
+		if (isThenable(loading)) await loading;
+		return new LiveStateSubscriptionRpcTarget(this.#live.subscribe(onUpdate, options));
+	}
+};
+/**
+* The wire handle for one subscription — `ping`/`unsubscribe` over RPC.
+* Exported for relays that build their subscription OUTSIDE a `LiveState`
+* engine (the worker-local liveState-socket relay) but must hand back the
+* same handle shape `LiveStateRpcTarget.subscribe` does.
+*/
+var LiveStateSubscriptionRpcTarget = class extends RpcTarget$1 {
+	#subscription;
+	constructor(subscription) {
+		super();
+		this.#subscription = subscription;
+	}
+	ping() {
+		return this.#subscription.ping();
+	}
+	unsubscribe() {
+		this.#subscription.unsubscribe();
+	}
+	[Symbol.dispose]() {
+		this.#subscription.unsubscribe();
+	}
+};
+//#endregion
+//#region src/sdk/capnweb/index.ts
+var capnweb_exports = /* @__PURE__ */ __exportAll({
+	LiveState: () => LiveState,
+	LiveStateRpcTarget: () => LiveStateRpcTarget,
+	LiveStateSubscriptionRpcTarget: () => LiveStateSubscriptionRpcTarget,
+	applyCompactPatch: () => applyCompactPatch,
+	applyPatch: () => applyPatch,
+	compactPatch: () => compactPatch,
+	createLiveStateStore: () => createLiveStateStore,
+	diff: () => diff,
+	disposeIgnoredRpcResult: () => disposeIgnoredRpcResult,
+	isLiveStateSnapshot: () => isLiveStateSnapshot,
+	isThenable: () => isThenable,
+	liveStateRevision: () => liveStateRevision,
+	retainCallback: () => retainCallback
+});
+import * as import__iterate_com_capnweb from "@iterate-com/capnweb";
+__reExport(capnweb_exports, import__iterate_com_capnweb);
+//#endregion
+//#region src/serve-itx.ts
+/**
+* Answer an app's `/api` request with an itx session for one narrowed scope.
+* Call it from `fetch` after deciding who the visitor is:
+*
+*   if (url.pathname === "/api") {
+*     return await serveItx(request, {
+*       project: await this.env.ITX.get(),
+*       scope: {
+*         path: `/agents/web/${visitorIdFrom(request)}`,
+*         surface: [
+*           "agent.message",
+*           "agent.liveState.get",
+*           "agent.liveState.subscribe",
+*           "agent.stream.openConnection",
+*         ],
+*       },
+*     });
+*   }
+*
+* WebSocket upgrades carry the live session (stream connections, live
+* state); `POST` answers the client's HTTP-batch transport.
+*/
+async function serveItx(request, options) {
+	const { path, surface } = options.scope;
+	const roots = [...new Set(surface.map((entry) => entry.split(".", 1)[0]))];
+	const root = new ServedItxRoot(new ServedItxSession(relayServedProject(options.project.scope({
+		path,
+		surface: roots
+	}), surface)));
+	if (request.method === "POST") return await (0, capnweb_exports.newHttpBatchRpcResponse)(request, root);
+	if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return new Response("This endpoint accepts WebSocket upgrades and POST batches.", { status: 400 });
+	return (0, capnweb_exports.newWorkersWebSocketRpcResponse)(request, root);
+}
+/**
+* The served project: the relay tree over a scoped stub for these dotted
+* members. Exported for the relay's own tests; callers use `serveItx`.
+* @internal
+*/
+function relayServedProject(scoped, surface) {
+	return relayNode(scoped, [], surfaceTree(surface));
+}
+const LEAF = Symbol("served member");
+/** `["agent.message", "agent.stream.openConnection"]` → nested member tree. */
+function surfaceTree(surface) {
+	const tree = {};
+	for (const entry of surface) {
+		const segments = entry.split(".");
+		if (segments.length < 2) throw new Error(`serveItx cannot relay the bare root "${entry}": list the members to serve as dotted paths, e.g. "${entry}.someMethod"`);
+		let node = tree;
+		for (const [index, segment] of segments.entries()) {
+			const last = index === segments.length - 1;
+			const existing = node[segment];
+			if (last) {
+				if (existing !== void 0 && existing !== LEAF) throw new Error(`serveItx: "${entry}" is both a member and a branch of the surface`);
+				node[segment] = LEAF;
+			} else {
+				if (existing === LEAF) throw new Error(`serveItx: "${entry}" is both a member and a branch of the surface`);
+				node = existing ?? (node[segment] = {});
+			}
+		}
+	}
+	return tree;
+}
+/**
+* One node of the served project: a real Cap'n Web target whose PROTOTYPE
+* carries exactly the served members — a method per leaf, a getter per
+* branch — plus `__describe`, which forwards so the platform's restricted
+* description comes back unchanged. A leaf IS a method call: an
+* object-valued member (`liveState`) must appear as a branch, i.e. listed
+* through to its methods.
+*/
+function relayNode(stub, path, tree) {
+	class ServedNode extends capnweb_exports.RpcTarget {}
+	for (const [member, child] of Object.entries(tree)) Object.defineProperty(ServedNode.prototype, member, child === LEAF ? {
+		configurable: true,
+		value: (...args) => forward(stub, [...path, member], args),
+		writable: true
+	} : {
+		configurable: true,
+		get: () => relayNode(stub, [...path, member], child)
+	});
+	Object.defineProperty(ServedNode.prototype, "__describe", {
+		configurable: true,
+		value: () => forward(stub, [...path, "__describe"], []),
+		writable: true
+	});
+	return new ServedNode();
+}
+/**
+* Walk `path` on the Workers-RPC stub (pipelined) and call the last segment
+* — as a genuine member call: extracting the method and `apply`ing it would
+* make the stub's proxy dial a remote member named "apply" with the stub
+* itself as an argument, which workerd refuses to serialize.
+*/
+async function forward(stub, path, args) {
+	let target = stub;
+	for (const segment of path.slice(0, -1)) target = target[segment];
+	return relayResult(await target[path.at(-1)](...args.map((arg) => relayArgument(arg))));
+}
+/**
+* A browser callback arrives as a Cap'n Web stub function; the platform can
+* only call back a plain function, so wrap it. Plain data passes through,
+* recursively, because callbacks ride inside option objects.
+*/
+function relayArgument(value) {
+	if (typeof value === "function") {
+		const stub = value;
+		const callback = typeof stub.dup === "function" ? stub.dup() : value;
+		return (...callbackArgs) => callback(...callbackArgs);
+	}
+	if (Array.isArray(value)) return value.map((entry) => relayArgument(entry));
+	if (isPlainObject(value)) {
+		const relayed = {};
+		for (const [key, entry] of Object.entries(value)) relayed[key] = relayArgument(entry);
+		return relayed;
+	}
+	return value;
+}
+/** A stub a call returned (a connection handle) is wrapped so its methods stay callable. */
+function relayResult(value) {
+	return isWorkersRpcStub(value) ? new RelayedStub(value) : value;
+}
+/**
+* Workers-RPC stubs are callable proxies (`typeof` says "function") that
+* implement the dispose protocol; plain data has `Object.prototype` (or no
+* prototype), arrays are arrays, and a plain function has no disposer.
+* `cloudflare:workers` does not export the stub class to type against, so
+* the check is structural.
+*/
+function isWorkersRpcStub(value) {
+	return (typeof value === "function" || typeof value === "object" && value !== null) && !Array.isArray(value) && !isPlainObject(value) && typeof value[Symbol.dispose] === "function";
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/** Names common protocols probe on any object; never forwarded. */
+const NEVER_FORWARDED = new Set([
+	"then",
+	"toJSON",
+	"asymmetricMatch",
+	"constructor",
+	"dup",
+	"onRpcBroken"
+]);
+/**
+* A stub a served call returned, as a Cap'n Web target: every unknown member
+* is a method forwarding onto the stub (a connection handle's `close()`,
+* `ping()`). Data properties of such a stub are not readable through the
+* relay — methods only.
+*/
+var RelayedStub = class extends capnweb_exports.RpcTarget {
+	#stub;
+	constructor(stub) {
+		super();
+		this.#stub = stub;
+	}
+	static stubOf(relayed) {
+		return relayed.#stub;
+	}
+};
+Object.setPrototypeOf(RelayedStub.prototype, new Proxy(Object.create(capnweb_exports.RpcTarget.prototype), { get(hopTarget, key, receiver) {
+	if (typeof key === "symbol" || key in hopTarget || NEVER_FORWARDED.has(key)) return Reflect.get(hopTarget, key, receiver);
+	if (!(receiver instanceof RelayedStub)) return void 0;
+	return (...args) => forward(RelayedStub.stubOf(receiver), [key], args);
+} }));
+var ServedItxProjects = class extends capnweb_exports.RpcTarget {
+	#project;
+	constructor(project) {
+		super();
+		this.#project = project;
+	}
+	/** The served project, whatever slug the page addresses it by. */
+	get(_slug) {
+		return this.#project;
+	}
+};
+var ServedItxSession = class extends capnweb_exports.RpcTarget {
+	#projects;
+	constructor(project) {
+		super();
+		this.#projects = new ServedItxProjects(project);
+	}
+	get projects() {
+		return this.#projects;
+	}
+	/** Also the session keeper's liveness probe. */
+	async __describe() {
+		return {
+			instructions: "An app-served itx session: projects.get(slug) is the project.",
+			children: { projects: "The served projects catalog." }
+		};
+	}
+};
+var ServedItxRoot = class extends capnweb_exports.RpcTarget {
+	#session;
+	constructor(session) {
+		super();
+		this.#session = session;
+	}
+	/** The stock client's `authenticate` call. Identity was decided by the caller of `serveItx`. */
+	authenticate(_credentials) {
+		return this.#session;
+	}
+};
+//#endregion
+//#region src/sdk.ts
+/**
+* Forward a request to one of the project's dynamic workers (an "app") —
+* pages, APIs, streaming bodies, and WebSocket upgrades all ride through.
+*
+* Why this is a real `env.ITX.fetch` hop with the ref in a header, and not a
+* method call on the app: workerd only performs protocol work — WebSocket 101
+* upgrades, streaming response bodies — through genuine `fetch` handler hops
+* between workers. Calling `fetch` (or anything else) on an app handle from
+* `project.workers.get(ref)` is ordinary RPC: arguments and results are
+* serialized copies, so a Response carrying a socket cannot cross it (workerd
+* throws a DataCloneError). And because a fetch hop's only side channel for
+* "which worker do I mean" is the request itself, the target ref rides the
+* x-iterate-worker-dispatch header (JSON `{ ref, buildBudgetMs? }` — the same
+* ref shape `project.workers.get` takes). Method calls on apps still go
+* through `project.workers.get(ref)` RPC dispatch; HTTP never does.
+*
+* A cold build past `buildBudgetMs` (default 15s) answers a 503 building page
+* that refreshes itself, marked with x-iterate-worker-building — intercept
+* that response here to render your own.
+*/
+async function fetchDynamicWorker(env, req, ref, opts) {
+	const headers = new Headers(req.headers);
+	headers.set("x-iterate-worker-dispatch", JSON.stringify({
+		buildBudgetMs: opts?.buildBudgetMs ?? 15e3,
+		ref
+	}));
+	return await env.ITX.fetch(new Request(req, { headers }));
+}
+/**
+* Walk a dotted capability path over the worker instance and invoke the final
+* segment. The platform dispatches `itx.worker.<path>` calls as ONE flattened
+* `invokeCapability({ path, args })`, and this walks it in userland: nothing
+* ever crosses RPC except the final method's arguments and result, so a
+* getter on the worker class can hand back a whole vendor SDK (installed from
+* package.json) — or any nested surface — in a single round trip.
+*/
+async function invokeCapability(receiver, { args = [], path }) {
+	for (const segment of path.slice(0, -1)) receiver = await Reflect.get(Object(receiver), segment);
+	const method = path.at(-1);
+	const handler = Reflect.get(Object(receiver), method);
+	if (typeof handler !== "function") throw new Error(`"${path.join(".")}" is not a method on this worker`);
+	return await Reflect.apply(handler, receiver, args);
+}
+/** Dispose an RPC stub, tolerating stubs without a disposer and disposers
+* that throw — cleanup must never mask the value it was cleaning up after. */
+function disposeStub(stub) {
+	try {
+		stub[Symbol.dispose]?.();
+	} catch {}
+}
+/** Open a project itx session, use it, dispose it. RPC stubs from
+* `env.ITX.get()` must not outlive the invocation that dialed them, so every
+* operation opens its own session. */
+async function withProject(env, fn) {
+	const project = await env.ITX.get();
+	try {
+		return await fn(project);
+	} finally {
+		disposeStub(project);
+	}
+}
+/**
+* Detach plain data returned by Workers RPC before releasing the per-call
+* result capability. Disposing the project root does not release values
+* obtained through it; each stream call owns its own result reference.
+*/
+function detachPlainRpcResult(result) {
+	if (result === null || typeof result !== "object" && typeof result !== "function") return result;
+	const detached = Array.isArray(result) ? [...result] : { ...result };
+	Reflect.deleteProperty(detached, Symbol.dispose);
+	try {
+		const dispose = Reflect.get(result, Symbol.dispose);
+		if (typeof dispose === "function") Reflect.apply(dispose, result, []);
+	} catch (error) {
+		console.warn("project stream RPC result dispose failed after detaching plain data", { error });
+	}
+	return detached;
+}
+/**
+* A view of `target` with `overrides` in front and everything else passed
+* through. Proxies (not spreads or Object.create) because DurableObjectState
+* and DurableObjectStorage are host objects: their methods must be invoked
+* with the REAL receiver or workerd throws "Illegal invocation".
+*/
+function overlay(target, overrides) {
+	return new Proxy(target, { get(object, prop) {
+		if (Object.hasOwn(overrides, prop)) return overrides[prop];
+		const value = Reflect.get(object, prop, object);
+		return typeof value === "function" ? value.bind(object) : value;
+	} });
+}
+/**
+* A {@link ProcessorStream} over the project stream at `path`, dialed through
+* the platform ITX binding — the stream handle a worker-hosted stream
+* processor registry needs (`iterate/processors`; see the config-repo
+* template's guestbook for the full hosting shape). RPC stubs from
+* `env.ITX.get()` must not outlive the invocation that dialed them, so every
+* operation opens, uses, and disposes its own session; `readEvents` owns one
+* session for its pager's lifetime (scope it with `using`, like any pager).
+*/
+function itxProjectStream(env, path) {
+	const withStream = (fn) => withProject(env, (project) => fn(project.streams)).then(detachPlainRpcResult);
+	return {
+		append: (...events) => withStream((streams) => streams.get(path).append(...events)),
+		appendIfStreamId: (args) => withStream((streams) => streams.get(path).appendIfStreamId(args)),
+		getEvent: (args) => withStream((streams) => streams.get(path).getEvent(args)),
+		getEvents: (args) => withStream((streams) => streams.get(path).getEvents(args)),
+		getEventPage: (args) => withStream((streams) => streams.get(path).getEventPage(args)),
+		readEvents: (args) => {
+			let opened;
+			let closed = false;
+			return {
+				next: async () => {
+					if (closed) return [];
+					opened ??= env.ITX.get().then((project) => ({
+						pager: project.streams.get(path).readEvents(args),
+						project
+					}));
+					const { pager } = await opened;
+					return detachPlainRpcResult(await pager.next());
+				},
+				[Symbol.dispose]() {
+					closed = true;
+					opened?.then(({ pager, project }) => {
+						disposeStub(pager);
+						disposeStub(project);
+					}).catch(() => {});
+				}
+			};
+		},
+		at: (siblingPath) => itxProjectStream(env, siblingPath)
+	};
+}
+/** Where the platform-delivered self ref lives in this worker's own storage
+* (see {@link IterateDurableObject.__stashSelfRef}). */
+const SELF_REF_STORAGE_KEY = "iterate:self-ref";
+/**
+* Durable alarms for a stateful dynamic worker, presented as the ordinary
+* `DurableObjectState` alarm API — what `IterateDurableObject` installs as
+* `this.ctx`, so alarms on stateful workers just work.
+*
+* workerd does not implement alarms for facet-hosted Durable Objects — the
+* hosting model for stateful dynamic workers (workerd#6810; a facet
+* `setAlarm` even appears to succeed, then poisons the commit path). So the
+* platform Durable Object that hosts this worker keeps the real alarm on its
+* behalf: the trio here dials `itx.workers.get(ref).setAlarm/getAlarm` on the
+* worker's own ref — delivered by the host before any other traffic and
+* stashed durably ({@link IterateDurableObject.__stashSelfRef}) — and the
+* host's fire calls this class's `alarm(alarmInfo)` method, retried by the
+* platform if it throws, exactly like a native alarm handler.
+*
+* Everything except the three alarm methods is the worker's own `ctx`,
+* untouched (`storage.kv`, `waitUntil`, WebSocket APIs, …), so code written
+* against this state uses only standard Durable Object concepts, and if
+* workerd ships facet alarms the shim disappears without a caller changing.
+* Honest divergences: the alarm methods ignore the native `options` bag,
+* alarms armed inside `storage.transaction()` bypass the shim, and a class
+* with no `alarm()` handler fails at fire time (native `setAlarm` rejects at
+* arm time; the shim cannot check).
+*/
+function selfAlarmState(ctx, env) {
+	const withSelf = (fn) => {
+		const ref = ctx.storage.kv.get(SELF_REF_STORAGE_KEY);
+		if (ref === void 0) throw new Error("this worker's own ref has not been delivered yet — alarms are unavailable in the constructor; arm from a handler instead");
+		return withProject(env, (project) => fn(project.workers.get(ref)));
+	};
+	return overlay(ctx, { storage: overlay(ctx.storage, {
+		setAlarm: (scheduledTime) => withSelf((worker) => worker.setAlarm(typeof scheduledTime === "number" ? scheduledTime : scheduledTime.getTime())),
+		deleteAlarm: () => withSelf((worker) => worker.setAlarm(null)),
+		getAlarm: () => withSelf((worker) => worker.getAlarm())
+	}) });
+}
+/**
+* Base class for stateless dynamic workers — the project worker (a repo's
+* default export) and stateless apps. A WorkerEntrypoint whose env carries
+* the platform's itx binding, plus the platform ceremony every worker needs
+* but shouldn't have to hand-roll:
+*
+* - `processEventBatch` / `processEvent`: the platform delivers every
+*   committed DURABLE event on every stream in the project as checkpointed
+*   per-stream batches — in per-stream order, at-least-once. Events appended
+*   with `ephemeral: true` (LLM streaming chunks and other transient
+*   signals) never arrive here. Session callbacks can receive one while its
+*   body remains in the Stream Durable Object's bounded memory buffer; react
+*   here to the durable fact that supersedes it (e.g. an assistant-role
+*   `agents/context-added` item). The base unpacks batches
+*   into one `processEvent(event)` call per event; override `processEvent` to react
+*   (one `if` per reaction, keyed on event.path + event.type). Throwing (or a worker that fails to build) leaves that
+*   stream's checkpoint in place and the whole batch is redelivered later,
+*   so return normally to advance past events you don't care about — and
+*   anything a reaction appends should carry an idempotency key.
+* - `invokeCapability`: the flattened `itx.worker.<path>` dispatcher — add a
+*   getter or method to your class and it becomes a capability surface.
+* - `fetchDynamicWorker`: forward HTTP (WebSockets included) to another of
+*   the project's dynamic workers.
+*/
+var IterateWorkerEntrypoint = class extends WorkerEntrypoint {
+	#itx;
+	constructor(ctx, env) {
+		super(ctx, env);
+		this.env = env;
+	}
+	/**
+	* This invocation's project-root itx. Cloudflare constructs one
+	* WorkerEntrypoint per invocation and releases its RPC stubs when that
+	* execution context ends. The getter returns the native Workers RPC
+	* promise-proxy, so `await this.itx.agents.list()` pipelines immediately;
+	* repeated access within one event batch or fetch reuses the same handle.
+	*
+	* Durable Objects have a longer, multi-invocation lifetime and no eviction
+	* callback, so IterateDurableObject deliberately does not expose this
+	* memoized getter.
+	*/
+	get itx() {
+		return this.#itx ??= this.env.ITX.get();
+	}
+	/**
+	* Run the project-member auth partial fetch without transferring the app's
+	* request body on paths auth only inspects. The callback POST belongs to
+	* auth, so that one path deliberately transfers the complete request.
+	*/
+	async fetchProjectAuth(request, policy) {
+		if (request.method === "POST" && new URL(request.url).pathname === "/_iterate/auth/callback") return await this.itx.auth.get(policy).fetch(request);
+		const authRequest = new Request(request.url, {
+			headers: request.headers,
+			method: request.method
+		});
+		return await this.itx.auth.get(policy).fetch(authRequest);
+	}
+	/** See `fetchDynamicWorker` at module level: a real fetch hop into a
+	* sibling dynamic worker — the only lane that can carry WebSocket upgrades
+	* and streaming bodies (RPC serializes; sockets can't cross it). */
+	async fetchDynamicWorker(req, ref, opts) {
+		return await fetchDynamicWorker(this.env, req, ref, opts);
+	}
+	/** Platform entry point for event delivery (see the class docstring for
+	* the delivery contract). Override `processEvent`, not this, unless you
+	* need whole-batch atomicity. */
+	async processEventBatch(batch) {
+		for (const event of batch.events) await this.processEvent(event);
+	}
+	/** Called once per delivered event, in per-stream order, at-least-once.
+	* Override to react; the default ignores everything. */
+	async processEvent(_event) {}
+	/** Platform entry point for flattened `itx.worker.<path>` capability
+	* calls (see the class docstring). */
+	async invokeCapability(input) {
+		return await invokeCapability(this, input);
+	}
+};
+/**
+* Base class for stateful dynamic workers (apps hosted as Durable Objects
+* under a `durableWorkerKey`). Same platform surface as
+* `IterateWorkerEntrypoint` — see its docstring for the event-delivery and
+* capability-dispatch contracts — on a DurableObject, so state survives
+* across requests and WebSockets can be served from `fetch`. Durable alarms
+* work natively — `this.ctx.storage.setAlarm(...)` plus an `alarm()` method
+* on the class — even though this object is hosted as a workerd facet with
+* no alarms of its own; see {@link selfAlarmState} for the mechanism.
+*/
+var IterateDurableObject = class extends DurableObject {
+	constructor(ctx, env) {
+		super(ctx, env);
+		this.env = env;
+		this.ctx = selfAlarmState(this.ctx, this.env);
+	}
+	/**
+	* Platform bootstrap door: the Durable Object hosting this worker delivers
+	* the worker's OWN ref here before any other traffic in its incarnation —
+	* a facet has no channel to learn its identity by itself, and the ref is
+	* what the alarm shim dials (`itx.workers.get(ref)` resolves back to the
+	* hosting DO). Stashed durably, so a warm facet under a fresh host needs
+	* no re-delivery to keep working.
+	*/
+	__stashSelfRef(ref) {
+		this.ctx.storage.kv.put(SELF_REF_STORAGE_KEY, ref);
+	}
+	/** A real fetch hop into a sibling dynamic worker — see
+	* `IterateWorkerEntrypoint.fetchDynamicWorker`. */
+	async fetchDynamicWorker(req, ref, opts) {
+		return await fetchDynamicWorker(this.env, req, ref, opts);
+	}
+	/** Platform entry point for event delivery — see
+	* `IterateWorkerEntrypoint.processEventBatch`. */
+	async processEventBatch(batch) {
+		for (const event of batch.events) await this.processEvent(event);
+	}
+	/** Called once per delivered event — see
+	* `IterateWorkerEntrypoint.processEvent`. */
+	async processEvent(_event) {}
+	/** Platform entry point for flattened `itx.worker.<path>` capability
+	* calls — see `IterateWorkerEntrypoint.invokeCapability`. */
+	async invokeCapability(input) {
+		return await invokeCapability(this, input);
+	}
+};
+const HOST_PROJECT_ID_KEY = "iterate:processor-host:project-id";
+const HOST_STREAM_PATH_KEY = "iterate:processor-host:stream-path";
+/**
+* The worker's `processor` node: the wake door the stream spine dials PLUS
+* the public read verbs of the standard processor contract
+* (`StreamProcessorRpc`). The reads serve the registered runner directly, so
+* `streams.get(path).subscriptions.get(name).processor` and the stream's
+* `waitUntilProcessed` barrier reach an expression-placed dynamic worker's
+* processor with no extra wiring — the stream replays those verbs onto this
+* node (the stored wake expression minus its trailing wake step). It crosses
+* Workers RPC as a property read before its method is called, so it must be
+* a real RpcTarget.
+*/
+var ProcessorWakeTarget = class extends RpcTarget {
+	#registryFor;
+	#reads;
+	constructor(registryFor, reads) {
+		super();
+		this.#registryFor = registryFor;
+		this.#reads = reads;
+	}
+	async wakeStreamProcessor(request) {
+		if (request.stream.projectId === null) throw new Error("hosted stream processors require project streams");
+		return await this.#registryFor(request.stream.projectId, request.stream.path).wakeStreamProcessor(request);
+	}
+	/** One consistent read of the committed fold, pulled through the durable
+	* stream tail first (read-your-writes, the hosting relays' catch-up leg). */
+	async snapshot() {
+		const reads = await this.#reads();
+		await reads.catchUp();
+		return await reads.snapshot();
+	}
+	async getRuntimeState() {
+		return await (await this.#reads()).getRuntimeState();
+	}
+	/** Offset barrier against the runner's committed fold. The runner's waiter
+	* self-pulls, so its timeout bounds the whole read-your-writes operation. */
+	async waitUntilProcessed(input) {
+		await (await this.#reads()).waitUntilEvent(input);
+	}
+};
+/**
+* Host one stream processor in a Durable Object: the registry ceremony, the
+* RPC-safe wake door, the alarm multiplex, and the durable coordinate cache
+* in one place, so an app class is only its processor plus its own verbs.
+*
+* With `path` the host serves one fixed home stream (the guestbook shape).
+* Without it the host learns its stream from the first wake request and
+* caches the coordinates durably (one Durable Object per dynamic stream,
+* keyed by the ref that names it). One host per Durable Object — the cache
+* keys assume it.
+*/
+function createProcessorHost(args) {
+	let built;
+	const ensure = (projectId, path) => {
+		if (built === void 0) {
+			args.ctx.storage.kv.put(HOST_PROJECT_ID_KEY, projectId);
+			args.ctx.storage.kv.put(HOST_STREAM_PATH_KEY, path);
+			const stream = itxProjectStream(args.env, path);
+			const registry = createStreamProcessorRegistry(args.ctx, {
+				path,
+				projectId,
+				stream,
+				version: args.env.ITERATE_WORKER_VERSION
+			});
+			const processor = registry.register(args.createProcessor({
+				path,
+				projectId,
+				stream
+			}), args.recovery === void 0 ? void 0 : { recovery: args.recovery });
+			built = {
+				reads: registry.reads(processor),
+				registry
+			};
+		}
+		return built;
+	};
+	const buildOutsideWake = async () => {
+		if (built !== void 0) return built;
+		const path = args.path ?? args.ctx.storage.kv.get(HOST_STREAM_PATH_KEY);
+		if (path === void 0) throw new Error("this processor host learns its stream from the first wake request");
+		return ensure(args.ctx.storage.kv.get(HOST_PROJECT_ID_KEY) ?? await withProject(args.env, async (project) => await project.projectId), path);
+	};
+	return {
+		registry: async () => (await buildOutsideWake()).registry,
+		snapshot: async () => await (await buildOutsideWake()).reads.snapshot(),
+		wakeProcessor: new ProcessorWakeTarget((projectId, path) => ensure(projectId, args.path ?? path).registry, async () => (await buildOutsideWake()).reads),
+		async handleAlarm(alarmInfo) {
+			const projectId = args.ctx.storage.kv.get(HOST_PROJECT_ID_KEY);
+			const path = args.path ?? args.ctx.storage.kv.get(HOST_STREAM_PATH_KEY);
+			if (projectId === void 0 || path === void 0) return;
+			await ensure(projectId, path).registry.handleAlarm(alarmInfo);
+		}
+	};
+}
+/**
+* Ergonomic base for a Durable Object that hosts exactly one stream processor.
+*
+* It collapses the host boilerplate every processor app writes by hand today —
+* a {@link createProcessorHost} field, an `alarm()` that forwards to it, and a
+* `processor` getter exposing the wake door — down to a single
+* {@link createProcessor} factory. First-party and userspace processors are
+* authored the SAME way: all a subclass writes is how to build its processor
+* from the host-derived platform deps (`{ stream, path, projectId }`) plus
+* whatever it wires off `this.env`. That single seam is why a built-in
+* processor forks into userspace with no change to the processor itself — only
+* the dep wiring in `createProcessor` differs.
+*
+* Host-agnostic: the exact same class runs as its own Durable Object, as a
+* facet of the Stream DO, or as a facet of another DO. Only the alarm adapter
+* (native vs parent-proxied) and who dials the wake door differ per host, and
+* the host owns both.
+*
+* ```ts
+* export class GuestbookDurableObject extends StreamProcessorDurableObject<GuestbookState> {
+*   protected readonly streamPath = guestbookStreamPath; // fixed home stream
+*   protected createProcessor(deps: ProcessorHostDeps) {
+*     return new GuestbookProcessor(deps);
+*   }
+*   // alarm(), the `processor` wake door, snapshot(), registry() — inherited.
+* }
+* ```
+*/
+var StreamProcessorDurableObject = class extends IterateDurableObject {
+	/**
+	* A fixed home stream path (the guestbook shape). Leave undefined to learn
+	* the stream from the first wake request and cache the coordinates durably
+	* (one Durable Object per dynamic stream).
+	*/
+	streamPath;
+	/**
+	* Post-eviction keepalive recovery, for processors that owe registered
+	* background work (the obligation pattern). Off by default.
+	*/
+	recovery = false;
+	/**
+	* Built lazily on first door/alarm access — deliberately NOT a field
+	* initializer. A base-class field initializer runs before the subclass's
+	* `streamPath` / `recovery` field initializers, so it would capture the base
+	* defaults instead of a subclass's overrides; reading them on first use
+	* sidesteps that ordering trap. Memoized because the host owns the registry
+	* cache, and one host per Durable Object is assumed.
+	*/
+	#memoHost;
+	get #host() {
+		return this.#memoHost ??= createProcessorHost({
+			ctx: this.ctx,
+			env: this.env,
+			path: this.streamPath,
+			recovery: this.recovery,
+			createProcessor: (deps) => this.createProcessor(deps)
+		});
+	}
+	/**
+	* The processor node the stream spine dials: the wake door plus the standard
+	* read verbs (`snapshot` / `getRuntimeState` / `waitUntilProcessed`), so the
+	* subscriptions catalog and the stream barrier reach this processor. It
+	* crosses Workers RPC as a property read before its method is called, so it
+	* must be a real RpcTarget — which the host guarantees.
+	*/
+	get processor() {
+		return this.#host.wakeProcessor;
+	}
+	/** Route the Durable Object's native `alarm()` into the host's multiplex. */
+	async alarm(alarmInfo) {
+		await this.#host.handleAlarm(alarmInfo);
+	}
+	/**
+	* One consistent read of the hosted processor's committed fold, for a
+	* subclass's own read verbs (e.g. a `getState()`).
+	*/
+	snapshot() {
+		return this.#host.snapshot();
+	}
+	/**
+	* The lazily built registry, for subclasses that drive catch-up / live
+	* refresh directly (the guestbook's HTTP + append flow).
+	*/
+	registry() {
+		return this.#host.registry();
+	}
+};
+/**
+* Ergonomic base for a userspace stream processor hosted as a FACET of the
+* platform's Stream Durable Object — the `facet-processor` subscription with a
+* `userspace` source, whose `StatefulDynamicWorkerRef` names THIS class. The
+* Stream DO loads the class from the project's source and starts it with
+* `ctx.facets.get(name, …)`, so it runs INSIDE the stream it serves: wakes are
+* an in-process parent→facet dial (no itx wake expression), and checkpoints /
+* projections land in the facet's own private SQLite.
+*
+* Same authoring seam as {@link StreamProcessorDurableObject} — a subclass
+* writes only `createProcessor` (and sets `recovery` when it owes background
+* work) — so a processor forks between "its own Durable Object" and "a facet
+* of its stream" with no change to the processor itself. The two differences a
+* facet forces, both handled here:
+*
+* - **No native alarm.** workerd does not implement alarms for facets
+*   (workerd#6810), so this base routes the registry's keepalive/recovery
+*   alarm through the parent's real platform alarm over itx —
+*   `streams.get(path).proxySetAlarm/proxyDeleteAlarm/proxyGetAlarm`, the
+*   itx-channel twin of a stateful worker's `workers.get(ref).setAlarm`. The
+*   parent fires it back as {@link ProcessorFacet.handleAlarm}. NEVER define
+*   `alarm()` on a subclass (the base throws): a facet's native `setAlarm`
+*   would appear to succeed, then poison its output gate.
+* - **Identity by first-contact `configure`, not the constructor.** The Stream
+*   DO delivers `{ parentName, projectId, path }`; the base stashes it and
+*   rebuilds the host from that stash on every incarnation (see
+*   {@link ProcessorFacet}).
+*
+* ```ts
+* export class GuestbookFacet extends StreamProcessorFacet {
+*   protected readonly recovery = true; // owes background work
+*   protected createProcessor(deps: ProcessorHostDeps) {
+*     return new GuestbookProcessor(deps);
+*   }
+* }
+* ```
+*/
+var StreamProcessorFacet = class extends ProcessorFacet {
+	/**
+	* Post-eviction keepalive recovery, for processors that owe registered
+	* background work (the obligation pattern). Off by default.
+	*/
+	recovery = false;
+	/**
+	* Dial the parent stream's alarm proxy over itx, resolved PER CALL (a stub
+	* must not outlive its RPC turn), each verb opening and disposing its own
+	* session like {@link itxProjectStream}. `identity.path` is the coordinate;
+	* `parentName` is unused here (userspace facets have no `env.STREAM`).
+	*/
+	parentAlarms(identity) {
+		const env = this.env;
+		const { path } = identity;
+		return {
+			proxySetAlarm: (scheduledTimeMs) => withProject(env, (project) => project.streams.get(path).proxySetAlarm(scheduledTimeMs)),
+			proxyDeleteAlarm: () => withProject(env, (project) => project.streams.get(path).proxyDeleteAlarm()),
+			proxyGetAlarm: () => withProject(env, (project) => project.streams.get(path).proxyGetAlarm())
+		};
+	}
+	/**
+	* Build the host wiring from the stashed identity: the stream handle is the
+	* same itx-backed {@link itxProjectStream} a worker-hosted processor appends
+	* through, and the single processor is registered under this facet's name.
+	*/
+	createHost(identity) {
+		if (identity.projectId === null) throw new Error("userspace stream-processor facets require a project stream");
+		const { projectId, path } = identity;
+		const stream = itxProjectStream(this.env, path);
+		return {
+			stream,
+			version: this.env.ITERATE_WORKER_VERSION,
+			registerProcessors: (registry) => {
+				registry.register(this.createProcessor({
+					path,
+					projectId,
+					stream
+				}), { recovery: this.recovery });
+			}
+		};
+	}
+};
+//#endregion
+export { createProcessorHost as a, capnweb_exports as c, StreamProcessorFacet as i, LiveStateRpcTarget as l, IterateWorkerEntrypoint as n, itxProjectStream as o, StreamProcessorDurableObject as r, serveItx as s, IterateDurableObject as t };
+
+//# sourceMappingURL=sdk-DMB-IM11.mjs.map