@langchain/langgraph-sdk 1.8.10 → 1.9.1

package/dist/stream/store.d.cts

@@ -0,0 +1,37 @@
+//#region src/stream/store.d.ts
+/**
+ * Minimal observable store backing every framework binding.
+ *
+ * The shape is intentionally tiny:
+ *
+ *  - `subscribe(listener) → unsubscribe` lines up with React's
+ *    `useSyncExternalStore`.
+ *  - `getSnapshot()` returns a referentially-stable value for
+ *    unchanged state so React can bail out of renders.
+ *  - Vue/Svelte/Angular bindings wrap `subscribe` + `getSnapshot` in
+ *    their own reactivity primitive (`shallowRef` / `writable` /
+ *    `signal`) in ~10 lines.
+ *
+ * Snapshot identity matters: a listener is only useful if
+ * `getSnapshot()` returns a *different* reference when state changes.
+ * Callers MUST pass a freshly-constructed value to {@link setState};
+ * mutating the previous snapshot in place will break React's bail-out
+ * and cause infinite re-renders.
+ */
+type StoreListener = () => void;
+declare class StreamStore<T> {
+  #private;
+  constructor(initial: T);
+  subscribe: (listener: StoreListener) => () => void;
+  getSnapshot: () => T;
+  /** Replace the snapshot and notify every listener. */
+  setValue: (next: T) => void;
+  /**
+   * Functional update. The `updater` receives the current snapshot and
+   * MUST return a new object. Returning the same reference is a no-op.
+   */
+  setState: (updater: (previous: T) => T) => void;
+}
+//#endregion
+export { StoreListener, StreamStore };
+//# sourceMappingURL=store.d.cts.map

package/dist/stream/store.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.cts","names":[],"sources":["../../src/stream/store.ts"],"mappings":";;AAoBA;;;;;AAEA;;;;;;;;;;;;;KAFY,aAAA;AAAA,cAEC,WAAA;EAAA;EAIX,WAAA,CAAY,OAAA,EAAS,CAAA;EAIrB,SAAA,GAAS,QAAA,EAAA,aAAA;EAOT,WAAA,QAAW,CAAA;EAAX;EAGA,QAAA,GAAQ,IAAA,EAAA,CAAA;EAAR;;;;EAUA,QAAA,GAAQ,OAAA,GAAA,QAAA,EAAA,CAAA,KAAA,CAAA;AAAA"}

package/dist/stream/store.d.ts

@@ -0,0 +1,37 @@
+//#region src/stream/store.d.ts
+/**
+ * Minimal observable store backing every framework binding.
+ *
+ * The shape is intentionally tiny:
+ *
+ *  - `subscribe(listener) → unsubscribe` lines up with React's
+ *    `useSyncExternalStore`.
+ *  - `getSnapshot()` returns a referentially-stable value for
+ *    unchanged state so React can bail out of renders.
+ *  - Vue/Svelte/Angular bindings wrap `subscribe` + `getSnapshot` in
+ *    their own reactivity primitive (`shallowRef` / `writable` /
+ *    `signal`) in ~10 lines.
+ *
+ * Snapshot identity matters: a listener is only useful if
+ * `getSnapshot()` returns a *different* reference when state changes.
+ * Callers MUST pass a freshly-constructed value to {@link setState};
+ * mutating the previous snapshot in place will break React's bail-out
+ * and cause infinite re-renders.
+ */
+type StoreListener = () => void;
+declare class StreamStore<T> {
+  #private;
+  constructor(initial: T);
+  subscribe: (listener: StoreListener) => () => void;
+  getSnapshot: () => T;
+  /** Replace the snapshot and notify every listener. */
+  setValue: (next: T) => void;
+  /**
+   * Functional update. The `updater` receives the current snapshot and
+   * MUST return a new object. Returning the same reference is a no-op.
+   */
+  setState: (updater: (previous: T) => T) => void;
+}
+//#endregion
+export { StoreListener, StreamStore };
+//# sourceMappingURL=store.d.ts.map

package/dist/stream/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","names":[],"sources":["../../src/stream/store.ts"],"mappings":";;AAoBA;;;;;AAEA;;;;;;;;;;;;;KAFY,aAAA;AAAA,cAEC,WAAA;EAAA;EAIX,WAAA,CAAY,OAAA,EAAS,CAAA;EAIrB,SAAA,GAAS,QAAA,EAAA,aAAA;EAOT,WAAA,QAAW,CAAA;EAAX;EAGA,QAAA,GAAQ,IAAA,EAAA,CAAA;EAAR;;;;EAUA,QAAA,GAAQ,OAAA,GAAA,QAAA,EAAA,CAAA,KAAA,CAAA;AAAA"}

package/dist/stream/store.js

