iterate 0.2.7 → 0.3.0

package/dist/live-state-BJNqOwFw.mjs

@@ -0,0 +1,299 @@
+import { a as compactPatch, s as diff } from "./protocol-DnK_f2m6.mjs";
+import { RpcTarget } from "@iterate-com/capnweb";
+//#region src/sdk/capnweb/live-state/retain.ts
+/**
+* Retain a single-argument RPC callback so it survives past the call that
+* carried it. `dup()` duplicates the underlying remote stub (that dup is what
+* `[Symbol.dispose]` releases); `onRpcBroken` is forwarded defensively — Cap'n
+* Web stubs expose no own property descriptors and a Workers RPC property access
+* can fabricate a pipelined method that rejects at call time, so we wire whatever
+* the stub claims and swallow registration failures. `onRpcBroken` is only a
+* prompt hint; callers that need a terminal verdict must model one explicitly
+* (for example, the durable wake lane's independent settlement capability).
+*/
+function retainCallback(callback) {
+	const retainable = callback;
+	const retained = retainable.dup?.() ?? retainable;
+	const dispose = retained[Symbol.dispose]?.bind(retained);
+	let disposed = false;
+	const wrapped = Object.assign((arg) => retained(arg), { [Symbol.dispose]() {
+		if (disposed) return;
+		disposed = true;
+		dispose?.();
+	} });
+	const onRpcBroken = retained.onRpcBroken;
+	if (typeof onRpcBroken === "function") wrapped.onRpcBroken = (handler) => {
+		try {
+			const result = onRpcBroken.call(retained, handler);
+			if (isThenable(result)) Promise.resolve(result).catch(() => {});
+		} catch {}
+	};
+	return wrapped;
+}
+/** Thenable probe: RPC stubs and their call results are thenable-shaped. */
+function isThenable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+/**
+* Dispose the result of an RPC call whose value the caller ignores. Reading a
+* Cap'n Web / Workers RPC method yields a disposable stub even when unused, and
+* dropping it without disposal leaks the remote reference.
+*/
+function disposeIgnoredRpcResult(result) {
+	if (result !== null && (typeof result === "object" || typeof result === "function") && Symbol.dispose in result) result[Symbol.dispose]();
+}
+//#endregion
+//#region src/sdk/capnweb/live-state/engine.ts
+const DEFAULT_DEBOUNCE_MS = 100;
+const ACK_TIMEOUT_MS = 1e4;
+/**
+* A source-agnostic live store: hold a state value, and when it changes push the
+* minimal diff to every subscriber. It does not know or care where the state
+* comes from — a Durable Object folds events into it, a stateless RpcTarget polls
+* a third-party API into it — so ANY RpcTarget can expose live state by holding
+* one and returning a read-only wrapper from a `.live` getter.
+*
+* Two rules make it cheap and correct:
+* - Updates are IMMUTABLE (`setState`/`assign` build a new value, never mutate),
+*   so the diff short-circuits unchanged branches by identity — O(changed), not
+*   O(size). See `diff.ts`.
+* - Push work runs only while a subscriber exists. Transient readers call
+*   `readSince` explicitly; a dormant engine schedules nothing.
+*
+* All subscribers share one revision line. Fast subscribers share a patch;
+* slow subscribers receive a coalesced patch from their acknowledged state.
+* A revision mismatch makes the client resync instead of applying stale data.
+*/
+var LiveState = class {
+	#current;
+	/** Latest flushed state — the shared diff baseline. */
+	#broadcast;
+	#revision = 0;
+	#epoch = crypto.randomUUID();
+	#lastUpdate;
+	#lastCompactUpdate;
+	#subscribers = /* @__PURE__ */ new Map();
+	#debounceMs;
+	#flushTimer;
+	constructor(initial, options = {}) {
+		this.#current = initial;
+		this.#broadcast = initial;
+		this.#debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	}
+	/** The current state — reflects every `setState`/`assign`, even while dormant. */
+	getState() {
+		return this.#current;
+	}
+	/** One retained delta bounds history while a single parent can pull incrementally.
+	* A late reader or a new incarnation receives an explicit snapshot instead. */
+	readSince(cursor, options = {}) {
+		if (this.#flushTimer !== void 0) clearTimeout(this.#flushTimer);
+		this.#flushTimer = void 0;
+		this.#flush();
+		if (cursor?.epoch === this.#epoch) {
+			if (cursor.revision === this.#revision) return {
+				epoch: this.#epoch,
+				update: null
+			};
+			if (cursor.revision === this.#lastUpdate?.from) return {
+				epoch: this.#epoch,
+				update: options.patchVersion === 3 ? this.#lastCompactUpdate : this.#lastUpdate
+			};
+		}
+		return {
+			epoch: this.#epoch,
+			update: options.patchVersion === 3 ? { s: [this.#revision, this.#broadcast] } : {
+				type: "snapshot",
+				revision: this.#revision,
+				state: this.#broadcast
+			}
+		};
+	}
+	/** True while at least one live subscriber makes projection work observable. */
+	get observed() {
+		return this.#subscribers.size > 0;
+	}
+	/** Replace the state. Build a NEW value (don't mutate) so the diff stays cheap. */
+	setState(next) {
+		this.#current = typeof next === "function" ? next(this.#current) : next;
+		if (this.#subscribers.size > 0) this.#scheduleFlush();
+	}
+	/** Shallow-merge a partial into the state — sugar for `setState(p => ({ ...p, ...partial }))`. */
+	assign(partial) {
+		this.setState((prev) => ({
+			...prev,
+			...partial
+		}));
+	}
+	subscribe(sink, options = {}) {
+		if (this.#subscribers.size === 0) this.#flush();
+		const retained = retainCallback(sink);
+		this.#subscribers.set(retained, {
+			version: options.patchVersion ?? 1,
+			state: this.#broadcast,
+			revision: this.#revision,
+			busy: false
+		});
+		retained.onRpcBroken?.(() => this.#drop(retained));
+		this.#deliver(retained, options.patchVersion === 3 ? { s: [this.#revision, this.#broadcast] } : {
+			type: "snapshot",
+			revision: this.#revision,
+			state: this.#broadcast
+		});
+		return {
+			ping: () => this.#subscribers.has(retained),
+			unsubscribe: () => this.#drop(retained),
+			[Symbol.dispose]: () => this.#drop(retained)
+		};
+	}
+	#scheduleFlush() {
+		this.#flushTimer ??= setTimeout(() => {
+			this.#flushTimer = void 0;
+			this.#flush();
+		}, this.#debounceMs);
+	}
+	#flush() {
+		const previous = this.#broadcast;
+		const patch = diff(previous, this.#current);
+		if (patch === void 0) return;
+		const from = this.#revision;
+		const to = this.#revision += 1;
+		this.#broadcast = this.#current;
+		const update = {
+			type: "patch",
+			from,
+			to,
+			patch
+		};
+		this.#lastUpdate = update;
+		this.#lastCompactUpdate = { p: [
+			from,
+			to,
+			compactPatch(previous, patch)
+		] };
+		for (const subscriber of this.#subscribers.keys()) this.#sendLatest(subscriber);
+	}
+	/** Slow subscribers hold one call and one baseline, never a queue of token updates. */
+	#sendLatest(subscriber) {
+		const held = this.#subscribers.get(subscriber);
+		if (!held || held.busy || held.revision === this.#revision) return;
+		if (held.version === 3) {
+			if (held.revision === this.#lastUpdate?.from) this.#deliver(subscriber, this.#lastCompactUpdate);
+			else {
+				const patch = diff(held.state, this.#broadcast);
+				this.#deliver(subscriber, { p: [
+					held.revision,
+					this.#revision,
+					patch ? compactPatch(held.state, patch) : {}
+				] });
+			}
+			return;
+		}
+		const patch = held.version === 2 && held.revision === this.#lastUpdate?.from ? this.#lastUpdate.patch : diff(held.state, this.#broadcast, { arrays: held.version === 2 });
+		this.#deliver(subscriber, {
+			type: "patch",
+			from: held.revision,
+			to: this.#revision,
+			patch: patch ?? {}
+		});
+	}
+	/** Only acknowledgement releases the next coalesced update; a dead sink is dropped. */
+	#deliver(subscriber, update) {
+		const held = this.#subscribers.get(subscriber);
+		if (!held) return;
+		held.state = this.#broadcast;
+		held.revision = this.#revision;
+		held.busy = true;
+		let result;
+		try {
+			result = subscriber(update);
+		} catch {
+			this.#drop(subscriber);
+			return;
+		}
+		if (isThenable(result)) {
+			held.timeout = setTimeout(() => {
+				console.warn("Live-state subscriber dropped: acknowledgement timed out", {
+					revision: held.revision,
+					timeoutMs: ACK_TIMEOUT_MS
+				});
+				this.#drop(subscriber);
+			}, ACK_TIMEOUT_MS);
+			Promise.resolve(result).then(() => {
+				if (held.timeout !== void 0) clearTimeout(held.timeout);
+				held.busy = false;
+				this.#sendLatest(subscriber);
+			}, () => this.#drop(subscriber)).finally(() => disposeIgnoredRpcResult(result));
+			return;
+		}
+		held.busy = false;
+		disposeIgnoredRpcResult(result);
+	}
+	#drop(subscriber) {
+		const timeout = this.#subscribers.get(subscriber)?.timeout;
+		if (timeout !== void 0) clearTimeout(timeout);
+		if (!this.#subscribers.delete(subscriber)) return;
+		subscriber[Symbol.dispose]();
+		if (this.#subscribers.size === 0 && this.#flushTimer !== void 0) {
+			clearTimeout(this.#flushTimer);
+			this.#flushTimer = void 0;
+		}
+	}
+};
+//#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 {
+	#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 {
+	#subscription;
+	constructor(subscription) {
+		super();
+		this.#subscription = subscription;
+	}
+	ping() {
+		return this.#subscription.ping();
+	}
+	unsubscribe() {
+		this.#subscription.unsubscribe();
+	}
+	[Symbol.dispose]() {
+		this.#subscription.unsubscribe();
+	}
+};
+//#endregion
+export { isThenable as a, disposeIgnoredRpcResult as i, LiveStateSubscriptionRpcTarget as n, retainCallback as o, LiveState as r, LiveStateRpcTarget as t };
+
+//# sourceMappingURL=live-state-BJNqOwFw.mjs.map

