@mostra/react 0.0.0-stage → 0.2.0

package/dist/hooks-Dh_l8KqJ.js

@@ -0,0 +1,2737 @@
+import { BROWSER_PROTOCOL_REVISION, MCP_APPS_PROTOCOL_VERSION, MutationId, OPEN_LINK_SCHEMES, RemoteError, SIGNAL_NAME_PATTERN, ValueReader, connectBridge, deserializeAll, isFieldId, isFinalRunStatus, mostraControlsRequest, mostraReady, serializeAll, uiInitialize, uiInitialized, uiOpenLink } from "@mostra/protocol";
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+//#region src/runtime/errors.ts
+/** An error with a Mostra diagnostic code, such as `MOSTRA_SUBMIT_CHANNEL_DENIED`. */
+var MostraError = class extends Error {
+	/** The stable diagnostic code. */
+	code;
+	/** The HTTP status the gateway answered with, when the error came from it. */
+	status;
+	/** The diagnostic, when the gateway sent one. */
+	diagnostic;
+	/** Extra data the refusal carried, such as the existing submission of `MOSTRA_SUBMIT_ALREADY`. */
+	body;
+	constructor(code, message, options = {}) {
+		super(message);
+		this.name = "MostraError";
+		this.code = code;
+		this.status = options.status;
+		this.diagnostic = options.diagnostic;
+		this.body = options.body;
+	}
+};
+/** `MOSTRA_TARGET_UNAVAILABLE`: what the delivery target can't do (a static export, D111). */
+function targetUnavailable(what) {
+	return new MostraError("MOSTRA_TARGET_UNAVAILABLE", `${what} needs the artifact's Mostra link; this copy of the page has no Mostra server.`);
+}
+//#endregion
+//#region src/runtime/journal.ts
+/** The key of a pending edit: one per viewer, tab, scope and field. */
+const pendingKey = (entry) => `p\u0000${entry.viewerId}\u0000${entry.tab}\u0000${entry.scope}\u0000${entry.op.id}`;
+const mutationKey = (mutationId) => `m\u0000${mutationId}`;
+const keyOf = (entry) => entry.kind === "pending" ? pendingKey(entry) : mutationKey(entry.mutationId);
+function split(entries, viewerId) {
+	const mine = entries.filter((entry) => entry.viewerId === viewerId);
+	return {
+		pending: mine.filter((entry) => entry.kind === "pending"),
+		mutations: mine.filter((entry) => entry.kind === "mutation").sort((a, b) => a.seq - b.seq)
+	};
+}
+/** The journal in memory: for targets without IndexedDB, and for tests. */
+var MemoryJournal = class {
+	durable = false;
+	#entries = /* @__PURE__ */ new Map();
+	async load(viewerId) {
+		return split([...this.#entries.values()], viewerId);
+	}
+	async putPending(entry) {
+		this.#entries.set(pendingKey(entry), entry);
+	}
+	async promote(mutation, consumed) {
+		for (const entry of consumed) this.#entries.delete(pendingKey(entry));
+		this.#entries.set(mutationKey(mutation.mutationId), mutation);
+	}
+	async remove(mutationId) {
+		this.#entries.delete(mutationKey(mutationId));
+	}
+	async dropPending(entry) {
+		this.#entries.delete(pendingKey(entry));
+	}
+	async adopt(entries, tab) {
+		for (const entry of entries) {
+			this.#entries.delete(keyOf(entry));
+			const moved = {
+				...entry,
+				tab
+			};
+			const key = keyOf(moved);
+			if (!this.#entries.has(key)) this.#entries.set(key, moved);
+		}
+	}
+};
+const DB_NAME = "mostra";
+const STORE = "journal";
+function request(req) {
+	return new Promise((resolve, reject) => {
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+function done(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+		transaction.onabort = () => reject(transaction.error ?? /* @__PURE__ */ new Error("The transaction aborted."));
+	});
+}
+/**
+* The journal in the artifact origin's IndexedDB: one database per origin, so per artifact (D38).
+* Each write starts its transaction at once, so an edit made just before the page closes is in it.
+*/
+var IndexedDbJournal = class IndexedDbJournal {
+	durable = true;
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	/** Opens the journal; `undefined` where IndexedDB can't be used (a private mode, a sandbox). */
+	static async open() {
+		if (typeof indexedDB === "undefined") return void 0;
+		try {
+			const open = indexedDB.open(DB_NAME, 1);
+			open.onupgradeneeded = () => {
+				if (!open.result.objectStoreNames.contains(STORE)) open.result.createObjectStore(STORE);
+			};
+			return new IndexedDbJournal(await request(open));
+		} catch {
+			return;
+		}
+	}
+	#write(change) {
+		const transaction = this.#db.transaction(STORE, "readwrite");
+		change(transaction.objectStore(STORE));
+		return done(transaction);
+	}
+	async load(viewerId) {
+		return split(await request(this.#db.transaction(STORE, "readonly").objectStore(STORE).getAll()), viewerId);
+	}
+	putPending(entry) {
+		return this.#write((store) => store.put(entry, pendingKey(entry)));
+	}
+	promote(mutation, consumed) {
+		return this.#write((store) => {
+			for (const entry of consumed) store.delete(pendingKey(entry));
+			store.put(mutation, mutationKey(mutation.mutationId));
+		});
+	}
+	remove(mutationId) {
+		return this.#write((store) => store.delete(mutationKey(mutationId)));
+	}
+	dropPending(entry) {
+		return this.#write((store) => store.delete(pendingKey(entry)));
+	}
+	async adopt(entries, tab) {
+		const transaction = this.#db.transaction(STORE, "readwrite");
+		const store = transaction.objectStore(STORE);
+		for (const entry of entries) {
+			store.delete(keyOf(entry));
+			const moved = {
+				...entry,
+				tab
+			};
+			const added = store.add(moved, keyOf(moved));
+			added.onerror = (event) => {
+				event.preventDefault();
+				event.stopPropagation();
+			};
+		}
+		await done(transaction);
+	}
+};
+//#endregion
+//#region src/runtime/transport.ts
+/**
+* How the client runtime reaches Mostra (INTERFACES §4): the browser protocol over the artifact's
+* own origin, with its session cookie and CSRF token. A delivery target without a gateway (a
+* static export, an MCP App before its transport, D111) gets another implementation of the same
+* interface, so hooks never know which they talk to.
+*/
+/** The connection to the gateway failed before it answered: the page is offline. */
+var NetworkError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NetworkError";
+	}
+};
+/** After this many stream failures in a row, the client long-polls instead (FAILURE_MODEL §8). */
+const STREAM_FAILURES_BEFORE_POLL = 2;
+/**
+* The browser protocol over HTTP, on the artifact's origin. The CSRF token comes from
+* `/_mostra/session`, once; a refusal is a {@link MostraError} with the gateway's diagnostic, and
+* an unreachable gateway a {@link NetworkError}.
+*/
+var HttpTransport = class {
+	#viewId;
+	#base;
+	#csrf;
+	/**
+	* `csrf` is the session's token when the caller already read it (the bridge does): a save made
+	* as the page closes must not wait for a request the closing page would cancel (IN-02).
+	*/
+	constructor(viewId, options = {}) {
+		this.#viewId = viewId;
+		this.#base = options.base ?? `/_mostra/v/${BROWSER_PROTOCOL_REVISION}`;
+		if (options.csrf) this.#csrf = Promise.resolve(options.csrf);
+	}
+	#token() {
+		this.#csrf ??= (async () => {
+			return (await this.#request("/_mostra/session", { method: "GET" })).csrf;
+		})().catch((error) => {
+			this.#csrf = void 0;
+			throw error;
+		});
+		return this.#csrf;
+	}
+	async #request(path, init) {
+		let response;
+		try {
+			response = await fetch(path, {
+				credentials: "same-origin",
+				cache: "no-store",
+				...init
+			});
+		} catch (error) {
+			throw new NetworkError(error.message);
+		}
+		let body;
+		try {
+			body = await response.json();
+		} catch {
+			body = void 0;
+		}
+		if (!response.ok) {
+			const diagnostic = body ?? {};
+			if (typeof diagnostic.code !== "string") throw new NetworkError(`The gateway answered ${response.status}.`);
+			throw new MostraError(diagnostic.code, diagnostic.message ?? diagnostic.code, {
+				status: response.status,
+				diagnostic,
+				body: diagnostic
+			});
+		}
+		return body;
+	}
+	async #post(path, body, keepalive = false) {
+		const text = JSON.stringify(body);
+		const csrf = await this.#token();
+		return this.#request(`${this.#base}${path}`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"x-mostra-csrf": csrf
+			},
+			body: text,
+			keepalive: keepalive && text.length < 64512
+		});
+	}
+	async snapshot() {
+		const result = await this.#request(`${this.#base}/events/poll?view=${this.#viewId}&wait=0`, { method: "GET" });
+		if (!result.snapshot) throw new NetworkError("The gateway sent no snapshot.");
+		return result.snapshot;
+	}
+	mutate(request, options) {
+		return this.#post("/fields", request, options?.keepalive === true);
+	}
+	submit(request) {
+		return this.#post("/submit", request);
+	}
+	signal(request) {
+		return this.#post("/signal", request);
+	}
+	async *call(fnId, request, signal) {
+		const csrf = await this.#token();
+		let response;
+		try {
+			response = await fetch(`${this.#base}/call/${encodeURIComponent(fnId)}`, {
+				method: "POST",
+				credentials: "same-origin",
+				cache: "no-store",
+				headers: {
+					"content-type": "application/json",
+					"x-mostra-csrf": csrf
+				},
+				body: JSON.stringify(request),
+				...signal ? { signal } : {}
+			});
+		} catch (error) {
+			throw new NetworkError(error.message);
+		}
+		if (!response.ok || !response.body) {
+			let body;
+			try {
+				body = await response.json();
+			} catch {
+				body = void 0;
+			}
+			const diagnostic = body ?? {};
+			if (typeof diagnostic.code !== "string") throw new NetworkError(`The gateway answered ${response.status}.`);
+			throw new MostraError(diagnostic.code, diagnostic.message ?? diagnostic.code, {
+				status: response.status,
+				diagnostic
+			});
+		}
+		const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+		let buffer = "";
+		try {
+			for (;;) {
+				let chunk;
+				try {
+					chunk = await reader.read();
+				} catch (error) {
+					throw new NetworkError(error.message);
+				}
+				if (chunk.done) break;
+				buffer += chunk.value;
+				let newline = buffer.indexOf("\n");
+				while (newline !== -1) {
+					const line = buffer.slice(0, newline);
+					buffer = buffer.slice(newline + 1);
+					if (line.trim() !== "") yield JSON.parse(line);
+					newline = buffer.indexOf("\n");
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (buffer.trim() !== "") yield JSON.parse(buffer);
+	}
+	startRun(request) {
+		return this.#post("/runs", request);
+	}
+	attachRuns(request) {
+		return this.#post("/runs/attach", request);
+	}
+	cancelRun(runId, viewId) {
+		return this.#post(`/runs/${encodeURIComponent(runId)}/cancel`, { viewId });
+	}
+	live(request) {
+		return this.#post("/live", request);
+	}
+	subscribe(cursor, handlers) {
+		let closed = false;
+		let last = cursor;
+		let source;
+		let failures = 0;
+		let polling = false;
+		let retry;
+		const query = () => `view=${this.#viewId}${last === void 0 ? "" : `&cursor=${last}`}`;
+		const poll = async () => {
+			polling = true;
+			let backoff = 1e3;
+			while (!closed) try {
+				const result = await this.#request(`${this.#base}/events/poll?${query()}&wait=25`, { method: "GET" });
+				backoff = 1e3;
+				handlers.onStatus("live");
+				if (result.snapshot) handlers.onSnapshot(result.snapshot);
+				if (result.events.length > 0) handlers.onEvents(result.events);
+				for (const message of result.ephemeral ?? []) handlers.onEphemeral?.(message);
+				last = result.cursor;
+			} catch (error) {
+				if (error instanceof MostraError && error.code === "MOSTRA_HYGIENE_TOKEN_REVOKED") {
+					handlers.onStatus("revoked");
+					return;
+				}
+				handlers.onStatus("offline");
+				await new Promise((resolve) => {
+					retry = setTimeout(resolve, backoff);
+				});
+				backoff = Math.min(backoff * 2, 3e4);
+			}
+		};
+		const open = () => {
+			if (closed) return;
+			if (typeof EventSource === "undefined") {
+				poll();
+				return;
+			}
+			source = new EventSource(`${this.#base}/events?${query()}`);
+			source.addEventListener("open", () => {
+				failures = 0;
+				handlers.onStatus("live");
+			});
+			source.addEventListener("snapshot", (event) => {
+				failures = 0;
+				const snapshot = JSON.parse(event.data);
+				last = snapshot.cursor;
+				handlers.onSnapshot(snapshot);
+			});
+			source.addEventListener("mostra", (event) => {
+				failures = 0;
+				const record = JSON.parse(event.data);
+				last = record.cursor;
+				handlers.onEvents([record]);
+			});
+			source.addEventListener("run", (event) => {
+				const run = JSON.parse(event.data);
+				handlers.onEphemeral?.({
+					kind: "run",
+					run
+				});
+			});
+			source.addEventListener("live", (event) => {
+				const live = JSON.parse(event.data);
+				handlers.onEphemeral?.({
+					kind: "live",
+					live
+				});
+			});
+			source.addEventListener("error", () => {
+				if (closed) return;
+				failures += 1;
+				handlers.onStatus("offline");
+				if (source?.readyState === EventSource.CLOSED || failures >= STREAM_FAILURES_BEFORE_POLL) {
+					source?.close();
+					source = void 0;
+					if (!polling) poll();
+				}
+			});
+		};
+		open();
+		return () => {
+			closed = true;
+			source?.close();
+			if (retry !== void 0) clearTimeout(retry);
+		};
+	}
+};
+//#endregion
+//#region src/runtime/server-client.ts
+/**
+* The page's server side (D54, D56; WP-08): plain calls to `"use server"` functions, durable action
+* runs, and live sources, over the store's transport. Runs and sources are tracked per page: one
+* record per run and per source however many hooks show it, fed by the stream's ephemeral
+* messages and read again whenever a message may have been missed (a gap, a reconnect, a renewal),
+* so what a page shows always converges on what the server holds.
+*/
+/** How often a page renews its interest in the runs and sources it shows (the lease is a minute). */
+const RENEW_MS = 2e4;
+/** How many times a run's start is retried after the network failed, with the same client key. */
+const START_ATTEMPTS = 6;
+/** How many runs' early updates a page keeps, and how many updates of each (see `#keepEarly`). */
+const EARLY_RUNS = 64;
+const EARLY_DELTAS_PER_RUN = 32;
+/** The function ID a server reference carries, or `undefined` for any other function. */
+function serverFunctionId(fn) {
+	const id = fn?.mostraServerFunctionId;
+	return typeof id === "string" ? id : void 0;
+}
+/** A random client key: a run's request idempotency (a retried POST joins its own run). */
+function clientKey() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	globalThis.crypto.getRandomValues(bytes);
+	return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** The error a failed or cancelled run, or call, rejects with. */
+function failure(error, fallback) {
+	return new MostraError(error?.code ?? fallback, error?.message ?? "The action failed.");
+}
+/** Plain calls, action runs and live sources for one page. */
+var ServerClient = class {
+	#options;
+	#runs = /* @__PURE__ */ new Map();
+	#live = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Set();
+	#version = 0;
+	#nextWatcher = 1;
+	#renewTimer;
+	#liveFlush;
+	#liveRefresh = /* @__PURE__ */ new Set();
+	#notifyScheduled = false;
+	/** Plain calls whose value hasn't arrived yet. */
+	#callsInFlight = 0;
+	/**
+	* Updates for runs the page doesn't track yet: a fast run's end can arrive on the stream before
+	* the answer that starts it, and is applied when that answer is (bounded, oldest dropped).
+	*/
+	#early = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#options = options;
+	}
+	/** Calls `listener` after every change; returns the function that stops. */
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	};
+	/** A number that changes with every change, for `useSyncExternalStore`. */
+	version = () => this.#version;
+	/**
+	* Server work the page is waiting on: plain calls whose value hasn't arrived, runs that haven't
+	* ended, and live sources a component shows that have no first value yet. `verify`'s field
+	* probe reads it, so the runner judges the page once what it loads at mount has arrived (Opus
+	* review finding 1).
+	*/
+	pending() {
+		let count = this.#callsInFlight;
+		for (const tracked of this.#runs.values()) if (!isFinalRunStatus(tracked.view.status)) count += 1;
+		for (const tracked of this.#live.values()) if (tracked.view.loading && tracked.watchers.size > 0) count += 1;
+		return count;
+	}
+	/**
+	* Notes a change. Listeners hear about it once per animation frame (FAILURE_MODEL §6), or in a
+	* microtask where a page has no frames to draw (a hidden tab, outside a browser), so a source
+	* producing hundreds of values a second renders at most once a frame.
+	*/
+	#changed() {
+		this.#version += 1;
+		if (this.#notifyScheduled) return;
+		this.#notifyScheduled = true;
+		const notify = () => {
+			this.#notifyScheduled = false;
+			for (const listener of [...this.#listeners]) listener();
+		};
+		if ((typeof document === "undefined" ? false : document.visibilityState === "visible") && typeof requestAnimationFrame === "function") requestAnimationFrame(notify);
+		else queueMicrotask(notify);
+	}
+	#transport(what) {
+		const transport = this.#options.transport;
+		if (!transport?.call || this.#options.viewId === void 0) throw targetUnavailable(what);
+		return transport;
+	}
+	get #viewId() {
+		return this.#options.viewId ?? "";
+	}
+	/**
+	* Calls a server function: no record, the result as soon as its first batch arrives (an async
+	* iterable result keeps yielding as later batches come).
+	*/
+	async call(fnId, args) {
+		const transport = this.#transport(`Calling the server function ${fnId}`);
+		const batches = await serializeAll([...args], {
+			mode: "argument",
+			serverFunctionId: (fn) => serverFunctionId(fn)
+		});
+		const reader = new ValueReader({ serverFunction: (id) => this.reference(id) });
+		const lines = transport.call(fnId, {
+			viewId: this.#viewId,
+			args: batches
+		})[Symbol.asyncIterator]();
+		let ended;
+		const pump = async () => {
+			for (;;) {
+				const next = await lines.next();
+				if (next.done) break;
+				const line = next.value;
+				if ("batch" in line) reader.push(line.batch);
+				else ended = line.end;
+			}
+			if (ended?.status === "failed") throw failure(ended.error, "MOSTRA_ACTION_THREW");
+			if (!ended) throw new NetworkError("The call's answer ended early.");
+		};
+		const pumped = pump();
+		this.#callsInFlight += 1;
+		try {
+			const root = await Promise.race([reader.root, pumped.then(() => reader.root)]);
+			pumped.catch((error) => reader.fail(error));
+			return root;
+		} finally {
+			this.#callsInFlight -= 1;
+		}
+	}
+	/** The client stub of a server function a result refers to. */
+	reference(id) {
+		const fn = ((...args) => this.call(id, args));
+		Object.defineProperty(fn, "mostraServerFunctionId", {
+			value: id,
+			enumerable: true
+		});
+		return fn;
+	}
+	/** What the page knows of a run. */
+	run(runId) {
+		return this.#runs.get(runId)?.view;
+	}
+	/**
+	* Starts a run, or joins the one its key names (AC-03). The request carries a client key, so a
+	* retry after a dropped answer joins the run it started instead of starting another.
+	*/
+	async startRun(fnId, args, key) {
+		const transport = this.#transport("Running actions");
+		const batches = await serializeAll([...args], {
+			mode: "argument",
+			serverFunctionId: (fn) => serverFunctionId(fn)
+		});
+		const ck = clientKey();
+		let delay = 500;
+		for (let attempt = 1;; attempt++) try {
+			const state = await transport.startRun({
+				viewId: this.#viewId,
+				fnId,
+				args: batches,
+				...key !== void 0 ? { key } : {},
+				clientKey: ck
+			});
+			return this.#track(state);
+		} catch (error) {
+			if (!(error instanceof NetworkError) || attempt >= START_ATTEMPTS) throw error;
+			await new Promise((resolve) => this.#setTimeout(() => resolve(void 0), delay));
+			delay = Math.min(delay * 2, 8e3);
+		}
+	}
+	/** Finds runs by ID, or by function and key (a reloaded page re-attaching, AC-02). */
+	async attach(input) {
+		const transport = this.#transport("Running actions");
+		const held = (input.runIds ?? []).flatMap((runId) => {
+			const tracked = this.#runs.get(runId);
+			return tracked && (tracked.view.log.length > 0 || tracked.batches.length > 0) ? [{
+				runId,
+				log: tracked.view.log.length,
+				batches: tracked.batches.length
+			}] : [];
+		});
+		const { runs } = await transport.attachRuns({
+			viewId: this.#viewId,
+			...input.runIds && input.runIds.length > 0 ? { runIds: input.runIds } : {},
+			...input.keyed && input.keyed.length > 0 ? { keyed: input.keyed } : {},
+			...held.length > 0 ? { held } : {}
+		});
+		return runs.map((state) => this.#track(state));
+	}
+	/** Cancels a run (AC-04): its `abortSignal` fires on the server. */
+	async cancel(runId) {
+		const state = await this.#transport("Cancelling actions").cancelRun(runId, this.#viewId);
+		this.#track(state);
+	}
+	/** Resolves with the run's result once it succeeded; rejects when it failed or was cancelled. */
+	settled(runId) {
+		const tracked = this.#runs.get(runId);
+		if (!tracked) return Promise.reject(new MostraError("MOSTRA_ACTION_RUN_NOT_FOUND", runId));
+		return tracked.settled;
+	}
+	#newRun(state) {
+		let resolve;
+		let reject;
+		const settled = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		settled.catch(() => {});
+		return {
+			view: {
+				runId: state.runId,
+				fnId: state.fnId,
+				...state.key !== void 0 ? { key: state.key } : {},
+				status: state.status,
+				log: [],
+				partial: []
+			},
+			batches: [],
+			reader: new ValueReader({ serverFunction: (id) => this.reference(id) }),
+			rootDecoded: false,
+			settled,
+			resolve,
+			reject
+		};
+	}
+	/** Merges a full run state: the server's account wins. */
+	#track(state) {
+		let tracked = this.#runs.get(state.runId);
+		if (!tracked) {
+			tracked = this.#newRun(state);
+			this.#runs.set(state.runId, tracked);
+		}
+		this.#merge(tracked, {
+			runId: state.runId,
+			status: state.status,
+			...state.reason !== void 0 ? { reason: state.reason } : {},
+			...state.progress ? { progress: state.progress } : {},
+			logFrom: state.logFrom ?? 0,
+			log: state.log,
+			batchFrom: state.batchFrom ?? 0,
+			batches: state.batches,
+			...state.error ? { error: state.error } : {},
+			...state.finishedAt ? { finishedAt: state.finishedAt } : {}
+		});
+		const early = this.#early.get(state.runId);
+		if (early) {
+			this.#early.delete(state.runId);
+			const current = tracked;
+			if (!early.every((delta) => this.#merge(current, delta))) this.attach({ runIds: [state.runId] }).catch(() => {});
+		}
+		this.#renewSoon();
+		return tracked.view;
+	}
+	/** Applies a run delta; returns `false` when it skipped something the page doesn't have. */
+	#merge(tracked, delta) {
+		const view = tracked.view;
+		if (delta.logFrom > view.log.length || delta.batchFrom > tracked.batches.length) return false;
+		if (isFinalRunStatus(view.status) && !isFinalRunStatus(delta.status)) return true;
+		const log = [...view.log, ...delta.log.slice(view.log.length - delta.logFrom)];
+		const fresh = delta.batches.slice(tracked.batches.length - delta.batchFrom);
+		for (const batch of fresh) {
+			tracked.batches.push([...batch]);
+			try {
+				tracked.reader.push(batch);
+			} catch (error) {
+				tracked.reader.fail(error);
+			}
+		}
+		tracked.view = {
+			...view,
+			status: delta.status,
+			...delta.reason !== void 0 ? { reason: delta.reason } : {},
+			...delta.progress ? { progress: delta.progress } : {},
+			log,
+			...delta.error ? { error: delta.error } : {},
+			...delta.finishedAt ? { finishedAt: delta.finishedAt } : {}
+		};
+		if (fresh.length > 0 && !tracked.rootDecoded) this.#decodeRoot(tracked);
+		if (isFinalRunStatus(delta.status)) this.#settle(tracked);
+		this.#changed();
+		return true;
+	}
+	#decodeRoot(tracked) {
+		tracked.rootDecoded = true;
+		tracked.reader.root.then((root) => {
+			tracked.view = {
+				...tracked.view,
+				data: root
+			};
+			this.#changed();
+			if (root !== null && typeof root === "object" && Symbol.asyncIterator in root) (async () => {
+				try {
+					for await (const item of root) {
+						tracked.view = {
+							...tracked.view,
+							partial: [...tracked.view.partial, item]
+						};
+						this.#changed();
+					}
+				} catch {}
+			})();
+		}, () => {});
+	}
+	/** Settles the run's promise once it reached a final state. */
+	#settle(tracked) {
+		const { status, error } = tracked.view;
+		if (status === "succeeded") {
+			if (tracked.batches.length === 0) {
+				tracked.resolve(void 0);
+				return;
+			}
+			if (!tracked.rootDecoded) this.#decodeRoot(tracked);
+			tracked.reader.root.then(tracked.resolve, tracked.reject);
+			queueMicrotask(() => {
+				if (!tracked.reader.complete) tracked.reader.fail(new RemoteError({ message: "The result ended early." }));
+			});
+			return;
+		}
+		const ended = status === "cancelled" ? error ?? {
+			code: "MOSTRA_ACTION_CANCELLED",
+			message: "The run was cancelled."
+		} : error;
+		tracked.reader.fail(new RemoteError(ended ?? { message: "The action failed." }));
+		tracked.reject(failure(ended, status === "cancelled" ? "MOSTRA_ACTION_CANCELLED" : "MOSTRA_ACTION_THREW"));
+	}
+	/** What the page knows of a live source. */
+	liveView(key) {
+		return this.#live.get(key)?.view;
+	}
+	/**
+	* Shows a live source: reads it now and keeps it produced while the page shows it. Returns the
+	* function that stops showing it.
+	*/
+	watchLive(key, window) {
+		let tracked = this.#live.get(key);
+		if (!tracked) {
+			tracked = {
+				view: {
+					key,
+					loading: true,
+					ring: []
+				},
+				watchers: /* @__PURE__ */ new Map(),
+				newest: 0,
+				ringRevisions: [],
+				applying: Promise.resolve()
+			};
+			this.#live.set(key, tracked);
+		}
+		const id = this.#nextWatcher++;
+		tracked.watchers.set(id, window);
+		this.#flushLive();
+		return () => {
+			tracked.watchers.delete(id);
+		};
+	}
+	/** Asks the source's producer to load again now (`useLive`'s `refresh()`). */
+	refreshLive(key) {
+		this.#liveRefresh.add(key);
+		this.#flushLive();
+	}
+	#windowOf(tracked) {
+		let largest;
+		for (const window of tracked.watchers.values()) if (window !== void 0) largest = Math.max(largest ?? 0, window);
+		return largest;
+	}
+	/** Reads every shown source in one request, coalesced within a tick. */
+	#flushLive() {
+		if (this.#liveFlush) return;
+		this.#liveFlush = Promise.resolve().then(async () => {
+			this.#liveFlush = void 0;
+			const shown = [...this.#live.values()].filter((tracked) => tracked.watchers.size > 0);
+			if (shown.length === 0) return;
+			const refresh = this.#liveRefresh;
+			this.#liveRefresh = /* @__PURE__ */ new Set();
+			let transport;
+			try {
+				transport = this.#transport("Live data");
+			} catch (error) {
+				for (const tracked of shown) {
+					const diagnostic = error;
+					tracked.view = {
+						...tracked.view,
+						loading: false,
+						error: {
+							message: diagnostic.message,
+							code: diagnostic.code
+						}
+					};
+				}
+				this.#changed();
+				return;
+			}
+			try {
+				const { sources } = await transport.live({
+					viewId: this.#viewId,
+					keys: shown.map((tracked) => {
+						const window = this.#windowOf(tracked);
+						return {
+							key: tracked.view.key,
+							...window !== void 0 ? { window } : {},
+							...refresh.has(tracked.view.key) ? { refresh: true } : {}
+						};
+					})
+				});
+				for (const source of sources) await this.#applyLiveState(source);
+			} catch (error) {
+				for (const tracked of shown) {
+					if (tracked.view.revision !== void 0) continue;
+					tracked.view = {
+						...tracked.view,
+						...error instanceof MostraError ? {
+							loading: false,
+							error: {
+								message: error.message,
+								code: error.code
+							}
+						} : {}
+					};
+				}
+				this.#changed();
+			}
+			this.#renewSoon();
+		});
+	}
+	/** Applies `apply` to a source after everything that arrived for it before. */
+	#inOrder(key, apply) {
+		const tracked = this.#live.get(key);
+		if (!tracked) return Promise.resolve();
+		const next = tracked.applying.then(() => apply(tracked)).catch(() => {});
+		tracked.applying = next;
+		return next;
+	}
+	#applyLiveState(state) {
+		return this.#inOrder(state.key, (tracked) => this.#applyLiveStateNow(tracked, state));
+	}
+	#applyLiveUpdate(update) {
+		const tracked = this.#live.get(update.key);
+		if (!tracked) return Promise.resolve();
+		if (update.value !== void 0 && this.#windowOf(tracked) === void 0) {
+			const waiting = tracked.pending;
+			if (!waiting || Number(update.revision ?? 0) > Number(waiting.revision ?? 0)) tracked.pending = update;
+			if (waiting) return tracked.applying;
+			return this.#inOrder(update.key, async (current) => {
+				const next = current.pending;
+				delete current.pending;
+				if (next) await this.#applyLiveUpdateNow(current, next);
+			});
+		}
+		return this.#inOrder(update.key, (current) => this.#applyLiveUpdateNow(current, update));
+	}
+	async #applyLiveStateNow(tracked, state) {
+		const revision = Number(state.revision ?? 0);
+		if (state.ring) {
+			const values = await Promise.all(state.ring.map((entry) => decode(entry.value)));
+			const revisions = state.ring.map((entry) => Number(entry.revision));
+			const last = revisions.at(-1) ?? 0;
+			const kept = tracked.ringRevisions.flatMap((held, index) => held > last ? [{
+				revision: held,
+				value: tracked.view.ring[index]
+			}] : []);
+			const window = this.#windowOf(tracked);
+			const merged = [...values, ...kept.map((entry) => entry.value)];
+			const mergedRevisions = [...revisions, ...kept.map((entry) => entry.revision)];
+			tracked.ringRevisions = window === void 0 ? mergedRevisions : mergedRevisions.slice(-window);
+			tracked.view = {
+				...tracked.view,
+				ring: window === void 0 ? merged : merged.slice(-window)
+			};
+		}
+		if (state.value && revision >= tracked.newest) {
+			tracked.newest = revision;
+			const data = await decode(state.value);
+			if (revision < tracked.newest) return;
+			tracked.view = {
+				...tracked.view,
+				data,
+				...state.revision !== void 0 ? { revision: state.revision } : {},
+				...state.at !== void 0 ? { at: state.at } : {}
+			};
+		}
+		tracked.view = {
+			...tracked.view,
+			loading: false,
+			...state.error ? { error: state.error } : {}
+		};
+		if (!state.error && tracked.view.error) {
+			const { error: _cleared, ...rest } = tracked.view;
+			tracked.view = rest;
+		}
+		this.#changed();
+	}
+	async #applyLiveUpdateNow(tracked, update) {
+		if (update.error && !update.value) {
+			tracked.view = {
+				...tracked.view,
+				loading: false,
+				error: update.error
+			};
+			this.#changed();
+			return;
+		}
+		const revision = Number(update.revision ?? 0);
+		if (!update.value || revision <= tracked.newest) return;
+		const skipped = tracked.newest > 0 && revision > tracked.newest + 1 && this.#windowOf(tracked) !== void 0;
+		tracked.newest = revision;
+		const data = await decode(update.value);
+		const window = this.#windowOf(tracked);
+		const ring = window === void 0 ? tracked.view.ring : [...tracked.view.ring, data].slice(-window);
+		if (window !== void 0) tracked.ringRevisions = [...tracked.ringRevisions, revision].slice(-window);
+		const { error: _cleared, ...rest } = tracked.view;
+		tracked.view = {
+			...rest,
+			loading: false,
+			data,
+			ring,
+			revision: String(revision),
+			...update.at !== void 0 ? { at: update.at } : {}
+		};
+		this.#changed();
+		if (skipped) this.#flushLive();
+	}
+	/** One ephemeral message from the page's stream. */
+	receive(message) {
+		if (message.kind === "run") {
+			const tracked = this.#runs.get(message.run.runId);
+			if (!tracked) {
+				this.#keepEarly(message.run);
+				return;
+			}
+			if (!this.#merge(tracked, message.run)) this.attach({ runIds: [message.run.runId] }).catch(() => {});
+		} else this.#applyLiveUpdate(message.live);
+	}
+	/** Keeps an update for a run the page will track once its start is answered. */
+	#keepEarly(delta) {
+		const kept = this.#early.get(delta.runId);
+		if (kept) {
+			if (kept.length < EARLY_DELTAS_PER_RUN) kept.push(delta);
+			return;
+		}
+		if (this.#early.size >= EARLY_RUNS) {
+			const oldest = this.#early.keys().next().value;
+			if (oldest !== void 0) this.#early.delete(oldest);
+		}
+		this.#early.set(delta.runId, [delta]);
+	}
+	/** The stream came back after a gap: read again what may have been missed. */
+	resync() {
+		const open = [...this.#runs.values()].filter((tracked) => !isFinalRunStatus(tracked.view.status));
+		if (open.length > 0) this.attach({ runIds: open.map((tracked) => tracked.view.runId) }).catch(() => {});
+		this.#flushLive();
+	}
+	/** Renews interest in open runs and shown sources before their lease ends. */
+	#renewSoon() {
+		if (this.#renewTimer !== void 0) return;
+		this.#renewTimer = this.#setTimeout(() => {
+			this.#renewTimer = void 0;
+			const open = [...this.#runs.values()].filter((tracked) => !isFinalRunStatus(tracked.view.status));
+			const shown = [...this.#live.values()].some((tracked) => tracked.watchers.size > 0);
+			if (open.length > 0 || shown) {
+				this.resync();
+				this.#renewSoon();
+			}
+		}, RENEW_MS);
+	}
+	#setTimeout(fn, ms) {
+		return this.#options.timers ? this.#options.timers.setTimeout(fn, ms) : setTimeout(fn, ms);
+	}
+	/** Stops renewing (the page is going away, or a test ends). */
+	stop() {
+		if (this.#renewTimer === void 0) return;
+		if (this.#options.timers) this.#options.timers.clearTimeout(this.#renewTimer);
+		else clearTimeout(this.#renewTimer);
+		this.#renewTimer = void 0;
+	}
+};
+/** A serialized live value, read back. */
+function decode(value) {
+	return deserializeAll(value);
+}
+/** How long a submit waits for the event stream to reach the page's own last save. */
+const CATCH_UP_MS = 5e3;
+/** How soon waiting saves try again once the event stream shows the gateway answers. */
+const RETRY_SOON_MS = 250;
+/** The most ops one mutation carries (the browser protocol's limit). */
+const OPS_PER_MUTATION = 1e3;
+/** A field's key. */
+const fieldKey = (scope, id) => `${scope}:${id}`;
+const DELIVERY_SEVERITY = {
+	delivered: 0,
+	pending: 1,
+	rejected: 2,
+	undeliverable: 3
+};
+/**
+* One submission's two accounts merged: each delivery as its latest change says, so an answer
+* built before newer events never takes the state back (Claude review finding 8).
+*/
+function mergedSubmission(known, next) {
+	if (known?.id !== next.id || known.deliveries === void 0) return next;
+	const newer = new Map((next.deliveries ?? []).map((delivery) => [delivery.deliveryId, delivery]));
+	for (const delivery of known.deliveries) {
+		const other = newer.get(delivery.deliveryId);
+		if (other === void 0 || delivery.updatedAt > other.updatedAt) newer.set(delivery.deliveryId, delivery);
+	}
+	const deliveries = [...newer.values()];
+	let worst = "delivered";
+	for (const delivery of deliveries) if (DELIVERY_SEVERITY[delivery.state] > DELIVERY_SEVERITY[worst]) worst = delivery.state;
+	return {
+		...next,
+		deliveries,
+		delivery: deliveries.length > 0 ? worst : next.delivery
+	};
+}
+/** Deep equality for JSON values. */
+function same(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	return keysA.every((key) => same(a[key], b[key]));
+}
+/** Whether a required field's value counts as missing. */
+function isEmpty(value) {
+	return value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
+}
+const keyParts = (key) => {
+	const at = key.indexOf(":");
+	return {
+		scope: key.slice(0, at),
+		id: key.slice(at + 1)
+	};
+};
+/** The runtime's store of one page. */
+var Store = class {
+	mode;
+	view;
+	#options;
+	#timers;
+	#server = /* @__PURE__ */ new Map();
+	/** The revision the event stream reached, per document: every change up to it was seen. */
+	#seen = {
+		viewer: 0,
+		artifact: 0
+	};
+	#epoch = 1;
+	#viewer;
+	/** Whether the first snapshot arrived. */
+	#loaded = false;
+	/** Delivery events for a submission not known yet (the stream may beat the submit's answer). */
+	#earlyDeliveries = [];
+	#submission;
+	/** Whether a submission closed the viewer's draft (`once`, D106). */
+	#closed = false;
+	#pending = /* @__PURE__ */ new Map();
+	#inflight = /* @__PURE__ */ new Map();
+	/** The value each in-flight mutation sends, per field. */
+	#sending = /* @__PURE__ */ new Map();
+	#conflicts = /* @__PURE__ */ new Map();
+	/** Edits the gateway refused for good (too large, invalid): kept, shown with the reason. */
+	#refused = /* @__PURE__ */ new Map();
+	/** Mutations waiting for the network, in order. */
+	#queue = [];
+	#registrations = /* @__PURE__ */ new Map();
+	/** Who hears each mount and unmount: `verify`'s field probe (D138). */
+	#mountObservers = /* @__PURE__ */ new Set();
+	#ready = false;
+	#readyWaiters = [];
+	#online = true;
+	#revoked = false;
+	#debounce;
+	#retry;
+	#retryMs = 1e3;
+	#sendingQueue = false;
+	#seq = 0;
+	#version = 0;
+	#listeners = /* @__PURE__ */ new Set();
+	#keyVersions = /* @__PURE__ */ new Map();
+	#broadcast;
+	#submitState = "open";
+	#catchUp = [];
+	/**
+	* Fields another writer changed whose new value the page hasn't got (a sensitive value isn't in
+	* events, D52): an edit of one is based on what the page last had, so it conflicts instead of
+	* overwriting, and a submit waits until a snapshot brings the value.
+	*/
+	#unknown = /* @__PURE__ */ new Set();
+	#resyncing;
+	#beforeSubmit = /* @__PURE__ */ new Set();
+	#stopStream;
+	/** Plain calls, action runs and live sources (WP-08), over the same transport and view. */
+	server;
+	constructor(options) {
+		this.#options = options;
+		this.server = new ServerClient({
+			...options.mode === "live" && options.transport ? { transport: options.transport } : {},
+			...options.mode === "live" && options.view ? { viewId: options.view.viewId } : {},
+			...options.timers ? { timers: options.timers } : {}
+		});
+		this.mode = options.mode;
+		this.view = options.view;
+		this.#viewer = options.viewer;
+		this.#timers = options.timers ?? {
+			setTimeout: (fn, ms) => setTimeout(fn, ms),
+			clearTimeout: (handle) => clearTimeout(handle)
+		};
+		if (options.view?.policy.policy === "none") this.#submitState = "closed";
+	}
+	/** Calls `listener` after every change; returns the function that stops. */
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	};
+	/** A number that changes with every change, for `useSyncExternalStore`. */
+	version = () => this.#version;
+	/** A number that changes whenever the field's value or meta may have. */
+	keyVersion(key) {
+		return this.#keyVersions.get(key) ?? 0;
+	}
+	#changed(keys = []) {
+		this.#version += 1;
+		for (const key of keys) this.#keyVersions.set(key, (this.#keyVersions.get(key) ?? 0) + 1);
+		for (const listener of [...this.#listeners]) listener();
+	}
+	/** Whether the first snapshot arrived (or, in local mode, at once). */
+	get ready() {
+		return this.#ready;
+	}
+	/** Resolves once the store is ready, or after `timeoutMs`. */
+	whenReady(timeoutMs = Number.POSITIVE_INFINITY) {
+		if (this.#ready) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.#readyWaiters.push(resolve);
+			if (Number.isFinite(timeoutMs)) this.#timers.setTimeout(resolve, timeoutMs);
+		});
+	}
+	#markReady() {
+		if (this.#ready) return;
+		this.#ready = true;
+		for (const resolve of this.#readyWaiters.splice(0)) resolve();
+		this.#changed(this.#allKeys());
+	}
+	#allKeys() {
+		return [.../* @__PURE__ */ new Set([...this.#server.keys(), ...this.#registrations.keys()])];
+	}
+	/** Starts: subscribes to the event stream (live) or reads this browser's values (local). */
+	start() {
+		if (this.mode === "local") {
+			this.#markReady();
+			return;
+		}
+		const transport = this.#transport();
+		this.#stopStream = transport.subscribe(void 0, {
+			onSnapshot: (snapshot) => this.#applySnapshot(snapshot),
+			onEvents: (events) => this.#applyEvents(events),
+			onStatus: (status) => {
+				if (status === "revoked") this.#revoked = true;
+				const online = status === "live";
+				if (online !== this.#online) {
+					this.#online = online;
+					if (online) {
+						this.#kickQueue();
+						this.server.resync();
+					}
+					this.#changed(this.#allKeys());
+				}
+			},
+			onEphemeral: (message) => this.server.receive(message)
+		});
+		if (typeof window !== "undefined") window.addEventListener("online", () => this.#kickQueue());
+	}
+	/** Stops the stream and timers (the page is going away, or a test ends). */
+	stop() {
+		this.#stopStream?.();
+		this.server.stop();
+		this.#broadcast?.close();
+		if (this.#debounce !== void 0) this.#timers.clearTimeout(this.#debounce);
+		if (this.#retry !== void 0) this.#timers.clearTimeout(this.#retry);
+	}
+	#transport() {
+		const transport = this.#options.transport;
+		if (!transport) throw targetUnavailable("Saving");
+		return transport;
+	}
+	#applySnapshot(snapshot) {
+		this.#gatewayHeard();
+		const first = !this.#loaded;
+		this.#loaded = true;
+		this.#viewer = snapshot.viewer;
+		const touched = new Set(this.#allKeys());
+		const load = (scope, document) => {
+			const revision = Number(document.revision);
+			const replace = first || revision >= this.#seen[scope];
+			if (replace) {
+				for (const key of [...this.#server.keys()]) if (keyParts(key).scope === scope) this.#server.delete(key);
+				for (const key of [...this.#unknown]) if (keyParts(key).scope === scope) this.#unknown.delete(key);
+				this.#seen[scope] = revision;
+			}
+			for (const [id, field] of Object.entries(document.fields)) {
+				const key = fieldKey(scope, id);
+				const current = this.#server.get(key);
+				if (!replace && current && current.revision >= Number(field.revision)) continue;
+				touched.add(key);
+				this.#unknown.delete(key);
+				this.#server.set(key, {
+					value: field.value,
+					revision: Number(field.revision),
+					deleted: false,
+					...field.updatedBy ? { updatedBy: field.updatedBy } : {}
+				});
+			}
+			return replace;
+		};
+		if (load("viewer", snapshot.draft)) this.#epoch = snapshot.draft.epoch;
+		load("artifact", snapshot.state);
+		if (snapshot.submission) this.#adoptSubmission(snapshot.submission, true);
+		this.#resolveCatchUp();
+		this.#changed(touched);
+		if (first) {
+			this.#openChannel();
+			this.#recoverJournal().finally(() => {
+				this.#markReady();
+				if (this.#pending.size > 0) this.#schedule();
+			});
+		}
+	}
+	#applyEvents(events) {
+		this.#gatewayHeard();
+		const touched = /* @__PURE__ */ new Set();
+		let resync = false;
+		for (const event of events) {
+			const ownMutation = event.causation?.["mutationId"] !== void 0 && (this.#inflight.has(event.causation["mutationId"]) || [...this.#sending.values()].some((s) => s.mutationId === event.causation?.["mutationId"]));
+			if (event.type === "draft.changed" || event.type === "state.changed") {
+				const scope = event.type === "draft.changed" ? "viewer" : "artifact";
+				const payload = event.payload;
+				const revision = Number(payload.revision);
+				if (scope === "viewer" && payload.epoch !== void 0 && payload.epoch > this.#epoch) this.#epoch = payload.epoch;
+				for (const change of payload.changes) {
+					const key = fieldKey(scope, change.id);
+					touched.add(key);
+					const current = this.#server.get(key);
+					if (current && current.revision >= revision) continue;
+					if (change.sensitive && !change.deleted) {
+						const mine = this.#sending.get(key);
+						if (ownMutation && mine) this.#server.set(key, {
+							value: mine.value,
+							revision,
+							deleted: false,
+							updatedBy: event.actor
+						});
+						else {
+							this.#unknown.add(key);
+							resync = true;
+						}
+						continue;
+					}
+					this.#unknown.delete(key);
+					this.#server.set(key, {
+						value: change.deleted ? void 0 : change.value,
+						revision,
+						deleted: change.deleted === true,
+						updatedBy: event.actor
+					});
+				}
+				this.#seen[scope] = Math.max(this.#seen[scope], revision);
+			} else if (event.type === "submission.created") {
+				const payload = event.payload;
+				const own = payload.viewerId !== void 0 && payload.viewerId === this.#viewer?.id;
+				if (own && this.#submission?.id !== payload.submissionId) resync = true;
+				else if (!own && this.view?.policy.policy === "once") {
+					if (this.view.policy.scope !== "per-viewer") {
+						this.#closed = true;
+						this.#submitState = "closed";
+						for (const key of this.#allKeys()) touched.add(key);
+					}
+				}
+			} else if (event.type.startsWith("submission.")) this.#deliveryEvent(event);
+		}
+		this.#resolveCatchUp();
+		if (resync) this.#resync();
+		if (touched.size > 0) this.#changed(touched);
+	}
+	/** Loads a fresh snapshot, once at a time; a failure leaves it to the next event or submit. */
+	#resync() {
+		this.#resyncing ??= (async () => {
+			try {
+				this.#applySnapshot(await this.#transport().snapshot());
+			} catch {} finally {
+				this.#resyncing = void 0;
+			}
+		})();
+		return this.#resyncing;
+	}
+	/** Whether the gateway holds a value for the field (deleted fields don't count). */
+	stored(key) {
+		const server = this.#server.get(key);
+		return server !== void 0 && !server.deleted;
+	}
+	/** The field's value as the viewer sees it: their edit, else the gateway's, else `fallback`. */
+	value(key, fallback) {
+		if (this.mode === "local") {
+			const stored = this.#localRead(key);
+			const pending = this.#pending.get(key);
+			if (pending) return pending.op.delete ? fallback : pending.op.value;
+			return stored === void 0 ? fallback : stored;
+		}
+		const pending = this.#pending.get(key);
+		if (pending) return pending.op.delete ? fallback : pending.op.value;
+		const sending = this.#sending.get(key);
+		if (sending) return sending.value === void 0 ? fallback : sending.value;
+		const server = this.#server.get(key);
+		if (server && !server.deleted) return server.value;
+		return fallback;
+	}
+	/** The field's open conflict, if any. */
+	conflict(key) {
+		return this.#conflicts.get(key);
+	}
+	/** Who last wrote the field (artifact state, D63). */
+	updatedBy(key) {
+		return this.#server.get(key)?.updatedBy;
+	}
+	/** Why the gateway refused the field's edit for good, if it did: its code and message. */
+	refusal(key) {
+		return this.#refused.get(key);
+	}
+	/** Whether the field takes edits: not a closed draft, not a view-only link. */
+	writable(key) {
+		if (this.mode === "local") return true;
+		const { scope } = keyParts(key);
+		if (!this.#canSave()) return false;
+		return scope === "artifact" || !this.#closed;
+	}
+	/** Whether the link may submit (D97): its `submit` scope. */
+	canSubmit() {
+		return this.#options.scopes === void 0 || this.#options.scopes.includes("submit");
+	}
+	#canSave() {
+		return this.#options.scopes === void 0 || this.#options.scopes.includes("draft");
+	}
+	/** The field's save state (INTERFACES §2.3). */
+	save(key) {
+		if (this.mode === "local") return "readonly";
+		if (this.#conflicts.has(key)) return "conflict";
+		if (!this.writable(key)) return "readonly";
+		if (this.#refused.has(key)) return "offline";
+		if (!(this.#pending.has(key) || this.#sending.has(key))) return "saved";
+		return this.#online && !this.#revoked ? "saving" : "offline";
+	}
+	/** The page's save state, for the shell's rail. */
+	pageSave() {
+		if (this.mode === "local") return "saved";
+		if (this.#conflicts.size > 0) return "conflict";
+		if (!(this.#pending.size > 0 || this.#inflight.size > 0 || this.#queue.length > 0) && this.#refused.size === 0) return "saved";
+		return this.#online && !this.#revoked && this.#refused.size === 0 ? "saving" : "offline";
+	}
+	/** Whether edits wait to be saved. */
+	unsaved() {
+		return this.#pending.size > 0 || this.#inflight.size > 0 || this.#queue.length > 0 || this.#refused.size > 0;
+	}
+	/** The viewer the page acts as, once known. */
+	viewer() {
+		return this.#viewer;
+	}
+	/** Every field ID of a scope the viewer sees, with its value (for `window.storage.list`). */
+	ids(scope) {
+		const ids = /* @__PURE__ */ new Set();
+		if (this.mode === "local") for (const id of this.#localIds(scope)) ids.add(id);
+		for (const [key, server] of this.#server) if (!server.deleted && key.startsWith(`${scope}:`)) ids.add(keyParts(key).id);
+		for (const key of [...this.#pending.keys(), ...this.#sending.keys()]) if (key.startsWith(`${scope}:`)) ids.add(keyParts(key).id);
+		return [...ids].filter((id) => this.value(fieldKey(scope, id), void 0) !== void 0).sort();
+	}
+	/** Registers a mounted field; returns the function that unregisters it. */
+	register(registration) {
+		const key = fieldKey(registration.scope, registration.id);
+		const existing = this.#registrations.get(key);
+		if (existing) {
+			existing.count += 1;
+			existing.registration = {
+				...registration,
+				initial: existing.registration.initial
+			};
+		} else this.#registrations.set(key, {
+			registration,
+			count: 1
+		});
+		for (const observer of this.#mountObservers) observer(registration, true);
+		this.#changed([key]);
+		let released = false;
+		return () => {
+			const entry = this.#registrations.get(key);
+			if (!entry) return;
+			if (!released) {
+				released = true;
+				for (const observer of this.#mountObservers) observer(registration, false);
+			}
+			entry.count -= 1;
+			if (entry.count <= 0) this.#registrations.delete(key);
+			this.#changed([key]);
+		};
+	}
+	/**
+	* Hears every field mount and unmount, with the registration as the hook gave it; returns the
+	* function that stops. `verify`'s field probe uses it (D138). @internal
+	*/
+	observeMounts(observer) {
+		this.#mountObservers.add(observer);
+		return () => this.#mountObservers.delete(observer);
+	}
+	/**
+	* Tells the mount observers about a field a hook reads and writes without registering it
+	* (`useChoice`'s choice field): `verify`'s field probe hears it, and nothing else changes, so
+	* no default is written for it (D110). Returns the function that announces its unmount.
+	*/
+	announceMount(registration) {
+		if (this.#mountObservers.size === 0) return () => void 0;
+		for (const observer of this.#mountObservers) observer(registration, true);
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			for (const observer of this.#mountObservers) observer(registration, false);
+		};
+	}
+	/** Updates a mounted field's options or validation message. */
+	updateRegistration(registration) {
+		const key = fieldKey(registration.scope, registration.id);
+		const entry = this.#registrations.get(key);
+		if (!entry) return;
+		const next = {
+			...registration,
+			initial: entry.registration.initial
+		};
+		if (entry.registration.label === next.label && entry.registration.required === next.required && entry.registration.sensitive === next.sensitive && entry.registration.error === next.error) return;
+		entry.registration = next;
+		this.#changed([key]);
+	}
+	/** Every mounted field. */
+	registrations() {
+		return [...this.#registrations.values()].map((entry) => entry.registration);
+	}
+	/** What blocks a submit now (INTERFACES §2.3): required, invalid and conflicting fields. */
+	blockers() {
+		const blockers = [];
+		for (const [key, { registration }] of this.#registrations) {
+			const label = registration.label !== void 0 ? { label: registration.label } : {};
+			if (this.#conflicts.has(key)) blockers.push({
+				fieldId: registration.id,
+				...label,
+				reason: "conflict"
+			});
+			else if (registration.error !== void 0) blockers.push({
+				fieldId: registration.id,
+				...label,
+				reason: "invalid"
+			});
+			else if (registration.required && isEmpty(this.value(key, registration.initial))) blockers.push({
+				fieldId: registration.id,
+				...label,
+				reason: "required"
+			});
+		}
+		return blockers.sort((a, b) => a.fieldId < b.fieldId ? -1 : a.fieldId > b.fieldId ? 1 : 0);
+	}
+	/**
+	* Sets a field: shown at once, journaled at once, sent after the debounce (`immediate` sends
+	* now). Refused with `MOSTRA_FIELD_ID_INVALID` for an ID that isn't one; a closed draft or a
+	* view-only link refuses with `MOSTRA_SUBMIT_ALREADY` or `MOSTRA_HYGIENE_SCOPE_DENIED`.
+	*/
+	set(scope, id, value, options = {}) {
+		if (!isFieldId(id)) throw new MostraError("MOSTRA_FIELD_ID_INVALID", `${JSON.stringify(id)} isn't a field ID.`);
+		const key = fieldKey(scope, id);
+		if (!this.writable(key)) throw this.#closed && scope === "viewer" ? new MostraError("MOSTRA_SUBMIT_ALREADY", "This draft was submitted and takes no edits.") : new MostraError("MOSTRA_HYGIENE_SCOPE_DENIED", "This link can't save answers.");
+		if (value !== void 0) try {
+			JSON.stringify(value);
+		} catch {
+			throw new MostraError("MOSTRA_HOST_INVALID_PARAMS", `The value of ${id} isn't JSON.`);
+		}
+		const earlierOp = this.#pending.get(fieldKey(scope, id))?.op;
+		const registered = this.#registrations.get(fieldKey(scope, id))?.registration;
+		const label = options.label ?? earlierOp?.label ?? registered?.label;
+		const required = options.required ?? earlierOp?.required ?? registered?.required;
+		const sensitive = options.sensitive ?? earlierOp?.sensitive ?? registered?.sensitive;
+		const op = {
+			id,
+			...options.delete || value === void 0 ? { delete: true } : { value },
+			...label !== void 0 ? { label } : {},
+			...required !== void 0 ? { required } : {},
+			...sensitive !== void 0 ? { sensitive } : {}
+		};
+		if (this.mode === "local") {
+			this.#localWrite(key, op.delete ? void 0 : op.value);
+			this.#changed([key]);
+			return;
+		}
+		const earlier = this.#pending.get(key);
+		const entry = {
+			kind: "pending",
+			viewerId: this.#viewer?.id ?? "",
+			tab: this.#options.tab,
+			viewId: this.view?.viewId ?? "",
+			scope,
+			op,
+			base: earlier ? earlier.base : this.#baseFor(key),
+			at: Date.now()
+		};
+		this.#refused.delete(key);
+		this.#pending.set(key, entry);
+		if (entry.viewerId !== "") this.#options.journal.putPending(entry).catch(() => void 0);
+		this.#changed([key]);
+		if (options.immediate) this.flush();
+		else this.#schedule();
+	}
+	/** The base of a new edit: what the page has seen of the field (null while it is in flight). */
+	#baseFor(key) {
+		if (this.#sending.has(key)) return null;
+		if (this.#unknown.has(key)) return this.#server.get(key)?.revision ?? 0;
+		const { scope } = keyParts(key);
+		return Math.max(this.#server.get(key)?.revision ?? 0, this.#seen[scope]);
+	}
+	#schedule() {
+		if (this.#debounce !== void 0) this.#timers.clearTimeout(this.#debounce);
+		this.#debounce = this.#timers.setTimeout(() => {
+			this.#debounce = void 0;
+			this.flush();
+		}, 400);
+	}
+	/** Keeps the viewer's value of a conflicting field: written over theirs (FAILURE_MODEL §5). */
+	keepMine(key) {
+		const conflict = this.#conflicts.get(key);
+		const pending = this.#pending.get(key);
+		if (!conflict || !pending) return;
+		this.#conflicts.delete(key);
+		const entry = {
+			...pending,
+			base: conflict.revision,
+			at: Date.now()
+		};
+		this.#pending.set(key, entry);
+		this.#options.journal.putPending(entry).catch(() => void 0);
+		this.#changed([key]);
+		this.flush();
+	}
+	/** Takes the other writer's value of a conflicting field and drops the viewer's. */
+	takeTheirs(key) {
+		const pending = this.#pending.get(key);
+		this.#conflicts.delete(key);
+		this.#refused.delete(key);
+		this.#pending.delete(key);
+		if (pending) this.#options.journal.dropPending(pending).catch(() => void 0);
+		this.#changed([key]);
+	}
+	/**
+	* Sends every edit now and waits for the answers. `keepalive` is for `pagehide`: the requests
+	* outlive the page, and the journal keeps whatever they don't deliver (IN-02).
+	*/
+	async flush(options = {}) {
+		if (this.mode === "local" || this.#viewer === void 0 || !this.#loaded) return {
+			revision: this.#seen.viewer,
+			unsaved: this.unsaved()
+		};
+		if (this.#debounce !== void 0) {
+			this.#timers.clearTimeout(this.#debounce);
+			this.#debounce = void 0;
+		}
+		const ready = [...this.#pending.entries()].filter(([key, entry]) => entry.base !== null && !this.#conflicts.has(key) && !this.#refused.has(key));
+		const groups = /* @__PURE__ */ new Map();
+		for (const [, entry] of ready) {
+			const group = `${entry.scope}\u0000${entry.base}\u0000${entry.viewId}`;
+			const list = groups.get(group) ?? [];
+			list.push(entry);
+			groups.set(group, list);
+		}
+		const created = [];
+		for (const entries of groups.values()) for (let start = 0; start < entries.length; start += OPS_PER_MUTATION) {
+			const chunk = entries.slice(start, start + OPS_PER_MUTATION);
+			const first = chunk[0];
+			const mutation = {
+				kind: "mutation",
+				viewerId: this.#viewer.id,
+				tab: this.#options.tab,
+				viewId: first.viewId !== "" ? first.viewId : this.view?.viewId ?? "",
+				scope: first.scope,
+				mutationId: MutationId.create(),
+				baseRevision: first.base,
+				ops: chunk.map((entry) => entry.op),
+				seq: Date.now() * 1e3 + this.#seq++ % 1e3
+			};
+			for (const entry of chunk) {
+				const key = fieldKey(entry.scope, entry.op.id);
+				this.#pending.delete(key);
+				this.#sending.set(key, {
+					value: entry.op.delete ? void 0 : entry.op.value,
+					mutationId: mutation.mutationId
+				});
+			}
+			this.#options.journal.promote(mutation, chunk).catch(() => void 0);
+			created.push(mutation);
+			this.#queue.push(mutation);
+		}
+		if (created.length > 0) this.#changed(created.flatMap((m) => m.ops.map((op) => fieldKey(m.scope, op.id))));
+		await this.#drain(options.keepalive === true);
+		return {
+			revision: this.#ownRevision(),
+			unsaved: this.unsaved()
+		};
+	}
+	/** The draft revision the page's own saves reached. */
+	#ownRevision() {
+		let revision = this.#seen.viewer;
+		for (const [key, server] of this.#server) if (key.startsWith("viewer:")) revision = Math.max(revision, server.revision);
+		return revision;
+	}
+	/** Sends queued mutations one at a time, in order, until the queue is empty or the page is offline. */
+	async #drain(keepalive) {
+		if (keepalive) {
+			for (const mutation of [...this.#queue]) this.#send(mutation, true).then((outcome) => {
+				if (outcome === "done") this.#dequeue(mutation);
+			}).catch(() => void 0);
+			return;
+		}
+		if (this.#sendingQueue) {
+			await new Promise((resolve) => {
+				const check = () => {
+					if (!this.#sendingQueue) resolve();
+					else this.#timers.setTimeout(check, 20);
+				};
+				check();
+			});
+			if (this.#queue.length === 0) return;
+		}
+		this.#sendingQueue = true;
+		try {
+			while (this.#queue.length > 0 && !this.#revoked) {
+				const head = this.#queue[0];
+				if (await this.#send(head, false) === "retry") {
+					this.#scheduleRetry();
+					return;
+				}
+				this.#dequeue(head);
+			}
+			this.#retryMs = 1e3;
+		} finally {
+			this.#sendingQueue = false;
+		}
+	}
+	/** Removes an answered mutation from the queue; the page's save state changes only now. */
+	#dequeue(mutation) {
+		const index = this.#queue.indexOf(mutation);
+		if (index === -1) return;
+		this.#queue.splice(index, 1);
+		this.#changed(mutation.ops.map((op) => fieldKey(mutation.scope, op.id)));
+	}
+	/**
+	* The event stream just brought something, so the gateway is reachable: saves waiting out a
+	* backoff after a network failure try again soon instead of after up to 30 s (FAILURE_MODEL
+	* §5, "on reconnect the journal replays"). The backoff itself isn't reset, so a path that keeps
+	* failing while the stream works (a proxy refusing POSTs) is tried at most once per message.
+	*/
+	#gatewayHeard() {
+		if (this.#retry === void 0) return;
+		this.#timers.clearTimeout(this.#retry);
+		this.#retry = this.#timers.setTimeout(() => {
+			this.#retry = void 0;
+			this.#drain(false);
+		}, RETRY_SOON_MS);
+	}
+	#scheduleRetry() {
+		if (this.#retry !== void 0) return;
+		this.#retry = this.#timers.setTimeout(() => {
+			this.#retry = void 0;
+			this.#drain(false);
+		}, this.#retryMs);
+		this.#retryMs = Math.min(this.#retryMs * 2, 3e4);
+	}
+	#kickQueue() {
+		if (this.#retry !== void 0) {
+			this.#timers.clearTimeout(this.#retry);
+			this.#retry = void 0;
+		}
+		this.#retryMs = 1e3;
+		this.flush();
+	}
+	/** Sends one mutation; `retry` when the network failed and it stays queued. */
+	async #send(mutation, keepalive) {
+		this.#inflight.set(mutation.mutationId, mutation);
+		let result;
+		try {
+			result = await this.#transport().mutate({
+				mutationId: mutation.mutationId,
+				scope: mutation.scope,
+				baseRevision: String(mutation.baseRevision),
+				viewId: mutation.viewId,
+				ops: mutation.ops
+			}, { keepalive });
+		} catch (error) {
+			if (error instanceof NetworkError) {
+				this.#online = false;
+				this.#changed(mutation.ops.map((op) => fieldKey(mutation.scope, op.id)));
+				return "retry";
+			}
+			return this.#refusedMutation(mutation, error);
+		} finally {
+			this.#inflight.delete(mutation.mutationId);
+		}
+		if (!this.#online) this.#online = true;
+		this.#answered(mutation, result);
+		return "done";
+	}
+	/** A mutation the gateway answered. */
+	#answered(mutation, result) {
+		const revision = Number(result.revision);
+		const touched = [];
+		const conflicts = new Map(result.conflicts.map((conflict) => [conflict.id, conflict]));
+		const applied = [];
+		for (const op of mutation.ops) {
+			const key = fieldKey(mutation.scope, op.id);
+			touched.push(key);
+			const sending = this.#sending.get(key);
+			const mine = op.delete ? void 0 : op.value;
+			if (sending?.mutationId === mutation.mutationId) this.#sending.delete(key);
+			const conflict = conflicts.get(op.id);
+			if (conflict) {
+				this.#conflicted(key, op, conflict, mutation);
+				continue;
+			}
+			if (result.applied.includes(op.id)) {
+				const current = this.#server.get(key);
+				if (!current || current.revision < revision) this.#server.set(key, {
+					value: mine,
+					revision,
+					deleted: op.delete === true,
+					updatedBy: {
+						kind: "viewer",
+						...this.#viewer ? { id: this.#viewer.id } : {}
+					}
+				});
+				applied.push({
+					id: op.id,
+					value: mine
+				});
+				const later = this.#pending.get(key);
+				if (later && later.base === null) {
+					const based = {
+						...later,
+						base: revision
+					};
+					this.#pending.set(key, based);
+					this.#options.journal.putPending(based).catch(() => void 0);
+				}
+			}
+		}
+		this.#options.journal.remove(mutation.mutationId).catch(() => void 0);
+		if (applied.length > 0) this.#broadcast?.postMessage({
+			kind: "applied",
+			scope: mutation.scope,
+			revision,
+			changes: applied
+		});
+		this.#resolveCatchUp();
+		this.#changed(touched);
+		if ([...this.#pending.values()].some((entry) => entry.base !== null)) this.#schedule();
+	}
+	#conflicted(key, op, conflict, mutation) {
+		const theirs = conflict.deleted ? void 0 : conflict.value;
+		const mine = op.delete ? void 0 : op.value;
+		this.#unknown.delete(key);
+		this.#server.set(key, {
+			value: theirs,
+			revision: Number(conflict.revision),
+			deleted: conflict.deleted === true,
+			...conflict.updatedBy ? { updatedBy: conflict.updatedBy } : {}
+		});
+		const later = this.#pending.get(key);
+		if (same(theirs, later ? later.op.delete ? void 0 : later.op.value : mine)) {
+			if (later) {
+				this.#pending.delete(key);
+				this.#options.journal.dropPending(later).catch(() => void 0);
+			}
+			return;
+		}
+		const held = later !== void 0 ? later.base === null ? {
+			...later,
+			base: mutation.baseRevision
+		} : later : {
+			kind: "pending",
+			viewerId: mutation.viewerId,
+			tab: this.#options.tab,
+			viewId: mutation.viewId,
+			scope: mutation.scope,
+			op,
+			base: mutation.baseRevision,
+			at: Date.now()
+		};
+		this.#pending.set(key, held);
+		this.#options.journal.putPending(held).catch(() => void 0);
+		this.#conflicts.set(key, {
+			theirs,
+			deleted: conflict.deleted === true,
+			revision: Number(conflict.revision),
+			...conflict.updatedBy ? { updatedBy: conflict.updatedBy } : {}
+		});
+	}
+	/** A mutation the gateway refused: dropped from the queue, its values handled per refusal. */
+	async #refusedMutation(mutation, error) {
+		const code = error instanceof MostraError ? error.code : "MOSTRA_HOST_INTERNAL_ERROR";
+		const keys = mutation.ops.map((op) => fieldKey(mutation.scope, op.id));
+		const forget = () => {
+			for (const key of keys) if (this.#sending.get(key)?.mutationId === mutation.mutationId) this.#sending.delete(key);
+			this.#options.journal.remove(mutation.mutationId).catch(() => void 0);
+		};
+		switch (code) {
+			case "MOSTRA_HYGIENE_TOKEN_REVOKED":
+				this.#revoked = true;
+				this.#changed(keys);
+				return "retry";
+			case "MOSTRA_SUBMIT_VIEW_INVALID":
+				if (this.view && mutation.viewId !== this.view.viewId) {
+					const moved = {
+						...mutation,
+						viewId: this.view.viewId
+					};
+					this.#queue[0] = moved;
+					this.#options.journal.promote(moved, []).catch(() => void 0);
+					return this.#send(moved, false);
+				}
+				break;
+			case "MOSTRA_SUBMIT_ALREADY":
+				this.#closed = true;
+				forget();
+				this.#changed(this.#allKeys());
+				return "done";
+			case "MOSTRA_HOME_DISK_FULL":
+			case "MOSTRA_HOME_GONE":
+			case "MOSTRA_HOST_INTERNAL_ERROR":
+				this.#online = false;
+				this.#changed(keys);
+				return "retry";
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		for (const op of mutation.ops) {
+			const key = fieldKey(mutation.scope, op.id);
+			if (!this.#pending.has(key)) {
+				const held = {
+					kind: "pending",
+					viewerId: mutation.viewerId,
+					tab: this.#options.tab,
+					viewId: mutation.viewId,
+					scope: mutation.scope,
+					op,
+					base: mutation.baseRevision,
+					at: Date.now()
+				};
+				this.#pending.set(key, held);
+				this.#options.journal.putPending(held).catch(() => void 0);
+			}
+			this.#refused.set(key, {
+				code,
+				message
+			});
+		}
+		forget();
+		this.#changed(keys);
+		return "done";
+	}
+	/**
+	* Replays what earlier pages left: this tab's entries (none on a fresh load) and those of tabs
+	* that are gone, mutations first in their order, then pending edits (IN-02, IN-04).
+	*/
+	#recoverJournal() {
+		return (this.#options.exclusive ?? ((fn) => fn()))(() => this.#adoptJournal()).catch(() => void 0);
+	}
+	async #adoptJournal() {
+		const viewerId = this.#viewer?.id;
+		if (!viewerId) return;
+		let contents;
+		try {
+			contents = await this.#options.journal.load(viewerId);
+		} catch {
+			return;
+		}
+		const tabs = [...new Set([...contents.pending, ...contents.mutations].map((entry) => entry.tab))].filter((tab) => tab !== this.#options.tab);
+		const gone = this.#options.goneTabs ? await this.#options.goneTabs(tabs) : new Set(tabs);
+		const mutations = contents.mutations.filter((entry) => gone.has(entry.tab));
+		const pending = [];
+		const newest = /* @__PURE__ */ new Map();
+		for (const entry of contents.pending.filter((candidate) => gone.has(candidate.tab)).sort((a, b) => a.at - b.at)) {
+			const key = fieldKey(entry.scope, entry.op.id);
+			const earlier = newest.get(key);
+			if (earlier) {
+				const promoted = {
+					kind: "mutation",
+					viewerId: earlier.viewerId,
+					tab: earlier.tab,
+					viewId: earlier.viewId,
+					scope: earlier.scope,
+					mutationId: MutationId.create(),
+					baseRevision: earlier.base ?? this.#server.get(key)?.revision ?? this.#seen[earlier.scope],
+					ops: [earlier.op],
+					seq: earlier.at * 1e3
+				};
+				try {
+					await this.#options.journal.promote(promoted, [earlier]);
+				} catch {
+					return;
+				}
+				mutations.push(promoted);
+				pending.splice(pending.indexOf(earlier), 1);
+			}
+			newest.set(key, entry);
+			pending.push(entry);
+		}
+		const adopted = [...mutations.sort((a, b) => a.seq - b.seq), ...pending];
+		if (adopted.length === 0) return;
+		try {
+			await this.#options.journal.adopt(adopted, this.#options.tab);
+		} catch {
+			return;
+		}
+		const touched = [];
+		for (const entry of adopted) {
+			if (entry.kind !== "mutation") continue;
+			const mutation = {
+				...entry,
+				tab: this.#options.tab
+			};
+			for (const op of mutation.ops) {
+				const key = fieldKey(mutation.scope, op.id);
+				touched.push(key);
+				this.#sending.set(key, {
+					value: op.delete ? void 0 : op.value,
+					mutationId: mutation.mutationId
+				});
+			}
+			this.#queue.push(mutation);
+		}
+		for (const entry of adopted) {
+			if (entry.kind !== "pending") continue;
+			const key = fieldKey(entry.scope, entry.op.id);
+			touched.push(key);
+			if (this.#pending.has(key)) continue;
+			const base = entry.base ?? (this.#sending.has(key) ? null : this.#baseFor(key));
+			this.#pending.set(key, {
+				...entry,
+				tab: this.#options.tab,
+				base
+			});
+		}
+		this.#changed(touched);
+		this.flush();
+	}
+	#openChannel() {
+		const viewerId = this.#viewer?.id;
+		const artifactId = this.view?.artifactId;
+		if (!viewerId || !artifactId || !this.#options.channel) return;
+		this.#broadcast = this.#options.channel(`mostra:${artifactId}:${viewerId}`);
+		if (!this.#broadcast) return;
+		this.#broadcast.onmessage = (event) => {
+			const data = event.data;
+			if (data.kind !== "applied" || !data.scope || typeof data.revision !== "number") return;
+			const touched = [];
+			for (const change of data.changes ?? []) {
+				const key = fieldKey(data.scope, change.id);
+				const current = this.#server.get(key);
+				if (current && current.revision >= data.revision) continue;
+				this.#server.set(key, {
+					value: change.value,
+					revision: data.revision,
+					deleted: change.value === void 0,
+					...current?.updatedBy ? { updatedBy: current.updatedBy } : {}
+				});
+				touched.push(key);
+			}
+			if (touched.length > 0) this.#changed(touched);
+		};
+	}
+	/** The submission state (INTERFACES §2.3). */
+	submitState() {
+		return this.#submitState;
+	}
+	/** The viewer's submission, once made or known. */
+	submission() {
+		return this.#submission;
+	}
+	/** Whether a submission closed the viewer's draft. */
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* Gets the draft ready for a submit (D110, IN-02): writes the initial values of mounted viewer
+	* fields the gateway never stored, saves everything, waits until the event stream reached the
+	* page's own last save, and reports what still blocks.
+	*/
+	/**
+	* Adds a check that runs before every submit, either channel's: an adapter whose library
+	* validates on its own schedule (react-hook-form validates on submit by default) runs its
+	* validation here and updates its registrations, so the blockers are current. Returns the
+	* function that removes it.
+	*/
+	beforeSubmit(check) {
+		this.#beforeSubmit.add(check);
+		return () => this.#beforeSubmit.delete(check);
+	}
+	async prepareSubmit() {
+		if (this.mode === "local") throw targetUnavailable("Submitting");
+		await this.whenReady(CATCH_UP_MS);
+		await Promise.allSettled([...this.#beforeSubmit].map((check) => check()));
+		for (const [key, { registration }] of this.#registrations) {
+			if (registration.scope !== "viewer" || !this.writable(key)) continue;
+			if (this.stored(key) || this.#pending.has(key) || this.#sending.has(key)) continue;
+			if (registration.initial === void 0) continue;
+			this.set("viewer", registration.id, registration.initial, {
+				...registration.label !== void 0 ? { label: registration.label } : {},
+				...registration.required !== void 0 ? { required: registration.required } : {},
+				...registration.sensitive !== void 0 ? { sensitive: registration.sensitive } : {}
+			});
+		}
+		const flushed = await this.flush();
+		await this.#caughtUp(flushed.revision);
+		if (this.#unknown.size > 0) await this.#resync();
+		if (this.#seen.viewer < flushed.revision) {
+			this.#resync();
+			return {
+				revision: this.#seen.viewer,
+				unsaved: this.unsaved(),
+				blockers: this.blockers()
+			};
+		}
+		return {
+			revision: Math.max(this.#seen.viewer, flushed.revision),
+			unsaved: this.unsaved() || this.#unknown.size > 0,
+			blockers: this.blockers()
+		};
+	}
+	/** Waits until the event stream reached `revision` of the draft, or a while. */
+	#caughtUp(revision) {
+		if (this.#seen.viewer >= revision) return Promise.resolve();
+		return new Promise((resolve) => {
+			const check = () => {
+				if (this.#seen.viewer >= revision) resolve();
+				else this.#catchUp.push(check);
+			};
+			this.#catchUp.push(check);
+			this.#timers.setTimeout(resolve, CATCH_UP_MS);
+		});
+	}
+	#resolveCatchUp() {
+		for (const check of this.#catchUp.splice(0)) check();
+	}
+	/**
+	* Submits through the artifact channel (D40), where the view allows it: prepares the draft,
+	* refuses with `MOSTRA_SUBMIT_BLOCKED` while a field blocks, and submits the revision the
+	* viewer saw.
+	*/
+	async submit() {
+		if (this.mode === "local") throw targetUnavailable("Submitting");
+		const view = this.view;
+		if (view && !view.submitChannels.includes("artifact")) throw new MostraError("MOSTRA_SUBMIT_CHANNEL_DENIED", "This host takes submissions from the shell's trusted Submit only.");
+		if (view?.policy.policy === "none") throw new MostraError("MOSTRA_SUBMIT_POLICY_NONE", "This artifact's submission policy is none: it takes no submissions.");
+		if (!this.canSubmit()) throw new MostraError("MOSTRA_HYGIENE_SCOPE_DENIED", "This link doesn't carry the submit scope.");
+		const previous = this.#submitState;
+		this.#submitState = "submitting";
+		this.#changed();
+		try {
+			const prepared = await this.prepareSubmit();
+			if (prepared.blockers.length > 0) throw new MostraError("MOSTRA_SUBMIT_BLOCKED", `Not submitted: ${prepared.blockers.map((b) => b.label ?? b.fieldId).join(", ")} ${prepared.blockers.length === 1 ? "needs" : "need"} attention.`, { body: { blockers: prepared.blockers } });
+			if (prepared.unsaved) throw new MostraError("MOSTRA_SUBMIT_BLOCKED", "Not submitted: some answers aren't saved yet. Try again when the page is back online.", { body: { blockers: [] } });
+			const submission = await this.#transport().submit({
+				viewId: view?.viewId ?? "",
+				expectedRevision: String(prepared.revision),
+				channel: "artifact"
+			});
+			this.#adoptSubmission(submission, false);
+			this.#changed(this.#allKeys());
+			return submission;
+		} catch (error) {
+			if (error instanceof MostraError && error.code === "MOSTRA_SUBMIT_ALREADY") {
+				const existing = error.body?.["submission"];
+				if (existing) this.#adoptSubmission(existing, false);
+				else this.#submitState = "closed";
+			} else {
+				this.#submitState = previous === "submitting" ? "open" : previous;
+				if (error instanceof MostraError && error.code === "MOSTRA_SUBMIT_REVISION_MOVED") await this.#resync();
+			}
+			this.#changed();
+			throw error;
+		}
+	}
+	/** Raises a signal for the host's attention (IN-09). */
+	async signal(name, payload) {
+		if (this.mode === "local") throw targetUnavailable("Sending a signal");
+		if (!SIGNAL_NAME_PATTERN.test(name) || name === "submit") throw new MostraError("MOSTRA_SUBMIT_SIGNAL_INVALID", `${JSON.stringify(name)} isn't a signal name: use letters, digits, ".", "_" and "-"; "submit" is the shell's.`);
+		await this.#transport().signal({
+			viewId: this.view?.viewId ?? "",
+			name,
+			...payload !== void 0 ? { payload } : {}
+		});
+	}
+	/** Takes a submission the page made, or learned of, as the viewer's. */
+	adoptSubmission(submission) {
+		this.#adoptSubmission(submission, false);
+		this.#changed();
+	}
+	#adoptSubmission(incoming, fromSnapshot) {
+		const submission = mergedSubmission(this.#submission, incoming);
+		this.#submission = submission;
+		const early = this.#earlyDeliveries.filter((event) => event.payload.submissionId === submission.id);
+		this.#earlyDeliveries = this.#earlyDeliveries.filter((event) => !early.includes(event));
+		const policy = this.view?.policy;
+		if (policy?.policy !== "epochs" || submission.epoch === this.#epoch) {
+			if (policy?.policy === "once" || policy === void 0) this.#closed = true;
+		}
+		if (policy?.policy === "epochs" && fromSnapshot && submission.epoch < this.#epoch) {
+			this.#submitState = "open";
+			return;
+		}
+		this.#submitState = deliveryState(submission);
+		for (const event of early) this.#deliveryEvent(event);
+	}
+	#deliveryEvent(event) {
+		const submission = this.#submission;
+		const payload = event.payload;
+		if (!submission || payload.submissionId !== submission.id) {
+			this.#earlyDeliveries = [...this.#earlyDeliveries, event].slice(-64);
+			return;
+		}
+		const kind = event.type.slice(11);
+		const state = kind === "delivered" ? "delivered" : kind === "rejected" ? "rejected" : kind === "undeliverable" ? "undeliverable" : "pending";
+		const deliveries = (submission.deliveries ?? []).map((delivery) => delivery.deliveryId === payload.deliveryId ? {
+			...delivery,
+			state,
+			...kind === "retrying" ? { waiting: true } : {},
+			...payload.reason !== void 0 && kind !== "retrying" ? { reason: payload.reason } : {},
+			updatedAt: event.at
+		} : delivery);
+		this.#submission = {
+			...submission,
+			deliveries,
+			delivery: worst(deliveries)
+		};
+		this.#submitState = deliveryState(this.#submission);
+		this.#changed();
+	}
+	#localStorage() {
+		if (this.#options.local) return this.#options.local;
+		try {
+			return typeof localStorage === "undefined" ? void 0 : localStorage;
+		} catch {
+			return;
+		}
+	}
+	#localRead(key) {
+		const text = this.#localStorage()?.getItem(`mostra.field.${key}`);
+		if (text === null || text === void 0) return void 0;
+		try {
+			return JSON.parse(text);
+		} catch {
+			return;
+		}
+	}
+	#localWrite(key, value) {
+		const storage = this.#localStorage();
+		try {
+			if (value === void 0) storage?.removeItem(`mostra.field.${key}`);
+			else storage?.setItem(`mostra.field.${key}`, JSON.stringify(value));
+		} catch {
+			this.#pending.set(key, {
+				kind: "pending",
+				viewerId: "",
+				tab: this.#options.tab,
+				viewId: "",
+				scope: keyParts(key).scope,
+				op: value === void 0 ? {
+					id: keyParts(key).id,
+					delete: true
+				} : {
+					id: keyParts(key).id,
+					value
+				},
+				base: 0,
+				at: Date.now()
+			});
+		}
+	}
+	#localIds(scope) {
+		const storage = this.#localStorage();
+		if (!storage || typeof storage.length !== "number") return [];
+		const prefix = `mostra.field.${scope}:`;
+		const ids = [];
+		for (let index = 0; index < storage.length; index += 1) {
+			const name = storage.key(index);
+			if (name?.startsWith(prefix)) ids.push(name.slice(prefix.length));
+		}
+		return ids;
+	}
+};
+const SEVERITY = {
+	delivered: 0,
+	pending: 1,
+	rejected: 2,
+	undeliverable: 3
+};
+function worst(deliveries) {
+	let result = "delivered";
+	for (const delivery of deliveries) if (SEVERITY[delivery.state] > SEVERITY[result]) result = delivery.state;
+	return result;
+}
+/** The submission's state as the viewer sees it (IN-13, D47). */
+function deliveryState(submission) {
+	const deliveries = submission.deliveries ?? [];
+	if (submission.delivery === "undeliverable" || submission.delivery === "rejected") return "undeliverable";
+	if (submission.delivery === "delivered") return "delivered";
+	return deliveries.some((delivery) => delivery.state === "pending" && delivery.waiting) ? "pending-delivery" : "submitted";
+}
+//#endregion
+//#region src/shell-bridge.ts
+/**
+* The artifact's end of the shell bridge (INTERFACES §5, SH-04). The client runtime starts it:
+* when the page runs inside Mostra's shell, it learns the shell's exact origin and its link's
+* scopes from its own session (`GET /_mostra/session`, readable only by this origin), introduces
+* itself with MCP Apps' `ui/initialize`, whose answer names the view this frame load is (D104),
+* and reports `mostra/ready` once the page has rendered. Messages from any other window or origin
+* are dropped. Outside a shell (a static export, the page opened on its own) it does nothing.
+*/
+/**
+* The version this page's build belongs to: its `<meta name="mostra-version">`, which Mostra's
+* builder writes (WP-07). `undefined` for a build that has none. @internal
+*/
+function builtVersion() {
+	if (typeof document === "undefined") return void 0;
+	const content = document.querySelector("meta[name=\"mostra-version\"]")?.getAttribute("content");
+	return content ? content : void 0;
+}
+/** `ui/initialize`'s `mostra` params: the page's version, when the build names it. */
+function versionParams() {
+	const versionId = builtVersion();
+	return versionId === void 0 ? {} : { mostra: { versionId } };
+}
+const listeners = /* @__PURE__ */ new Set();
+let connecting;
+/**
+* Listens to the shell's requests and notifications on this page's bridge; returns the function
+* that stops. The client runtime answers `mostra/flush` and hears `mostra/version.available`.
+*/
+function listenShell(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+/**
+* Connects this page to the shell that frames it, once; later calls return the same connection.
+* Resolves `undefined` when the page isn't framed by a Mostra shell. The client runtime calls it;
+* artifact code doesn't need to.
+*/
+function connectShell() {
+	connecting ??= (async () => {
+		if (typeof window === "undefined" || window.parent === window) return void 0;
+		let session;
+		try {
+			const response = await fetch("/_mostra/session", {
+				credentials: "same-origin",
+				cache: "no-store",
+				signal: AbortSignal.timeout(HANDSHAKE_TIMEOUT_MS)
+			});
+			if (!response.ok) return void 0;
+			session = await response.json();
+		} catch {
+			return;
+		}
+		if (typeof session.shellOrigin !== "string") return void 0;
+		const shellOrigin = session.shellOrigin;
+		const bridge = connectBridge({
+			side: "artifact",
+			receiver: window,
+			peer: () => window.parent,
+			peerOrigin: shellOrigin,
+			onRequest: async (message, params) => {
+				for (const listener of listeners) {
+					const answer = await listener.request?.(message, params);
+					if (answer !== void 0) return answer;
+				}
+				throw new Error(`The page doesn't answer ${message.method}.`);
+			},
+			onNotification: (message, params) => {
+				for (const listener of listeners) listener.notification?.(message, params);
+			}
+		});
+		let host;
+		try {
+			host = await bridge.call(uiInitialize, {
+				appInfo: {
+					name: "mostra-artifact",
+					version: "0"
+				},
+				appCapabilities: {},
+				protocolVersion: MCP_APPS_PROTOCOL_VERSION,
+				...versionParams()
+			}, { timeoutMs: HANDSHAKE_TIMEOUT_MS });
+		} catch (error) {
+			bridge.close();
+			throw error;
+		}
+		bridge.notify(uiInitialized, {});
+		return {
+			shellOrigin,
+			host,
+			bridge,
+			session: {
+				csrf: typeof session.csrf === "string" ? session.csrf : "",
+				scopes: Array.isArray(session.scopes) ? session.scopes.filter((scope) => typeof scope === "string") : [],
+				...isViewer(session.viewer) ? { viewer: session.viewer } : {}
+			}
+		};
+	})().then((connection) => {
+		if (connection === void 0) connecting = void 0;
+		return connection;
+	}, () => {
+		connecting = void 0;
+	});
+	return connecting;
+}
+/** Whether the session's `viewer` looks like a viewer (a light check: the gateway sends it). */
+function isViewer(value) {
+	const viewer = value;
+	return typeof viewer?.id === "string" && typeof viewer.kind === "string";
+}
+/** How long one attempt at the shell's handshake may take. */
+const HANDSHAKE_TIMEOUT_MS = 1e4;
+/**
+* Tells the shell the page has rendered (`mostra/ready`), after the next frame paints. The
+* client runtime calls it right after mounting the page.
+*/
+function reportReady() {
+	connectShell().then((connection) => {
+		if (!connection) return;
+		requestAnimationFrame(() => connection.bridge.notify(mostraReady, {}));
+	});
+}
+/**
+* Opens `url` for the viewer in a new tab. Inside Mostra's shell the frame can't navigate the
+* viewer's tab (D98 item 7), so the shell opens it (`ui/open-link`, MCP Apps); on a page of its
+* own, the browser does. Only `http:`, `https:`, `mailto:` and `tel:` URLs open. Resolves `true`
+* when the URL was handed to the browser.
+*/
+async function openLink(url) {
+	const connection = await connectShell();
+	if (connection) try {
+		return (await connection.bridge.call(uiOpenLink, { url })).isError !== true;
+	} catch {
+		return false;
+	}
+	let parsed;
+	try {
+		parsed = new URL(url, window.location.href);
+	} catch {
+		return false;
+	}
+	if (!OPEN_LINK_SCHEMES.includes(parsed.protocol)) return false;
+	window.open(parsed.href, "_blank", "noopener,noreferrer");
+	return true;
+}
+//#endregion
+//#region src/hooks.ts
+/**
+* The client runtime's hooks (INTERFACES §2.3, D52, D53, D113): fields that behave like
+* `useState` with a stable ID, the artifact channel's submit, the shell's trusted Submit label,
+* signals, choices, the viewer and the artifact. Every hook works in every delivery target: where
+* there is no Mostra server (a static export), fields keep their values in this browser, and
+* submit and signals reject with `MOSTRA_TARGET_UNAVAILABLE`.
+*/
+const RuntimeContext = createContext(void 0);
+let fallback;
+/** The runtime of a tree rendered outside `mountArtifact` (a test, a component gallery): local. */
+function fallbackRuntime() {
+	if (!fallback) {
+		const store = new Store({
+			mode: "local",
+			journal: new MemoryJournal(),
+			tab: "fallback"
+		});
+		store.start();
+		fallback = {
+			store,
+			mode: "static"
+		};
+	}
+	return fallback;
+}
+/** Provides a runtime to a tree; `mountArtifact` renders the page inside it. */
+function RuntimeProvider(props) {
+	const value = useMemo(() => ({
+		store: props.store,
+		mode: props.mode
+	}), [props.store, props.mode]);
+	return createElement(RuntimeContext.Provider, { value }, props.children);
+}
+function useRuntime() {
+	return useContext(RuntimeContext) ?? fallbackRuntime();
+}
+/** The page's store, for the package's own adapters (`@mostra/react/form`). @internal */
+function useStore() {
+	return useRuntime().store;
+}
+/** Re-renders on every change of the store; returns its version. */
+function useStoreVersion(store) {
+	return useSyncExternalStore(store.subscribe, store.version, store.version);
+}
+/** The message shown while an asynchronous check runs; it blocks a submit until it settles. */
+const CHECKING = "Checking this answer…";
+function messageOf(result) {
+	const issues = result?.issues;
+	return issues && issues.length > 0 ? issues[0]?.message ?? "Invalid value." : void 0;
+}
+function validationOf(validate, value) {
+	if (validate === void 0) return {
+		kind: "now",
+		error: void 0
+	};
+	if (typeof validate === "function") return {
+		kind: "now",
+		error: validate(value) ?? void 0
+	};
+	const result = validate["~standard"].validate(value);
+	if (result instanceof Promise) return {
+		kind: "later",
+		settled: result.then(messageOf, () => "This answer couldn't be checked.")
+	};
+	return {
+		kind: "now",
+		error: messageOf(result)
+	};
+}
+function updatedByOf(actor) {
+	if (!actor || actor.kind === "mostra") return void 0;
+	return {
+		kind: actor.kind,
+		...actor.name !== void 0 ? { name: actor.name } : {}
+	};
+}
+const warned = /* @__PURE__ */ new Set();
+/**
+* A persisted value with a stable field ID (D52). It behaves like `useState`: the value the viewer
+* sees, a setter, and what the field is doing. Edits save to Mostra as the viewer works, survive
+* reloads, closed tabs and other devices, reach other tabs, and carry over to newer versions by
+* ID. Dotted IDs (`reply.m1`) nest in results.
+*
+* ```tsx
+* const [layout, setLayout, meta] = useField("layout", "a", { label: "Layout", required: true });
+* ```
+*/
+function useField(id, initial, options = {}) {
+	const { store } = useRuntime();
+	const scope = options.scope ?? "viewer";
+	const key = fieldKey(scope, id);
+	const [first] = useState(() => initial);
+	useSyncExternalStore(store.subscribe, () => store.keyVersion(key), () => store.keyVersion(key));
+	const value = store.value(key, first);
+	const { validate } = options;
+	const validation = useMemo(() => validationOf(validate, value), [validate, value]);
+	const [settled, setSettled] = useState();
+	useEffect(() => {
+		if (validation.kind !== "later") return;
+		let current = true;
+		validation.settled.then((message) => {
+			if (current) setSettled({
+				of: validation,
+				error: message
+			});
+		});
+		return () => {
+			current = false;
+		};
+	}, [validation]);
+	const error = validation.kind === "now" ? validation.error : settled?.of === validation ? settled.error : CHECKING;
+	const { label, required, sensitive } = options;
+	useEffect(() => store.register({
+		id,
+		scope,
+		initial: first,
+		...label !== void 0 ? { label } : {},
+		...required !== void 0 ? { required } : {},
+		...sensitive !== void 0 ? { sensitive } : {}
+	}), [
+		store,
+		id,
+		scope,
+		first
+	]);
+	useEffect(() => {
+		store.updateRegistration({
+			id,
+			scope,
+			initial: first,
+			...label !== void 0 ? { label } : {},
+			...required !== void 0 ? { required } : {},
+			...sensitive !== void 0 ? { sensitive } : {},
+			...error !== void 0 ? { error } : {}
+		});
+	});
+	useEffect(() => {
+		if (validation.kind !== "later") return;
+		return store.beforeSubmit(async () => {
+			const message = await validation.settled;
+			store.updateRegistration({
+				id,
+				scope,
+				initial: first,
+				...label !== void 0 ? { label } : {},
+				...required !== void 0 ? { required } : {},
+				...sensitive !== void 0 ? { sensitive } : {},
+				...message !== void 0 ? { error: message } : {}
+			});
+		});
+	}, [
+		store,
+		validation,
+		id,
+		scope,
+		first,
+		label,
+		required,
+		sensitive
+	]);
+	const set = useCallback((next) => {
+		if (!store.writable(key)) {
+			if (!warned.has(key)) {
+				warned.add(key);
+				console.warn(`Mostra: the field ${id} is read-only here (submitted, or a view-only link); the change was not kept.`);
+			}
+			return;
+		}
+		const previous = store.value(key, first);
+		const resolved = typeof next === "function" ? next(previous) : next;
+		store.set(scope, id, resolved, {
+			...label !== void 0 ? { label } : {},
+			...required !== void 0 ? { required } : {},
+			...sensitive !== void 0 ? { sensitive } : {}
+		});
+	}, [
+		store,
+		key,
+		scope,
+		id,
+		label,
+		required,
+		sensitive,
+		first
+	]);
+	const conflict = store.conflict(key);
+	const refusal = store.refusal(key);
+	const save = store.save(key);
+	const writer = updatedByOf(store.updatedBy(key));
+	const writerKind = writer?.kind;
+	const writerName = writer?.name;
+	return [
+		value,
+		set,
+		useMemo(() => {
+			const message = error ?? refusal?.message;
+			const updatedBy = writerKind === void 0 ? void 0 : {
+				kind: writerKind,
+				...writerName !== void 0 ? { name: writerName } : {}
+			};
+			return {
+				save,
+				...message !== void 0 ? { error: message } : {},
+				...conflict ? { conflict: {
+					theirs: conflict.deleted ? first : conflict.theirs,
+					keepMine: () => store.keepMine(key),
+					takeTheirs: () => store.takeTheirs(key)
+				} } : {},
+				...scope === "artifact" && updatedBy ? { updatedBy } : {}
+			};
+		}, [
+			save,
+			error,
+			refusal,
+			conflict,
+			writerKind,
+			writerName,
+			store,
+			key,
+			scope,
+			first
+		])
+	];
+}
+/** The artifact channel's submit, the blockers and the submission's state (D40, IN-13). */
+function useSubmit() {
+	const { store } = useRuntime();
+	const version = useStoreVersion(store);
+	return useMemo(() => {
+		const view = store.view;
+		const state = store.submitState();
+		const submission = store.submission();
+		const openState = state === "open" || view?.policy.policy === "epochs" && state !== "submitting";
+		return {
+			submit: () => store.submit(),
+			allowed: store.mode === "live" && view !== void 0 && view.submitChannels.includes("artifact") && view.policy.policy !== "none" && store.canSubmit() && !store.closed && openState,
+			blockers: store.blockers(),
+			state,
+			...submission ? { submission: {
+				id: submission.id,
+				at: submission.at
+			} } : {}
+		};
+	}, [store, version]);
+}
+/** Asks the shell for a trusted control while mounted, and withdraws it on unmount. */
+function useControl(request, release) {
+	const text = request === void 0 ? void 0 : JSON.stringify(request);
+	const releaseText = JSON.stringify(release);
+	useEffect(() => {
+		if (text === void 0) return;
+		let active = true;
+		connectShell().then((connection) => {
+			if (!active || !connection) return;
+			connection.bridge.call(mostraControlsRequest, JSON.parse(text)).catch(() => void 0);
+		});
+		return () => {
+			active = false;
+			connectShell().then((connection) => {
+				connection?.bridge.call(mostraControlsRequest, JSON.parse(releaseText)).catch(() => void 0);
+			});
+		};
+	}, [text, releaseText]);
+}
+/**
+* Relabels the shell's trusted Submit while mounted, and asks the shell to confirm with `confirm`
+* first (D06, SH-02). The artifact asks; the shell renders the control in its own origin, where
+* the artifact can't reach it.
+*/
+function useSubmitControl(options) {
+	useControl({
+		control: "submit",
+		...options.label !== void 0 ? { label: options.label } : {},
+		...options.confirm !== void 0 ? { confirm: options.confirm } : {}
+	}, {
+		control: "release",
+		submit: true
+	});
+}
+/** A named signal for the host's attention (IN-09), such as "Ping the agent". */
+function useSignal(name) {
+	const { store } = useRuntime();
+	return useMemo(() => ({ send: (payload) => store.signal(name, payload) }), [store, name]);
+}
+/**
+* A review set's choice (D65, D113): the field `review.<reviewSetId>.choice`. With `candidates`,
+* the shell renders a trusted Choose for the candidate the page shows (`current`); `choose()`
+* chooses from inside the page where the host allows the artifact channel (D40), else rejects
+* with `MOSTRA_SUBMIT_CHANNEL_DENIED`.
+*/
+function useChoice(reviewSetId, options) {
+	const { store } = useRuntime();
+	const id = `review.${reviewSetId}.choice`;
+	const key = fieldKey("viewer", id);
+	useSyncExternalStore(store.subscribe, () => store.keyVersion(key), () => store.keyVersion(key));
+	const choice = store.value(key, void 0);
+	useEffect(() => store.announceMount({
+		id,
+		scope: "viewer",
+		initial: void 0,
+		hook: "useChoice"
+	}), [store, id]);
+	const candidates = options?.candidates;
+	useControl(candidates && candidates.length > 0 ? {
+		control: "choose",
+		reviewSetId,
+		candidates: candidates.map((candidate) => ({
+			id: candidate.id,
+			...candidate.label !== void 0 ? { label: candidate.label } : {}
+		})),
+		...options?.current !== void 0 ? { current: options.current } : {}
+	} : void 0, {
+		control: "release",
+		reviewSetId
+	});
+	const labels = useMemo(() => new Map((candidates ?? []).map((candidate) => [candidate.id, candidate.label])), [candidates]);
+	const choose = useCallback(async (candidateId) => {
+		const view = store.view;
+		if (store.mode === "live" && view && !view.submitChannels.includes("artifact")) throw new MostraError("MOSTRA_SUBMIT_CHANNEL_DENIED", "This host takes choices from the shell's trusted Choose only.");
+		const label = labels.get(candidateId);
+		store.set("viewer", id, candidateId, {
+			...label !== void 0 ? { label } : {},
+			immediate: true
+		});
+		await store.flush();
+	}, [
+		store,
+		id,
+		labels
+	]);
+	return {
+		...typeof choice === "string" ? { choice } : {},
+		choose
+	};
+}
+/** Who the page acts as (D104): the home's local user, a tailnet user, or a link's person. */
+function useViewer() {
+	const { store } = useRuntime();
+	useStoreVersion(store);
+	const viewer = store.viewer();
+	return viewer ? {
+		id: viewer.id,
+		...viewer.name !== void 0 ? { name: viewer.name } : {},
+		source: viewer.kind
+	} : {
+		id: "",
+		source: "local"
+	};
+}
+/** The artifact, the version and the view the page shows, and where it runs (D104, D111). */
+function useArtifact() {
+	const { store, mode } = useRuntime();
+	const view = store.view;
+	return {
+		id: view?.artifactId ?? "",
+		versionId: view?.version.id ?? "",
+		version: view?.version.number ?? 0,
+		viewId: view?.viewId ?? "",
+		mode
+	};
+}
+//#endregion
+export { serverFunctionId as _, useSignal as a, MemoryJournal as b, useSubmitControl as c, connectShell as d, listenShell as f, fieldKey as g, Store as h, useField as i, useViewer as l, reportReady as m, useArtifact as n, useStore as o, openLink as p, useChoice as r, useSubmit as s, RuntimeProvider as t, builtVersion as u, HttpTransport as v, MostraError as x, IndexedDbJournal as y };
+
+//# sourceMappingURL=hooks-Dh_l8KqJ.js.map