@@ -0,0 +1,32 @@
+//#region src/stream/store.ts
+var StreamStore = class {
+	#snapshot;
+	#listeners = /* @__PURE__ */ new Set();
+	constructor(initial) {
+		this.#snapshot = initial;
+	}
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	};
+	getSnapshot = () => this.#snapshot;
+	/** Replace the snapshot and notify every listener. */
+	setValue = (next) => {
+		if (Object.is(next, this.#snapshot)) return;
+		this.#snapshot = next;
+		for (const listener of this.#listeners) listener();
+	};
+	/**
+	* Functional update. The `updater` receives the current snapshot and
+	* MUST return a new object. Returning the same reference is a no-op.
+	*/
+	setState = (updater) => {
+		this.setValue(updater(this.#snapshot));
+	};
+};
+//#endregion
+export { StreamStore };
+
+//# sourceMappingURL=store.js.map

package/dist/stream/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["#listeners","#snapshot"],"sources":["../../src/stream/store.ts"],"sourcesContent":["/**\n * Minimal observable store backing every framework binding.\n *\n * The shape is intentionally tiny:\n *\n *  - `subscribe(listener) → unsubscribe` lines up with React's\n *    `useSyncExternalStore`.\n *  - `getSnapshot()` returns a referentially-stable value for\n *    unchanged state so React can bail out of renders.\n *  - Vue/Svelte/Angular bindings wrap `subscribe` + `getSnapshot` in\n *    their own reactivity primitive (`shallowRef` / `writable` /\n *    `signal`) in ~10 lines.\n *\n * Snapshot identity matters: a listener is only useful if\n * `getSnapshot()` returns a *different* reference when state changes.\n * Callers MUST pass a freshly-constructed value to {@link setState};\n * mutating the previous snapshot in place will break React's bail-out\n * and cause infinite re-renders.\n */\n\nexport type StoreListener = () => void;\n\nexport class StreamStore<T> {\n  #snapshot: T;\n  readonly #listeners = new Set<StoreListener>();\n\n  constructor(initial: T) {\n    this.#snapshot = initial;\n  }\n\n  subscribe = (listener: StoreListener): (() => void) => {\n    this.#listeners.add(listener);\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  };\n\n  getSnapshot = (): T => this.#snapshot;\n\n  /** Replace the snapshot and notify every listener. */\n  setValue = (next: T): void => {\n    if (Object.is(next, this.#snapshot)) return;\n    this.#snapshot = next;\n    for (const listener of this.#listeners) listener();\n  };\n\n  /**\n   * Functional update. The `updater` receives the current snapshot and\n   * MUST return a new object. Returning the same reference is a no-op.\n   */\n  setState = (updater: (previous: T) => T): void => {\n    this.setValue(updater(this.#snapshot));\n  };\n}\n"],"mappings":";AAsBA,IAAa,cAAb,MAA4B;CAC1B;CACA,6BAAsB,IAAI,KAAoB;CAE9C,YAAY,SAAY;AACtB,QAAA,WAAiB;;CAGnB,aAAa,aAA0C;AACrD,QAAA,UAAgB,IAAI,SAAS;AAC7B,eAAa;AACX,SAAA,UAAgB,OAAO,SAAS;;;CAIpC,oBAAuB,MAAA;;CAGvB,YAAY,SAAkB;AAC5B,MAAI,OAAO,GAAG,MAAM,MAAA,SAAe,CAAE;AACrC,QAAA,WAAiB;AACjB,OAAK,MAAM,YAAY,MAAA,UAAiB,WAAU;;;;;;CAOpD,YAAY,YAAsC;AAChD,OAAK,SAAS,QAAQ,MAAA,SAAe,CAAC"}

package/dist/stream/submit-coordinator.cjs

@@ -0,0 +1,399 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let uuid = require("uuid");
+//#region src/stream/submit-coordinator.ts
+/**
+* Owns the run-submission lifecycle for a single
+* {@link StreamController}.
+*
+* # What this module is
+*
+* The {@link SubmitCoordinator} is the piece of the controller that
+* dispatches runs (`submit()`), enforces multitask strategies, queues
+* deferred submissions, races dispatch against terminal lifecycle
+* events, and surfaces errors back through the per-submit `onError`
+* callback and the root snapshot.
+*
+* Conceptually a submit looks like:
+*
+*   1. Optionally rebind to a different thread (`options.threadId`).
+*   2. Mint a thread id if one isn't bound yet.
+*   3. Wait for the controller's root pump to be ready (so the
+*      transport is subscribed before the run is dispatched —
+*      otherwise we could miss replayed events).
+*   4. Apply the {@link StreamSubmitOptions.multitaskStrategy} to
+*      decide whether to abort, enqueue, reject, or proceed.
+*   5. Race the dispatch promise (`thread.submitRun()` or
+*      `thread.respondInput()` for resumes) against the next root
+*      terminal lifecycle event.
+*   6. Settle the resulting state (loading flag, error slot) and
+*      drain the next queued submission, if any.
+*
+* # Why it lives in its own class
+*
+* The submit lifecycle is the most state-heavy part of the
+* controller — six promises, an abort controller, a queue, a
+* terminal-vs-command race, and bidirectional callback wiring with
+* the controller. Splitting it out keeps `controller.ts` focused on
+* subscription / projection wiring while letting the submit logic
+* evolve independently.
+*
+* # Why we race "command" against "terminal"
+*
+* For fast runs, the server's terminal lifecycle event can arrive
+* *before* the dispatch HTTP response has resolved. Racing the two
+* lets us detect terminal early and not block waiting for a now-stale
+* dispatch response. The dispatch response is still consumed (via
+* `.then(notifyCreated).catch(reportError)`) so `onCreated` still
+* fires and dispatch errors still surface through `onError`.
+*
+* # Queue semantics (`multitaskStrategy: "enqueue"`)
+*
+* When a run is already in flight, an `"enqueue"` submit is recorded
+* into {@link queueStore} and the call returns immediately. After the
+* active run terminates, `#drainQueue` schedules the head of the
+* queue as a fresh submit on the next macrotask. Each drained
+* submission has its own `multitaskStrategy` cleared so it doesn't
+* recursively re-enqueue.
+*
+* @see StreamController - The owner; injects every collaborator dep.
+*/
+/**
+* Frozen empty queue value used as the initial / cleared snapshot.
+*
+* Reusing one frozen reference keeps store identity stable across
+* empty resets, so React's `useSyncExternalStore` doesn't think the
+* queue changed when it actually didn't.
+*/
+const EMPTY_QUEUE = Object.freeze([]);
+/**
+* Coordinates one controller's run-submission lifecycle.
+*
+* The constructor takes a bag of callbacks rather than a reference to
+* the parent {@link StreamController} on purpose:
+*
+*   - It keeps the dependency surface explicit and testable — every
+*     piece of controller state the submit lifecycle touches is one
+*     of these closures.
+*   - It avoids a cyclic dependency between controller and coordinator.
+*   - Tests can construct one with stub callbacks and assert behavior
+*     without mocking the entire controller.
+*
+* @typeParam StateType         - Root state shape.
+* @typeParam InterruptType     - Root interrupt payload shape.
+* @typeParam ConfigurableType  - `config.configurable` shape accepted
+*   by submit (usually `Record<string, unknown>`).
+*/
+var SubmitCoordinator = class {
+	/** Controller-level options forwarded into `submitRun` / callbacks. */
+	#options;
+	/** Root snapshot store; written for `isLoading`, `error`, `interrupts`. */
+	#rootStore;
+	/** Pending submissions awaiting the active run to terminate. */
+	#queueStore;
+	/** Probes the controller's `disposed` flag from deferred work. */
+	#getDisposed;
+	/** Reads the controller's currently-bound thread id. */
+	#getCurrentThreadId;
+	/** Updates the controller's thread id (used when minting a new id). */
+	#setCurrentThreadId;
+	/** Records a thread id we created client-side so hydrate can skip a 404 round-trip. */
+	#rememberSelfCreatedThreadId;
+	/** Triggers a hydrate on the controller (used by `options.threadId` rebinds). */
+	#hydrate;
+	/** Lazily creates / returns the active {@link ThreadStream}. */
+	#ensureThread;
+	/** Resolves once the controller's root subscription pump is up. */
+	#waitForRootPumpReady;
+	/** Resolves on the next root terminal lifecycle (or on abort). */
+	#awaitNextTerminal;
+	/** Returns the most recent unresolved root interrupt, for resumes. */
+	#latestUnresolvedInterrupt;
+	/** Marks an interrupt id as resolved so it isn't re-targeted. */
+	#markInterruptResolved;
+	/**
+	* Active submission's abort controller. `undefined` between submits.
+	*
+	* Used both for `multitaskStrategy: "rollback"` (abort the previous
+	* controller's signal) and `stop()` (abort the current one without
+	* starting a new one).
+	*/
+	#runAbort;
+	constructor(params) {
+		this.#options = params.options;
+		this.#rootStore = params.rootStore;
+		this.#queueStore = params.queueStore;
+		this.#getDisposed = params.getDisposed;
+		this.#getCurrentThreadId = params.getCurrentThreadId;
+		this.#setCurrentThreadId = params.setCurrentThreadId;
+		this.#rememberSelfCreatedThreadId = params.rememberSelfCreatedThreadId;
+		this.#hydrate = params.hydrate;
+		this.#ensureThread = params.ensureThread;
+		this.#waitForRootPumpReady = params.waitForRootPumpReady;
+		this.#awaitNextTerminal = params.awaitNextTerminal;
+		this.#latestUnresolvedInterrupt = params.latestUnresolvedInterrupt;
+		this.#markInterruptResolved = params.markInterruptResolved;
+	}
+	/**
+	* Submit input or a resume command to the active thread.
+	*
+	* Honours {@link StreamSubmitOptions.multitaskStrategy}:
+	*
+	*   - `"rollback"` (default) — aborts any in-flight run and
+	*     dispatches immediately.
+	*   - `"reject"`              — throws synchronously when a run is
+	*     already in flight.
+	*   - `"enqueue"`             — defers via {@link #enqueueSubmission};
+	*     the call returns without dispatching.
+	*   - `"interrupt"`           — falls through to the default path
+	*     (server-side cancellation lands with roadmap A0.3).
+	*
+	* Errors are routed through both the per-submit `onError` callback
+	* and `rootStore.error`. Aborts (controller dispose / rollback) are
+	* silently dropped.
+	*
+	* @param input   - Input payload, or `null`/`undefined` for no input
+	*   (typical for resume commands).
+	* @param options - Per-submit options (config, metadata, callbacks,
+	*   strategy, etc).
+	*/
+	async submit(input, options) {
+		if (this.#getDisposed()) return;
+		const overrideThreadId = options?.threadId;
+		if (overrideThreadId !== void 0 && overrideThreadId !== this.#getCurrentThreadId()) await this.#hydrate(overrideThreadId);
+		if (this.#getCurrentThreadId() == null) {
+			const threadId = (0, uuid.v7)();
+			this.#setCurrentThreadId(threadId);
+			this.#rememberSelfCreatedThreadId(threadId);
+			this.#options.onThreadId?.(threadId);
+			this.#rootStore.setState((s) => ({
+				...s,
+				threadId
+			}));
+		}
+		const currentThreadId = this.#getCurrentThreadId();
+		if (currentThreadId == null) return;
+		const thread = this.#ensureThread(currentThreadId);
+		const activeThreadId = currentThreadId;
+		await this.#waitForRootPumpReady();
+		const strategy = options?.multitaskStrategy ?? "rollback";
+		const hasActiveRun = this.#runAbort != null && !this.#runAbort.signal.aborted;
+		if (hasActiveRun && strategy === "reject") throw new Error("submit() rejected: a run is already in flight and multitaskStrategy is 'reject'.");
+		if (hasActiveRun && strategy === "enqueue") {
+			this.#enqueueSubmission(input, options);
+			return;
+		}
+		this.#runAbort?.abort();
+		const abort = new AbortController();
+		this.#runAbort = abort;
+		const resumeCommand = options?.command?.resume;
+		const isResume = resumeCommand !== void 0;
+		this.#rootStore.setState((s) => ({
+			...s,
+			interrupts: [],
+			interrupt: void 0,
+			error: void 0,
+			isLoading: true
+		}));
+		const boundConfig = bindThreadConfig(options?.config, currentThreadId);
+		const terminalPromise = this.#awaitNextTerminal(abort.signal);
+		let terminalSettled = false;
+		const reportError = (error) => {
+			if (abort.signal.aborted) return;
+			this.#rootStore.setState((s) => ({
+				...s,
+				error
+			}));
+			try {
+				options?.onError?.(error);
+			} catch {}
+		};
+		try {
+			let terminal;
+			if (isResume) {
+				const target = this.#latestUnresolvedInterrupt();
+				if (target == null) throw new Error("submit({ command: { resume } }) called but no pending protocol interrupt is available.");
+				const commandPromise = thread.respondInput({
+					namespace: target.namespace,
+					interrupt_id: target.interruptId,
+					response: resumeCommand
+				});
+				this.#markInterruptResolved(target.interruptId);
+				const first = await Promise.race([terminalPromise.then((value) => ({
+					type: "terminal",
+					value
+				})), commandPromise.then(() => ({ type: "command" }), (error) => ({
+					type: "error",
+					error
+				}))]);
+				if (first.type === "error") throw first.error;
+				if (first.type === "terminal") {
+					terminal = first.value;
+					terminalSettled = true;
+					commandPromise.catch((error) => {
+						if (!terminalSettled) reportError(error);
+					});
+				}
+			} else {
+				const commandPromise = thread.submitRun({
+					input: input ?? null,
+					config: boundConfig,
+					metadata: options?.metadata ?? void 0,
+					forkFrom: options?.forkFrom,
+					multitaskStrategy: options?.multitaskStrategy === "enqueue" ? "enqueue" : options?.multitaskStrategy
+				});
+				const notifyCreated = (result) => {
+					this.#options.onCreated?.({
+						run_id: result.run_id,
+						thread_id: activeThreadId
+					});
+				};
+				const first = await Promise.race([terminalPromise.then((value) => ({
+					type: "terminal",
+					value
+				})), commandPromise.then((result) => ({
+					type: "command",
+					result
+				}), (error) => ({
+					type: "error",
+					error
+				}))]);
+				if (first.type === "error") throw first.error;
+				if (first.type === "command") notifyCreated(first.result);
+				else {
+					terminal = first.value;
+					terminalSettled = true;
+					commandPromise.then(notifyCreated).catch((error) => {
+						if (!terminalSettled) reportError(error);
+					});
+				}
+			}
+			terminal ??= await terminalPromise;
+			terminalSettled = true;
+			if (terminal.event === "failed" && !abort.signal.aborted) {
+				const runError = new Error(terminal.error ?? "Run failed with no error message");
+				this.#rootStore.setState((s) => ({
+					...s,
+					error: runError
+				}));
+				try {
+					options?.onError?.(runError);
+				} catch {}
+			}
+		} catch (error) {
+			reportError(error);
+		} finally {
+			this.#rootStore.setState((s) => ({
+				...s,
+				isLoading: false
+			}));
+			if (this.#runAbort === abort) this.#runAbort = void 0;
+			setTimeout(() => this.#drainQueue(), 0);
+		}
+	}
+	/**
+	* Abort the current run (if any) and force `isLoading=false`.
+	*
+	* Does NOT issue a server-side cancel — that lands with roadmap
+	* A0.3. Today this is a client-side stop only: subsequent events
+	* for the aborted run are ignored by the controller's pump because
+	* the abort signal is the same one `#awaitNextTerminal` is wired
+	* to.
+	*/
+	async stop() {
+		this.abortActiveRun();
+		this.#rootStore.setState((s) => ({
+			...s,
+			isLoading: false
+		}));
+	}
+	/**
+	* Abort the current run without forcing the loading flag down.
+	*
+	* Used by {@link StreamController.dispose}: disposal already tears
+	* down the root store, so flipping `isLoading` here is unnecessary
+	* and would race the dispose path.
+	*/
+	abortActiveRun() {
+		this.#runAbort?.abort();
+		this.#runAbort = void 0;
+	}
+	/**
+	* Cancel a queued submission by id.
+	*
+	* @param id - Client-side queue entry id to remove.
+	* @returns `true` when the entry was found and dropped, `false` otherwise.
+	*/
+	async cancelQueued(id) {
+		const current = this.#queueStore.getSnapshot();
+		const next = current.filter((entry) => entry.id !== id);
+		if (next.length === current.length) return false;
+		this.#queueStore.setState(() => next);
+		return true;
+	}
+	/**
+	* Drop every queued submission. Server-side cancel arrives with A0.3.
+	*/
+	async clearQueue() {
+		this.#queueStore.setState(() => EMPTY_QUEUE);
+	}
+	/**
+	* Append a submission to the queue without dispatching.
+	*
+	* The drained submission is later run via {@link #drainQueue} after
+	* the active run terminates.
+	*/
+	#enqueueSubmission(input, options) {
+		const entry = {
+			id: (0, uuid.v7)(),
+			values: input ?? void 0,
+			options,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.#queueStore.setState((current) => [...current, entry]);
+	}
+	/**
+	* Drain the head of the queue if no run is active.
+	*
+	* Called from the `finally` block of `submit()` on the next
+	* macrotask (so the just-finished run's state flushes first).
+	* Strips the strategy off the dequeued options to prevent infinite
+	* re-enqueueing.
+	*/
+	#drainQueue() {
+		if (this.#getDisposed()) return;
+		if (this.#runAbort != null && !this.#runAbort.signal.aborted) return;
+		const current = this.#queueStore.getSnapshot();
+		if (current.length === 0) return;
+		const [next, ...rest] = current;
+		this.#queueStore.setState(() => rest);
+		const nextOptions = {
+			...next.options ?? {},
+			multitaskStrategy: void 0
+		};
+		this.submit(next.values, nextOptions).catch(() => {});
+	}
+};
+/**
+* Merge `thread_id` into a user-supplied `config.configurable` blob.
+*
+* The platform expects `config.configurable.thread_id` on every run
+* dispatch; we set it last so user-supplied values can't accidentally
+* override the active thread id (which would route the run to a
+* different thread).
+*/
+function bindThreadConfig(config, threadId) {
+	const base = config != null && typeof config === "object" ? config : {};
+	const configurable = base.configurable != null && typeof base.configurable === "object" ? base.configurable : {};
+	return {
+		...base,
+		configurable: {
+			...configurable,
+			thread_id: threadId
+		}
+	};
+}
+//#endregion
+exports.EMPTY_QUEUE = EMPTY_QUEUE;
+exports.SubmitCoordinator = SubmitCoordinator;
+
+//# sourceMappingURL=submit-coordinator.cjs.map