package/dist/live-state-BJNqOwFw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-state-BJNqOwFw.mjs","names":["#epoch","#subscribers","#debounceMs","#current","#broadcast","#flushTimer","#flush","#revision","#lastUpdate","#lastCompactUpdate","#scheduleFlush","#drop","#deliver","#sendLatest","#live","#beforeRead","#subscription"],"sources":["../src/sdk/capnweb/live-state/retain.ts","../src/sdk/capnweb/live-state/engine.ts","../src/sdk/capnweb/live-state/index.ts"],"sourcesContent":["// Canonical retention for RPC callback stubs — the one place that knows a sink\n// might be a remote Cap'n Web / Workers RPC stub rather than a local function.\n//\n// A \"sink\" is a callback the server keeps calling AFTER the RPC method that\n// carried it returned (a live subscription's push). Retaining it means: dup the\n// underlying stub while the transport supports it, and dispose the dup on close.\n// Stream event delivery and the live-state engine both build on these primitives\n// instead of re-deriving the transport dance.\n\n/** An RPC callback after retention: still callable, plus disposable and (best-effort) broken-transport aware. */\nexport type RetainedCallback<Arg> = ((arg: Arg) => unknown) &\n  Disposable & { onRpcBroken?(handler: (error: unknown) => void): void };\n\n/**\n * Retain a single-argument RPC callback so it survives past the call that\n * carried it. `dup()` duplicates the underlying remote stub (that dup is what\n * `[Symbol.dispose]` releases); `onRpcBroken` is forwarded defensively — Cap'n\n * Web stubs expose no own property descriptors and a Workers RPC property access\n * can fabricate a pipelined method that rejects at call time, so we wire whatever\n * the stub claims and swallow registration failures. `onRpcBroken` is only a\n * prompt hint; callers that need a terminal verdict must model one explicitly\n * (for example, the durable wake lane's independent settlement capability).\n */\nexport function retainCallback<Arg>(callback: (arg: Arg) => unknown): RetainedCallback<Arg> {\n  const retainable = callback as ((arg: Arg) => unknown) &\n    Partial<Disposable> & {\n      dup?(): (arg: Arg) => unknown;\n      onRpcBroken?(handler: (error: unknown) => void): void;\n    };\n  const retained = (retainable.dup?.() ?? retainable) as typeof retainable;\n  const dispose = retained[Symbol.dispose]?.bind(retained);\n  // Idempotent by contract: owners often dispose from several paths (engine\n  // drop + connection teardown), and a double release of the underlying dup\n  // would free someone else's reference.\n  let disposed = false;\n  const wrapped = Object.assign((arg: Arg) => retained(arg), {\n    [Symbol.dispose]() {\n      if (disposed) return;\n      disposed = true;\n      dispose?.();\n    },\n  }) as RetainedCallback<Arg>;\n  const onRpcBroken = retained.onRpcBroken;\n  if (typeof onRpcBroken === \"function\") {\n    wrapped.onRpcBroken = (handler: (error: unknown) => void) => {\n      try {\n        const result = onRpcBroken.call(retained, handler);\n        if (isThenable(result)) void Promise.resolve(result).catch(() => {});\n      } catch {\n        // Registration is best-effort.\n      }\n    };\n  }\n  return wrapped;\n}\n\n/** Thenable probe: RPC stubs and their call results are thenable-shaped. */\nexport function isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    value !== null &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    typeof (value as PromiseLike<unknown>).then === \"function\"\n  );\n}\n\n/**\n * Dispose the result of an RPC call whose value the caller ignores. Reading a\n * Cap'n Web / Workers RPC method yields a disposable stub even when unused, and\n * dropping it without disposal leaks the remote reference.\n */\nexport function disposeIgnoredRpcResult(result: unknown): void {\n  if (\n    result !== null &&\n    (typeof result === \"object\" || typeof result === \"function\") &&\n    Symbol.dispose in result\n  ) {\n    (result as Disposable)[Symbol.dispose]();\n  }\n}\n","import {\n  disposeIgnoredRpcResult,\n  isThenable,\n  retainCallback,\n  type RetainedCallback,\n} from \"./retain.ts\";\nimport { diff } from \"./diff.ts\";\nimport { compactPatch } from \"./compact.ts\";\nimport type {\n  LiveStateCursor,\n  LiveStateRead,\n  LiveStateSubscriptionOptions,\n  LiveUpdate,\n} from \"./protocol.ts\";\n\n/** Handle returned by `LiveState.subscribe` — the ownership + liveness surface for one subscriber. */\nexport type LiveStateSubscription = {\n  /** Still registered on a live engine? A dead DO incarnation also makes the call reject. */\n  ping(): boolean;\n  unsubscribe(): void;\n  [Symbol.dispose](): void;\n};\n\nconst DEFAULT_DEBOUNCE_MS = 100;\nconst ACK_TIMEOUT_MS = 10_000;\n\ntype Subscriber<State> = {\n  version: 1 | 2 | 3;\n  state: State;\n  revision: number;\n  busy: boolean;\n  timeout?: ReturnType<typeof setTimeout>;\n};\n\n/**\n * A source-agnostic live store: hold a state value, and when it changes push the\n * minimal diff to every subscriber. It does not know or care where the state\n * comes from — a Durable Object folds events into it, a stateless RpcTarget polls\n * a third-party API into it — so ANY RpcTarget can expose live state by holding\n * one and returning a read-only wrapper from a `.live` getter.\n *\n * Two rules make it cheap and correct:\n * - Updates are IMMUTABLE (`setState`/`assign` build a new value, never mutate),\n *   so the diff short-circuits unchanged branches by identity — O(changed), not\n *   O(size). See `diff.ts`.\n * - Push work runs only while a subscriber exists. Transient readers call\n *   `readSince` explicitly; a dormant engine schedules nothing.\n *\n * All subscribers share one revision line. Fast subscribers share a patch;\n * slow subscribers receive a coalesced patch from their acknowledged state.\n * A revision mismatch makes the client resync instead of applying stale data.\n */\nexport class LiveState<State extends object> {\n  #current: State;\n  /** Latest flushed state — the shared diff baseline. */\n  #broadcast: State;\n  #revision = 0;\n  readonly #epoch = crypto.randomUUID();\n  #lastUpdate: Extract<LiveUpdate<State>, { type: \"patch\" }> | undefined;\n  #lastCompactUpdate: Extract<LiveUpdate<State>, { p: unknown }> | undefined;\n  readonly #subscribers = new Map<RetainedCallback<LiveUpdate<State>>, Subscriber<State>>();\n  readonly #debounceMs: number;\n  #flushTimer: ReturnType<typeof setTimeout> | undefined;\n\n  constructor(initial: State, options: { debounceMs?: number } = {}) {\n    this.#current = initial;\n    this.#broadcast = initial;\n    this.#debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;\n  }\n\n  /** The current state — reflects every `setState`/`assign`, even while dormant. */\n  getState(): State {\n    return this.#current;\n  }\n\n  /** One retained delta bounds history while a single parent can pull incrementally.\n   * A late reader or a new incarnation receives an explicit snapshot instead. */\n  readSince(\n    cursor?: LiveStateCursor,\n    options: LiveStateSubscriptionOptions = {},\n  ): LiveStateRead<State> {\n    if (this.#flushTimer !== undefined) clearTimeout(this.#flushTimer);\n    this.#flushTimer = undefined;\n    this.#flush();\n    if (cursor?.epoch === this.#epoch) {\n      if (cursor.revision === this.#revision) return { epoch: this.#epoch, update: null };\n      if (cursor.revision === this.#lastUpdate?.from) {\n        return {\n          epoch: this.#epoch,\n          update: options.patchVersion === 3 ? this.#lastCompactUpdate! : this.#lastUpdate,\n        };\n      }\n    }\n    return {\n      epoch: this.#epoch,\n      update:\n        options.patchVersion === 3\n          ? { s: [this.#revision, this.#broadcast] }\n          : { type: \"snapshot\", revision: this.#revision, state: this.#broadcast },\n    };\n  }\n\n  /** True while at least one live subscriber makes projection work observable. */\n  get observed(): boolean {\n    return this.#subscribers.size > 0;\n  }\n\n  /** Replace the state. Build a NEW value (don't mutate) so the diff stays cheap. */\n  setState(next: State | ((prev: State) => State)): void {\n    this.#current = typeof next === \"function\" ? next(this.#current) : next;\n    if (this.#subscribers.size > 0) this.#scheduleFlush();\n  }\n\n  /** Shallow-merge a partial into the state — sugar for `setState(p => ({ ...p, ...partial }))`. */\n  assign(partial: Partial<State>): void {\n    this.setState((prev) => ({ ...prev, ...partial }));\n  }\n\n  subscribe(\n    sink: (update: LiveUpdate<State>) => unknown,\n    options: LiveStateSubscriptionOptions = {},\n  ): LiveStateSubscription {\n    // First subscriber after dormancy: adopt the latest state as the shared\n    // baseline. While subscribers exist, `#broadcast` only advances inside a\n    // flush (with a patch to everyone), so it always matches what they've seen.\n    if (this.#subscribers.size === 0) {\n      this.#flush();\n    }\n\n    const retained = retainCallback(sink);\n    this.#subscribers.set(retained, {\n      version: options.patchVersion ?? 1,\n      state: this.#broadcast,\n      revision: this.#revision,\n      busy: false,\n    });\n    retained.onRpcBroken?.(() => this.#drop(retained));\n    // The initial snapshot is the first paint — delivered now, never debounced.\n    // A synchronously-throwing sink is dropped here and never becomes live.\n    this.#deliver(\n      retained,\n      options.patchVersion === 3\n        ? { s: [this.#revision, this.#broadcast] }\n        : { type: \"snapshot\", revision: this.#revision, state: this.#broadcast },\n    );\n\n    return {\n      ping: () => this.#subscribers.has(retained),\n      unsubscribe: () => this.#drop(retained),\n      [Symbol.dispose]: () => this.#drop(retained),\n    };\n  }\n\n  #scheduleFlush(): void {\n    this.#flushTimer ??= setTimeout(() => {\n      this.#flushTimer = undefined;\n      this.#flush();\n    }, this.#debounceMs);\n  }\n\n  #flush(): void {\n    const previous = this.#broadcast;\n    const patch = diff(previous, this.#current);\n    if (patch === undefined) return;\n    const from = this.#revision;\n    const to = (this.#revision += 1);\n    this.#broadcast = this.#current;\n    const update = { type: \"patch\", from, to, patch } satisfies LiveUpdate<State>;\n    this.#lastUpdate = update;\n    this.#lastCompactUpdate = { p: [from, to, compactPatch(previous, patch)] };\n    for (const subscriber of this.#subscribers.keys()) {\n      this.#sendLatest(subscriber);\n    }\n  }\n\n  /** Slow subscribers hold one call and one baseline, never a queue of token updates. */\n  #sendLatest(subscriber: RetainedCallback<LiveUpdate<State>>): void {\n    const held = this.#subscribers.get(subscriber);\n    if (!held || held.busy || held.revision === this.#revision) return;\n    if (held.version === 3) {\n      if (held.revision === this.#lastUpdate?.from) {\n        this.#deliver(subscriber, this.#lastCompactUpdate!);\n      } else {\n        const patch = diff(held.state, this.#broadcast);\n        this.#deliver(subscriber, {\n          p: [held.revision, this.#revision, patch ? compactPatch(held.state, patch) : {}],\n        });\n      }\n      return;\n    }\n    const patch =\n      held.version === 2 && held.revision === this.#lastUpdate?.from\n        ? this.#lastUpdate.patch\n        : diff(held.state, this.#broadcast, { arrays: held.version === 2 });\n    // A coalesced sequence may return to the same value. An empty object patch\n    // still advances its revision so the following shared update applies.\n    this.#deliver(subscriber, {\n      type: \"patch\",\n      from: held.revision,\n      to: this.#revision,\n      patch: patch ?? {},\n    });\n  }\n\n  /** Only acknowledgement releases the next coalesced update; a dead sink is dropped. */\n  #deliver(subscriber: RetainedCallback<LiveUpdate<State>>, update: LiveUpdate<State>): void {\n    const held = this.#subscribers.get(subscriber);\n    if (!held) return;\n    held.state = this.#broadcast;\n    held.revision = this.#revision;\n    held.busy = true;\n    let result: unknown;\n    try {\n      result = subscriber(update);\n    } catch {\n      this.#drop(subscriber);\n      return;\n    }\n    if (isThenable(result)) {\n      held.timeout = setTimeout(() => {\n        console.warn(\"Live-state subscriber dropped: acknowledgement timed out\", {\n          revision: held.revision,\n          timeoutMs: ACK_TIMEOUT_MS,\n        });\n        this.#drop(subscriber);\n      }, ACK_TIMEOUT_MS);\n      void Promise.resolve(result)\n        .then(\n          () => {\n            if (held.timeout !== undefined) clearTimeout(held.timeout);\n            held.busy = false;\n            this.#sendLatest(subscriber);\n          },\n          () => this.#drop(subscriber),\n        )\n        .finally(() => disposeIgnoredRpcResult(result));\n      return;\n    }\n    held.busy = false;\n    disposeIgnoredRpcResult(result);\n  }\n\n  #drop(subscriber: RetainedCallback<LiveUpdate<State>>): void {\n    const timeout = this.#subscribers.get(subscriber)?.timeout;\n    if (timeout !== undefined) clearTimeout(timeout);\n    if (!this.#subscribers.delete(subscriber)) return;\n    subscriber[Symbol.dispose]();\n    if (this.#subscribers.size === 0 && this.#flushTimer !== undefined) {\n      clearTimeout(this.#flushTimer); // dormant again: no work until the next subscriber\n      this.#flushTimer = undefined;\n    }\n  }\n}\n","// `iterate/sdk/capnweb` — live state end to end: the snapshot+patch wire\n// protocol, the structural diff that produces patches, the client store that\n// reassembles them, and the SERVER engine (`LiveState`) that holds a value\n// and pushes minimal diffs to retained RPC subscribers. No socket, no keeper\n// — a Worker or Durable Object can import it without dragging the browser\n// session machinery into its bundle.\nimport { RpcTarget } from \"@iterate-com/capnweb\";\nimport type { LiveState as LiveStateEngine, LiveStateSubscription } from \"./engine.ts\";\nimport type { LiveStateSubscriptionOptions, LiveUpdate } from \"./protocol.ts\";\nimport { isThenable } from \"./retain.ts\";\nimport type { LiveStateRpc, LiveStateSubscriptionHandle } from \"./types.ts\";\n\ntype LiveStateSource<State extends object> = Pick<LiveStateEngine<State>, \"getState\" | \"subscribe\">;\n\ntype RefreshingLiveStateSource<State extends object> = {\n  readonly live: LiveStateSource<State>;\n  loadAndRefreshLive(): void | PromiseLike<void>;\n};\n\nexport { createLiveStateStore, type LiveStateStore } from \"./store.ts\";\nexport { applyPatch, diff } from \"./diff.ts\";\nexport { compactPatch, applyCompactPatch } from \"./compact.ts\";\nexport { isLiveStateSnapshot, liveStateRevision } from \"./protocol.ts\";\nexport type {\n  CompactLiveStatePatch,\n  LiveStateCursor,\n  LiveStateRead,\n  LiveStatePatch,\n  LiveStateSubscriptionOptions,\n  LiveUpdate,\n} from \"./protocol.ts\";\nexport { LiveState, type LiveStateSubscription } from \"./engine.ts\";\nexport type { LiveStateRpc, LiveStateSubscriptionHandle } from \"./types.ts\";\nexport {\n  disposeIgnoredRpcResult,\n  isThenable,\n  retainCallback,\n  type RetainedCallback,\n} from \"./retain.ts\";\n\n/**\n * Expose mutable server state as a read-only Cap'n Web capability.\n * Pass an in-memory `LiveState`, or a stream-processor registry whose engine\n * must hydrate before its first snapshot.\n */\nexport class LiveStateRpcTarget<State extends object>\n  extends RpcTarget\n  implements LiveStateRpc<State>\n{\n  readonly #live: LiveStateSource<State>;\n  readonly #beforeRead: (() => void | PromiseLike<void>) | undefined;\n\n  constructor(source: LiveStateSource<State> | RefreshingLiveStateSource<State>) {\n    super();\n    if (\"loadAndRefreshLive\" in source) {\n      this.#live = source.live;\n      this.#beforeRead = () => source.loadAndRefreshLive();\n    } else {\n      this.#live = source;\n      this.#beforeRead = undefined;\n    }\n  }\n\n  async get() {\n    const loading = this.#beforeRead?.();\n    if (isThenable(loading)) await loading;\n    return this.#live.getState();\n  }\n\n  async subscribe(\n    onUpdate: (update: LiveUpdate<State>) => unknown,\n    options?: LiveStateSubscriptionOptions,\n  ) {\n    const loading = this.#beforeRead?.();\n    if (isThenable(loading)) await loading;\n    return new LiveStateSubscriptionRpcTarget(this.#live.subscribe(onUpdate, options));\n  }\n}\n\n/**\n * The wire handle for one subscription — `ping`/`unsubscribe` over RPC.\n * Exported for relays that build their subscription OUTSIDE a `LiveState`\n * engine (the worker-local liveState-socket relay) but must hand back the\n * same handle shape `LiveStateRpcTarget.subscribe` does.\n */\nexport class LiveStateSubscriptionRpcTarget\n  extends RpcTarget\n  implements LiveStateSubscriptionHandle\n{\n  readonly #subscription: LiveStateSubscription;\n\n  constructor(subscription: LiveStateSubscription) {\n    super();\n    this.#subscription = subscription;\n  }\n\n  ping() {\n    return this.#subscription.ping();\n  }\n\n  unsubscribe() {\n    this.#subscription.unsubscribe();\n  }\n\n  [Symbol.dispose]() {\n    this.#subscription.unsubscribe();\n  }\n}\n"],"mappings":"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"}