package/dist/stream/submit-coordinator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit-coordinator.cjs","names":["#options","#rootStore","#queueStore","#getDisposed","#getCurrentThreadId","#setCurrentThreadId","#rememberSelfCreatedThreadId","#hydrate","#ensureThread","#waitForRootPumpReady","#awaitNextTerminal","#latestUnresolvedInterrupt","#markInterruptResolved","#runAbort","#enqueueSubmission","#drainQueue"],"sources":["../../src/stream/submit-coordinator.ts"],"sourcesContent":["/**\n * Owns the run-submission lifecycle for a single\n * {@link StreamController}.\n *\n * # What this module is\n *\n * The {@link SubmitCoordinator} is the piece of the controller that\n * dispatches runs (`submit()`), enforces multitask strategies, queues\n * deferred submissions, races dispatch against terminal lifecycle\n * events, and surfaces errors back through the per-submit `onError`\n * callback and the root snapshot.\n *\n * Conceptually a submit looks like:\n *\n *   1. Optionally rebind to a different thread (`options.threadId`).\n *   2. Mint a thread id if one isn't bound yet.\n *   3. Wait for the controller's root pump to be ready (so the\n *      transport is subscribed before the run is dispatched —\n *      otherwise we could miss replayed events).\n *   4. Apply the {@link StreamSubmitOptions.multitaskStrategy} to\n *      decide whether to abort, enqueue, reject, or proceed.\n *   5. Race the dispatch promise (`thread.submitRun()` or\n *      `thread.respondInput()` for resumes) against the next root\n *      terminal lifecycle event.\n *   6. Settle the resulting state (loading flag, error slot) and\n *      drain the next queued submission, if any.\n *\n * # Why it lives in its own class\n *\n * The submit lifecycle is the most state-heavy part of the\n * controller — six promises, an abort controller, a queue, a\n * terminal-vs-command race, and bidirectional callback wiring with\n * the controller. Splitting it out keeps `controller.ts` focused on\n * subscription / projection wiring while letting the submit logic\n * evolve independently.\n *\n * # Why we race \"command\" against \"terminal\"\n *\n * For fast runs, the server's terminal lifecycle event can arrive\n * *before* the dispatch HTTP response has resolved. Racing the two\n * lets us detect terminal early and not block waiting for a now-stale\n * dispatch response. The dispatch response is still consumed (via\n * `.then(notifyCreated).catch(reportError)`) so `onCreated` still\n * fires and dispatch errors still surface through `onError`.\n *\n * # Queue semantics (`multitaskStrategy: \"enqueue\"`)\n *\n * When a run is already in flight, an `\"enqueue\"` submit is recorded\n * into {@link queueStore} and the call returns immediately. After the\n * active run terminates, `#drainQueue` schedules the head of the\n * queue as a fresh submit on the next macrotask. Each drained\n * submission has its own `multitaskStrategy` cleared so it doesn't\n * recursively re-enqueue.\n *\n * @see StreamController - The owner; injects every collaborator dep.\n */\nimport { v7 as uuidv7 } from \"uuid\";\nimport type { ThreadStream } from \"../client/stream/index.js\";\nimport { StreamStore } from \"./store.js\";\nimport type {\n  RootSnapshot,\n  StreamControllerOptions,\n  StreamSubmitOptions,\n} from \"./types.js\";\n\n/**\n * Pointer to a pending root protocol interrupt. Used to target\n * `respondInput` for resume submissions.\n */\ninterface ResolvedInterrupt {\n  interruptId: string;\n  namespace: string[];\n}\n\n/**\n * Result of awaiting the next root terminal lifecycle event. Mirrors\n * the four terminal lifecycle states the protocol surfaces, plus a\n * synthetic `\"aborted\"` for client-side cancellation.\n */\ntype TerminalResult = {\n  event: \"completed\" | \"failed\" | \"interrupted\" | \"aborted\";\n  error?: string;\n};\n\n/**\n * Queued submission entry mirrored from the server-side run queue.\n *\n * Surfaces the deferred submission to UI consumers via\n * {@link StreamController.queueStore}.\n */\nexport interface SubmissionQueueEntry<\n  StateType extends object = Record<string, unknown>,\n> {\n  /** Stable id minted on enqueue (uuidv7 — sortable by creation time). */\n  readonly id: string;\n  /** Original submit input, narrowed to the partial state shape. */\n  readonly values: Partial<StateType> | null | undefined;\n  /** Original submit options, minus the strategy slot which is reset on drain. */\n  readonly options?: StreamSubmitOptions<StateType>;\n  /** Wall-clock timestamp at enqueue. */\n  readonly createdAt: Date;\n}\n\n/**\n * Read-only snapshot of the queue. The queue store hands this out\n * directly; consumers must not mutate the array.\n */\nexport type SubmissionQueueSnapshot<\n  StateType extends object = Record<string, unknown>,\n> = ReadonlyArray<SubmissionQueueEntry<StateType>>;\n\n/**\n * Frozen empty queue value used as the initial / cleared snapshot.\n *\n * Reusing one frozen reference keeps store identity stable across\n * empty resets, so React's `useSyncExternalStore` doesn't think the\n * queue changed when it actually didn't.\n */\nexport const EMPTY_QUEUE: SubmissionQueueSnapshot<never> = Object.freeze([]);\n\n/**\n * Coordinates one controller's run-submission lifecycle.\n *\n * The constructor takes a bag of callbacks rather than a reference to\n * the parent {@link StreamController} on purpose:\n *\n *   - It keeps the dependency surface explicit and testable — every\n *     piece of controller state the submit lifecycle touches is one\n *     of these closures.\n *   - It avoids a cyclic dependency between controller and coordinator.\n *   - Tests can construct one with stub callbacks and assert behavior\n *     without mocking the entire controller.\n *\n * @typeParam StateType         - Root state shape.\n * @typeParam InterruptType     - Root interrupt payload shape.\n * @typeParam ConfigurableType  - `config.configurable` shape accepted\n *   by submit (usually `Record<string, unknown>`).\n */\nexport class SubmitCoordinator<\n  StateType extends object = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> {\n  /** Controller-level options forwarded into `submitRun` / callbacks. */\n  readonly #options: StreamControllerOptions<StateType>;\n  /** Root snapshot store; written for `isLoading`, `error`, `interrupts`. */\n  readonly #rootStore: StreamStore<RootSnapshot<StateType, InterruptType>>;\n  /** Pending submissions awaiting the active run to terminate. */\n  readonly #queueStore: StreamStore<SubmissionQueueSnapshot<StateType>>;\n  /** Probes the controller's `disposed` flag from deferred work. */\n  readonly #getDisposed: () => boolean;\n  /** Reads the controller's currently-bound thread id. */\n  readonly #getCurrentThreadId: () => string | null;\n  /** Updates the controller's thread id (used when minting a new id). */\n  readonly #setCurrentThreadId: (threadId: string | null) => void;\n  /** Records a thread id we created client-side so hydrate can skip a 404 round-trip. */\n  readonly #rememberSelfCreatedThreadId: (threadId: string) => void;\n  /** Triggers a hydrate on the controller (used by `options.threadId` rebinds). */\n  readonly #hydrate: (threadId?: string | null) => Promise<void>;\n  /** Lazily creates / returns the active {@link ThreadStream}. */\n  readonly #ensureThread: (threadId: string) => ThreadStream;\n  /** Resolves once the controller's root subscription pump is up. */\n  readonly #waitForRootPumpReady: () => Promise<void> | undefined;\n  /** Resolves on the next root terminal lifecycle (or on abort). */\n  readonly #awaitNextTerminal: (signal: AbortSignal) => Promise<TerminalResult>;\n  /** Returns the most recent unresolved root interrupt, for resumes. */\n  readonly #latestUnresolvedInterrupt: () => ResolvedInterrupt | null;\n  /** Marks an interrupt id as resolved so it isn't re-targeted. */\n  readonly #markInterruptResolved: (interruptId: string) => void;\n\n  /**\n   * Active submission's abort controller. `undefined` between submits.\n   *\n   * Used both for `multitaskStrategy: \"rollback\"` (abort the previous\n   * controller's signal) and `stop()` (abort the current one without\n   * starting a new one).\n   */\n  #runAbort: AbortController | undefined;\n\n  constructor(params: {\n    options: StreamControllerOptions<StateType>;\n    rootStore: StreamStore<RootSnapshot<StateType, InterruptType>>;\n    queueStore: StreamStore<SubmissionQueueSnapshot<StateType>>;\n    getDisposed: () => boolean;\n    getCurrentThreadId: () => string | null;\n    setCurrentThreadId: (threadId: string | null) => void;\n    rememberSelfCreatedThreadId: (threadId: string) => void;\n    hydrate: (threadId?: string | null) => Promise<void>;\n    ensureThread: (threadId: string) => ThreadStream;\n    waitForRootPumpReady: () => Promise<void> | undefined;\n    awaitNextTerminal: (signal: AbortSignal) => Promise<TerminalResult>;\n    latestUnresolvedInterrupt: () => ResolvedInterrupt | null;\n    markInterruptResolved: (interruptId: string) => void;\n  }) {\n    this.#options = params.options;\n    this.#rootStore = params.rootStore;\n    this.#queueStore = params.queueStore;\n    this.#getDisposed = params.getDisposed;\n    this.#getCurrentThreadId = params.getCurrentThreadId;\n    this.#setCurrentThreadId = params.setCurrentThreadId;\n    this.#rememberSelfCreatedThreadId = params.rememberSelfCreatedThreadId;\n    this.#hydrate = params.hydrate;\n    this.#ensureThread = params.ensureThread;\n    this.#waitForRootPumpReady = params.waitForRootPumpReady;\n    this.#awaitNextTerminal = params.awaitNextTerminal;\n    this.#latestUnresolvedInterrupt = params.latestUnresolvedInterrupt;\n    this.#markInterruptResolved = params.markInterruptResolved;\n  }\n\n  /**\n   * Submit input or a resume command to the active thread.\n   *\n   * Honours {@link StreamSubmitOptions.multitaskStrategy}:\n   *\n   *   - `\"rollback\"` (default) — aborts any in-flight run and\n   *     dispatches immediately.\n   *   - `\"reject\"`              — throws synchronously when a run is\n   *     already in flight.\n   *   - `\"enqueue\"`             — defers via {@link #enqueueSubmission};\n   *     the call returns without dispatching.\n   *   - `\"interrupt\"`           — falls through to the default path\n   *     (server-side cancellation lands with roadmap A0.3).\n   *\n   * Errors are routed through both the per-submit `onError` callback\n   * and `rootStore.error`. Aborts (controller dispose / rollback) are\n   * silently dropped.\n   *\n   * @param input   - Input payload, or `null`/`undefined` for no input\n   *   (typical for resume commands).\n   * @param options - Per-submit options (config, metadata, callbacks,\n   *   strategy, etc).\n   */\n  async submit(\n    input: unknown,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void> {\n    if (this.#getDisposed()) return;\n\n    // Per-submit thread override: rebind first so the rest of the\n    // submit operates against the new thread.\n    const overrideThreadId = options?.threadId;\n    if (\n      overrideThreadId !== undefined &&\n      overrideThreadId !== this.#getCurrentThreadId()\n    ) {\n      await this.#hydrate(overrideThreadId);\n    }\n\n    // Self-created thread id path: mint client-side so the controller\n    // (and Suspense boundaries) get a stable id even before the run\n    // is dispatched.\n    if (this.#getCurrentThreadId() == null) {\n      const threadId = uuidv7();\n      this.#setCurrentThreadId(threadId);\n      this.#rememberSelfCreatedThreadId(threadId);\n      this.#options.onThreadId?.(threadId);\n      this.#rootStore.setState((s) => ({\n        ...s,\n        threadId,\n      }));\n    }\n\n    const currentThreadId = this.#getCurrentThreadId();\n    if (currentThreadId == null) return;\n    const thread = this.#ensureThread(currentThreadId);\n    const activeThreadId = currentThreadId;\n    // Wait for the root subscription to be live; otherwise the\n    // dispatch could resolve before we're listening for events and\n    // we'd miss the terminal that ends the run.\n    await this.#waitForRootPumpReady();\n\n    const strategy = options?.multitaskStrategy ?? \"rollback\";\n    const hasActiveRun =\n      this.#runAbort != null && !this.#runAbort.signal.aborted;\n    if (hasActiveRun && strategy === \"reject\") {\n      throw new Error(\n        \"submit() rejected: a run is already in flight and multitaskStrategy is 'reject'.\"\n      );\n    }\n    if (hasActiveRun && strategy === \"enqueue\") {\n      this.#enqueueSubmission(input, options);\n      return;\n    }\n\n    // Rollback: abort the previous run before starting a new one.\n    this.#runAbort?.abort();\n    const abort = new AbortController();\n    this.#runAbort = abort;\n\n    const resumeCommand = options?.command?.resume;\n    const isResume = resumeCommand !== undefined;\n\n    // Optimistically clear interrupts/error and flip loading. The\n    // root pump's lifecycle listener will re-flip these as the run\n    // terminates.\n    this.#rootStore.setState((s) => ({\n      ...s,\n      interrupts: [],\n      interrupt: undefined,\n      error: undefined,\n      isLoading: true,\n    }));\n\n    const boundConfig = bindThreadConfig(options?.config, currentThreadId);\n    // Subscribe to the next terminal *before* dispatching so a fast\n    // run's terminal can't race us.\n    const terminalPromise = this.#awaitNextTerminal(abort.signal);\n\n    let terminalSettled = false;\n    const reportError = (error: unknown): void => {\n      if (abort.signal.aborted) return;\n      this.#rootStore.setState((s) => ({ ...s, error }));\n      try {\n        options?.onError?.(error);\n      } catch {\n        /* caller-supplied callback errors must not crash the submit */\n      }\n    };\n\n    try {\n      let terminal: TerminalResult | undefined;\n\n      if (isResume) {\n        const target = this.#latestUnresolvedInterrupt();\n        if (target == null) {\n          throw new Error(\n            \"submit({ command: { resume } }) called but no pending protocol interrupt is available.\"\n          );\n        }\n        const commandPromise = thread.respondInput({\n          namespace: target.namespace,\n          interrupt_id: target.interruptId,\n          response: resumeCommand,\n        });\n        // Mark resolved synchronously: even if the response races and\n        // the command settles after the terminal, we don't want to\n        // re-target this same interrupt on the next submit.\n        this.#markInterruptResolved(target.interruptId);\n        const first = await Promise.race([\n          terminalPromise.then((value) => ({\n            type: \"terminal\" as const,\n            value,\n          })),\n          commandPromise.then(\n            () => ({ type: \"command\" as const }),\n            (error) => ({ type: \"error\" as const, error })\n          ),\n        ]);\n        if (first.type === \"error\") throw first.error;\n        if (first.type === \"terminal\") {\n          terminal = first.value;\n          terminalSettled = true;\n          // Stale command response — surface as error only if it\n          // arrives with a real failure (not just our own abort).\n          void commandPromise.catch((error) => {\n            if (!terminalSettled) reportError(error);\n          });\n        }\n      } else {\n        const commandPromise = thread.submitRun({\n          input: input ?? null,\n          config: boundConfig,\n          metadata: (options?.metadata ?? undefined) as Record<string, unknown>,\n          forkFrom: options?.forkFrom,\n          multitaskStrategy:\n            options?.multitaskStrategy === \"enqueue\"\n              ? \"enqueue\"\n              : options?.multitaskStrategy,\n        });\n        const notifyCreated = (result: { run_id?: unknown }) => {\n          this.#options.onCreated?.({\n            run_id: result.run_id as string,\n            thread_id: activeThreadId,\n          });\n        };\n        const first = await Promise.race([\n          terminalPromise.then((value) => ({\n            type: \"terminal\" as const,\n            value,\n          })),\n          commandPromise.then(\n            (result) => ({ type: \"command\" as const, result }),\n            (error) => ({ type: \"error\" as const, error })\n          ),\n        ]);\n        if (first.type === \"error\") throw first.error;\n        if (first.type === \"command\") {\n          notifyCreated(first.result);\n        } else {\n          // Terminal landed first (very fast runs). Wait for the\n          // dispatch response in the background so onCreated fires\n          // and dispatch errors still surface.\n          terminal = first.value;\n          terminalSettled = true;\n          void commandPromise.then(notifyCreated).catch((error) => {\n            if (!terminalSettled) reportError(error);\n          });\n        }\n      }\n\n      terminal ??= await terminalPromise;\n      terminalSettled = true;\n      if (terminal.event === \"failed\" && !abort.signal.aborted) {\n        const runError = new Error(\n          terminal.error ?? \"Run failed with no error message\"\n        );\n        this.#rootStore.setState((s) => ({ ...s, error: runError }));\n        try {\n          options?.onError?.(runError);\n        } catch {\n          /* caller-supplied callback errors must not crash the submit */\n        }\n      }\n    } catch (error) {\n      reportError(error);\n    } finally {\n      // Always settle loading and clear our slot of the abort\n      // controller. Schedule queue drain on the next macrotask so any\n      // late state updates from this run finish flushing first.\n      this.#rootStore.setState((s) => ({ ...s, isLoading: false }));\n      if (this.#runAbort === abort) this.#runAbort = undefined;\n      setTimeout(() => this.#drainQueue(), 0);\n    }\n  }\n\n  /**\n   * Abort the current run (if any) and force `isLoading=false`.\n   *\n   * Does NOT issue a server-side cancel — that lands with roadmap\n   * A0.3. Today this is a client-side stop only: subsequent events\n   * for the aborted run are ignored by the controller's pump because\n   * the abort signal is the same one `#awaitNextTerminal` is wired\n   * to.\n   */\n  async stop(): Promise<void> {\n    this.abortActiveRun();\n    this.#rootStore.setState((s) => ({ ...s, isLoading: false }));\n  }\n\n  /**\n   * Abort the current run without forcing the loading flag down.\n   *\n   * Used by {@link StreamController.dispose}: disposal already tears\n   * down the root store, so flipping `isLoading` here is unnecessary\n   * and would race the dispose path.\n   */\n  abortActiveRun(): void {\n    this.#runAbort?.abort();\n    this.#runAbort = undefined;\n  }\n\n  /**\n   * Cancel a queued submission by id.\n   *\n   * @param id - Client-side queue entry id to remove.\n   * @returns `true` when the entry was found and dropped, `false` otherwise.\n   */\n  async cancelQueued(id: string): Promise<boolean> {\n    const current = this.#queueStore.getSnapshot();\n    const next = current.filter((entry) => entry.id !== id);\n    if (next.length === current.length) return false;\n    this.#queueStore.setState(() => next);\n    return true;\n  }\n\n  /**\n   * Drop every queued submission. Server-side cancel arrives with A0.3.\n   */\n  async clearQueue(): Promise<void> {\n    this.#queueStore.setState(\n      () => EMPTY_QUEUE as SubmissionQueueSnapshot<StateType>\n    );\n  }\n\n  /**\n   * Append a submission to the queue without dispatching.\n   *\n   * The drained submission is later run via {@link #drainQueue} after\n   * the active run terminates.\n   */\n  #enqueueSubmission(\n    input: unknown,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): void {\n    const entry: SubmissionQueueEntry<StateType> = {\n      id: uuidv7(),\n      values: (input ?? undefined) as Partial<StateType> | null | undefined,\n      options: options as StreamSubmitOptions<StateType> | undefined,\n      createdAt: new Date(),\n    };\n    this.#queueStore.setState((current) => [...current, entry]);\n  }\n\n  /**\n   * Drain the head of the queue if no run is active.\n   *\n   * Called from the `finally` block of `submit()` on the next\n   * macrotask (so the just-finished run's state flushes first).\n   * Strips the strategy off the dequeued options to prevent infinite\n   * re-enqueueing.\n   */\n  #drainQueue(): void {\n    if (this.#getDisposed()) return;\n    if (this.#runAbort != null && !this.#runAbort.signal.aborted) return;\n    const current = this.#queueStore.getSnapshot();\n    if (current.length === 0) return;\n    const [next, ...rest] = current;\n    this.#queueStore.setState(() => rest);\n    const nextOptions: StreamSubmitOptions<StateType, ConfigurableType> = {\n      ...((next.options ?? {}) as StreamSubmitOptions<\n        StateType,\n        ConfigurableType\n      >),\n      multitaskStrategy: undefined,\n    };\n    void this.submit(next.values, nextOptions).catch(() => {\n      /* submit() already routes errors through the per-submit onError\n       * hook and the root store; swallow here so a failing drain does\n       * not surface as an unhandled rejection. */\n    });\n  }\n}\n\n/**\n * Merge `thread_id` into a user-supplied `config.configurable` blob.\n *\n * The platform expects `config.configurable.thread_id` on every run\n * dispatch; we set it last so user-supplied values can't accidentally\n * override the active thread id (which would route the run to a\n * different thread).\n */\nfunction bindThreadConfig(\n  config: unknown,\n  threadId: string\n): Record<string, unknown> {\n  const base =\n    config != null && typeof config === \"object\"\n      ? (config as Record<string, unknown>)\n      : {};\n  const configurable =\n    base.configurable != null && typeof base.configurable === \"object\"\n      ? (base.configurable as Record<string, unknown>)\n      : {};\n  return {\n    ...base,\n    configurable: {\n      ...configurable,\n      thread_id: threadId,\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/stream/submit-coordinator.d.cts

@@ -0,0 +1,27 @@
+import { StreamSubmitOptions } from "./types.cjs";
+
+//#region src/stream/submit-coordinator.d.ts
+/**
+ * Queued submission entry mirrored from the server-side run queue.
+ *
+ * Surfaces the deferred submission to UI consumers via
+ * {@link StreamController.queueStore}.
+ */
+interface SubmissionQueueEntry<StateType extends object = Record<string, unknown>> {
+  /** Stable id minted on enqueue (uuidv7 — sortable by creation time). */
+  readonly id: string;
+  /** Original submit input, narrowed to the partial state shape. */
+  readonly values: Partial<StateType> | null | undefined;
+  /** Original submit options, minus the strategy slot which is reset on drain. */
+  readonly options?: StreamSubmitOptions<StateType>;
+  /** Wall-clock timestamp at enqueue. */
+  readonly createdAt: Date;
+}
+/**
+ * Read-only snapshot of the queue. The queue store hands this out
+ * directly; consumers must not mutate the array.
+ */
+type SubmissionQueueSnapshot<StateType extends object = Record<string, unknown>> = ReadonlyArray<SubmissionQueueEntry<StateType>>;
+//#endregion
+export { SubmissionQueueEntry, SubmissionQueueSnapshot };
+//# sourceMappingURL=submit-coordinator.d.cts.map

package/dist/stream/submit-coordinator.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit-coordinator.d.cts","names":[],"sources":["../../src/stream/submit-coordinator.ts"],"mappings":";;;;;;;;;UA0FiB,oBAAA,4BACY,MAAA;EAgBjB;EAAA,SAbD,EAAA;EAawB;EAAA,SAXxB,MAAA,EAAQ,OAAA,CAAQ,SAAA;EAaY;EAAA,SAX5B,OAAA,GAAU,mBAAA,CAAoB,SAAA;EAWrC;EAAA,SATO,SAAA,EAAW,IAAA;AAAA;;;;;KAOV,uBAAA,4BACiB,MAAA,qBACzB,aAAA,CAAc,oBAAA,CAAqB,SAAA"}

package/dist/stream/submit-coordinator.d.ts

@@ -0,0 +1,27 @@
+import { StreamSubmitOptions } from "./types.js";
+
+//#region src/stream/submit-coordinator.d.ts
+/**
+ * Queued submission entry mirrored from the server-side run queue.
+ *
+ * Surfaces the deferred submission to UI consumers via
+ * {@link StreamController.queueStore}.
+ */
+interface SubmissionQueueEntry<StateType extends object = Record<string, unknown>> {
+  /** Stable id minted on enqueue (uuidv7 — sortable by creation time). */
+  readonly id: string;
+  /** Original submit input, narrowed to the partial state shape. */
+  readonly values: Partial<StateType> | null | undefined;
+  /** Original submit options, minus the strategy slot which is reset on drain. */
+  readonly options?: StreamSubmitOptions<StateType>;
+  /** Wall-clock timestamp at enqueue. */
+  readonly createdAt: Date;
+}
+/**
+ * Read-only snapshot of the queue. The queue store hands this out
+ * directly; consumers must not mutate the array.
+ */
+type SubmissionQueueSnapshot<StateType extends object = Record<string, unknown>> = ReadonlyArray<SubmissionQueueEntry<StateType>>;
+//#endregion
+export { SubmissionQueueEntry, SubmissionQueueSnapshot };
+//# sourceMappingURL=submit-coordinator.d.ts.map

package/dist/stream/submit-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit-coordinator.d.ts","names":[],"sources":["../../src/stream/submit-coordinator.ts"],"mappings":";;;;;;;;;UA0FiB,oBAAA,4BACY,MAAA;EASH;EAAA,SANf,EAAA;EAawB;EAAA,SAXxB,MAAA,EAAQ,OAAA,CAAQ,SAAA;EAYE;EAAA,SAVlB,OAAA,GAAU,mBAAA,CAAoB,SAAA;EAWvB;EAAA,SATP,SAAA,EAAW,IAAA;AAAA;;;;;KAOV,uBAAA,4BACiB,MAAA,qBACzB,aAAA,CAAc,oBAAA,CAAqB,SAAA"}