gesso-framework 0.6.6 → 0.6.8

package/dist/serveChannels-Cs22-p8X.js

@@ -0,0 +1,952 @@
+import { a as agentSurface, i as serveAgentPort } from "./remote-gRdwYo-q.js";
+import { Subscription } from "rxjs";
+//#region src/channel/structuralEquals.ts
+/**
+* Deep comparison for store read models.
+*
+* Projections and selectors allocate a fresh value on every
+* evaluation, so reference equality reports a change on every
+* unrelated state emission. That invalidates bindings and dirties
+* nodes across the whole tree for state the view never read.
+*
+* Scope is deliberately narrow: primitives, arrays, and plain objects
+* — what a projection is allowed to return. Anything else (class
+* instances, Date, Map, Set, functions) compares by reference, which
+* is conservative: it reports a change, so the UI updates when it did
+* not need to rather than failing to update when it did.
+*
+* The same comparison becomes the equality half of the patch differ
+* in Phase E, so a store behaves identically local or remote.
+*/
+const MAX_DEPTH$1 = 100;
+function structurallyEqual(a, b) {
+	return compare(a, b, 0);
+}
+function compare(a, b, depth) {
+	if (Object.is(a, b)) return true;
+	if (depth > MAX_DEPTH$1) return false;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aIsArray = Array.isArray(a);
+	if (aIsArray !== Array.isArray(b)) return false;
+	if (aIsArray) {
+		const left = a;
+		const right = b;
+		if (left.length !== right.length) return false;
+		for (let i = 0; i < left.length; i++) if (!compare(left[i], right[i], depth + 1)) return false;
+		return true;
+	}
+	if (!isPlainObject$1(a) || !isPlainObject$1(b)) return false;
+	const left = a;
+	const right = b;
+	const leftKeys = Object.keys(left);
+	if (leftKeys.length !== Object.keys(right).length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
+		if (!compare(left[key], right[key], depth + 1)) return false;
+	}
+	return true;
+}
+/**
+* Objects created from an object literal or a null prototype. Class
+* instances are excluded so they keep reference semantics.
+*/
+function isPlainObject$1(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/channel/ChannelToken.ts
+/**
+* Declares a channel.
+*
+* The name identifies it across the thread boundary and must be
+* stable; unlike a class name it survives minification, which is why
+* it is written out rather than derived.
+*/
+function channel(name, initial) {
+	if (name.length === 0) throw new Error("A channel needs a name: it is how the two threads agree on which one this is.");
+	return {
+		name,
+		initial
+	};
+}
+/**
+* Declares a channel from one object.
+*
+*   export const Catalog = defineChannel('catalog', {
+*     view: {
+*       products: [] as readonly ProductRow[],
+*       status: 'loading' as ShelfStatus
+*     },
+*     commands: {} as {
+*       addToCart(id: string, quantity: number): void;
+*       move(from: number, to: number): void;
+*     }
+*   });
+*
+*   export type CatalogView = ViewOf<typeof Catalog>;
+*
+* The same token `channel()` returns, declared once instead of three
+* times. `channel<View, Commands>(name, initial)` wrote the view as an
+* interface, then as an initial literal that had to agree with it, and
+* a key added to one and forgotten in the other was a type error in a
+* third file. Here the object is the type.
+*
+* A field whose initial value is narrower than the type it holds is
+* given the type it holds: `[]` is `never[]` and `'loading'` is
+* `string` unless it is said, which is what the `as` clauses above are
+* for. `ViewOf` and `CommandsOf` name the resulting types wherever the
+* application used to name its own interface.
+*
+* `channel()` is not deprecated and keeps working exactly as it did.
+* An application with interfaces it wants to keep, because they are
+* shared with something else or because the initial values are built
+* elsewhere, has nothing to migrate.
+*/
+function defineChannel(name, spec) {
+	return channel(name, spec.view);
+}
+/**
+* The keys a channel publishes.
+*
+* Structural in its parameter rather than generic over the token, so
+* it does not have to agree with any particular command type to read
+* what is only ever the initial value's shape.
+*/
+function viewKeys(token) {
+	return Object.keys(token.initial);
+}
+//#endregion
+//#region src/channel/ChannelProtocol.ts
+function isChannelClientMessage(value) {
+	const type = value?.type;
+	return type === "channel:sync" || type === "channel:command";
+}
+function isChannelHostMessage(value) {
+	const type = value?.type;
+	return type === "channel:patch" || type === "channel:error";
+}
+//#endregion
+//#region src/channel/StorePatch.ts
+/**
+* Describes how to turn `previous` into `current` for one projection.
+*
+* Returns an empty list when nothing changed, which is the common case
+* and the reason this exists: the point of a projection is that most
+* state changes do not alter it, and the ones that do usually alter a
+* small part.
+*/
+function diffProjection(projection, previous, current) {
+	const patches = [];
+	diff(projection, [], previous, current, patches);
+	return patches;
+}
+function diff(projection, path, previous, current, out) {
+	if (structurallyEqual(previous, current)) return;
+	if (Array.isArray(previous) && Array.isArray(current)) {
+		diffArray(projection, path, previous, current, out);
+		return;
+	}
+	if (isPlainObject(previous) && isPlainObject(current)) {
+		for (const key of Object.keys(current)) if (Object.prototype.hasOwnProperty.call(previous, key)) diff(projection, [...path, key], previous[key], current[key], out);
+		else out.push({
+			op: "set",
+			projection,
+			path: [...path, key],
+			value: current[key]
+		});
+		for (const key of Object.keys(previous)) if (!Object.prototype.hasOwnProperty.call(current, key)) out.push({
+			op: "delete",
+			projection,
+			path: [...path, key]
+		});
+		return;
+	}
+	out.push({
+		op: "set",
+		projection,
+		path,
+		value: current
+	});
+}
+/**
+* Diffs two arrays by trimming the common prefix and suffix.
+*
+* This is not a minimal edit script — a shuffle degrades to replacing
+* the middle wholesale. It is chosen because the operations lists
+* actually undergo (append, prepend, remove one, edit in place) all
+* reduce to a single small patch, and computing a true LCS on every
+* store change would cost more than it saves.
+*/
+function diffArray(projection, path, previous, current, out) {
+	let start = 0;
+	while (start < previous.length && start < current.length && structurallyEqual(previous[start], current[start])) start++;
+	let previousEnd = previous.length - 1;
+	let currentEnd = current.length - 1;
+	while (previousEnd >= start && currentEnd >= start && structurallyEqual(previous[previousEnd], current[currentEnd])) {
+		previousEnd--;
+		currentEnd--;
+	}
+	const previousCount = previousEnd - start + 1;
+	const currentCount = currentEnd - start + 1;
+	if (previousCount === 0 && currentCount === 0) return;
+	if (previousCount === currentCount) {
+		for (let offset = 0; offset < previousCount; offset++) {
+			const index = start + offset;
+			diff(projection, [...path, index], previous[index], current[index], out);
+		}
+		return;
+	}
+	out.push({
+		op: "splice",
+		projection,
+		path,
+		index: start,
+		deleteCount: previousCount,
+		items: current.slice(start, currentEnd + 1)
+	});
+}
+/**
+* Applies patches to a projection value, sharing structure with the
+* original everywhere the patch did not reach.
+*
+* Nothing handed in is mutated: bindings hold onto emitted values, so a
+* replica that edited in place would change data a component already
+* rendered.
+*
+* **Each container on a patched path is copied once per batch, not once
+* per patch.** A batch of N patches into one K-key object used to cost
+* N × K: every patch spread the whole object again to change one key.
+* A snapshot keyed by id is exactly that shape — gessologic published
+* `Record<netId, 0 | 1>` for ten thousand nets, about nine hundred
+* patches a publish, and the render worker's patch phase fell minutes
+* behind a 60 Hz stream it could never catch. So the batch remembers
+* the containers it has copied, and writes into those in place: they
+* are its own, made during this call and seen by nobody yet. Values
+* that arrived inside a patch are never written into, because they are
+* the patch's — a devtools log replays the same patch objects again.
+*/
+function applyPatches(root, patches) {
+	const owned = /* @__PURE__ */ new Set();
+	let next = root;
+	for (const patch of patches) next = applyOne(next, patch, owned);
+	return next;
+}
+function applyPatch(root, patch) {
+	return applyOne(root, patch, /* @__PURE__ */ new Set());
+}
+function applyOne(root, patch, owned) {
+	switch (patch.op) {
+		case "set": return setIn(root, patch.path, 0, patch.value, owned);
+		case "delete":
+			if (patch.path.length === 0) return;
+			return deleteIn(root, patch.path, 0, owned);
+		case "splice": return updateIn(root, patch.path, 0, owned, (node) => {
+			const array = Array.isArray(node) ? node : [];
+			const spliced = array.slice(0, patch.index).concat(patch.items, array.slice(patch.index + patch.deleteCount));
+			owned.add(spliced);
+			return spliced;
+		});
+	}
+}
+function setIn(node, path, index, value, owned) {
+	if (index === path.length) return value;
+	const key = path[index];
+	const copy = cloneContainer(node, key, owned);
+	setKey(copy, key, setIn(readKey(node, key), path, index + 1, value, owned));
+	return copy;
+}
+function deleteIn(node, path, index, owned) {
+	const key = path[index];
+	const copy = cloneContainer(node, key, owned);
+	if (index === path.length - 1) {
+		if (Array.isArray(copy)) copy.splice(Number(key), 1);
+		else delete copy[String(key)];
+		return copy;
+	}
+	setKey(copy, key, deleteIn(readKey(node, key), path, index + 1, owned));
+	return copy;
+}
+function updateIn(node, path, index, owned, update) {
+	if (index === path.length) return update(node);
+	const key = path[index];
+	const copy = cloneContainer(node, key, owned);
+	setKey(copy, key, updateIn(readKey(node, key), path, index + 1, owned, update));
+	return copy;
+}
+/**
+* The container to write `key` into: `node` itself when this batch
+* already copied it, and a fresh copy, remembered, when it did not.
+*/
+function cloneContainer(node, key, owned) {
+	if (typeof node === "object" && node !== null && owned.has(node)) return node;
+	let copy;
+	if (Array.isArray(node)) copy = node.slice();
+	else if (isPlainObject(node)) copy = { ...node };
+	else copy = typeof key === "number" ? [] : {};
+	owned.add(copy);
+	return copy;
+}
+function readKey(node, key) {
+	if (node === null || node === void 0) return;
+	return node[key];
+}
+function setKey(container, key, value) {
+	container[key] = value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/channel/plainData.ts
+/**
+* Checks that a value can cross the barrier.
+*
+* `structurallyEqual` understands primitives, arrays and plain
+* objects, and falls back to reference equality for everything else —
+* which for a freshly built value reports "changed" every single time.
+* A view key holding a `Date`, a `Map` or a domain object therefore
+* re-emits on every unrelated update and dirties the subtree bound to
+* it, forever, while looking perfectly correct.
+*
+* That failure is invisible in a test and shows up as a vague slowness
+* much later, so `provide` checks each key's first emission and throws
+* naming the path. The view-model layer is where rich objects become
+* flat data; this is what makes that a rule rather than a convention.
+*
+* The check runs once per key, on the first value only. It is a
+* development guard against a design mistake, not a validator on the
+* hot path.
+*/
+const MAX_DEPTH = 100;
+/**
+* Returns the path to the first value that cannot cross, or null when
+* the whole tree is plain data.
+*/
+function findUnplainPath(value, path = []) {
+	if (path.length > MAX_DEPTH) return format(path);
+	if (value === null) return null;
+	const type = typeof value;
+	if (type === "string" || type === "number" || type === "boolean" || type === "undefined") return null;
+	if (type === "function" || type === "symbol" || type === "bigint") return format(path);
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) {
+			const found = findUnplainPath(value[index], [...path, index]);
+			if (found !== null) return found;
+		}
+		return null;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return format(path);
+	for (const [key, member] of Object.entries(value)) {
+		const found = findUnplainPath(member, [...path, key]);
+		if (found !== null) return found;
+	}
+	return null;
+}
+/**
+* Throws when `value` cannot cross the barrier, naming the channel,
+* the key and the path within it.
+*/
+function requirePlainData(channelName, key, value) {
+	const path = findUnplainPath(value);
+	if (path === null) return;
+	const where = path === "" ? `'${key}'` : `'${key}'${path}`;
+	throw new Error(`Channel '${channelName}' published ${where}, which is not plain data. Only primitives, arrays and plain objects cross the barrier: a Date, Map, Set, class instance or function compares by reference, so it would report a change on every update and rebuild the subtree bound to it. Flatten it in the view model.`);
+}
+function format(path) {
+	return path.map((step) => typeof step === "number" ? `[${step}]` : `.${step}`).join("");
+}
+//#endregion
+//#region src/channel/provide.ts
+/**
+* Publishes a channel from the thread that owns its data.
+*
+* Each view key is subscribed, diffed against what the other side last
+* saw, and sent as patches. Whatever produced the observable — a bare
+* subject or a stack of layers — stays here; only plain data crosses.
+*
+* Keys are subscribed on the first sync request, so a channel nobody
+* is watching costs nothing.
+*/
+function provide(token, source, port) {
+	return new ProvidedChannel(token, source, port);
+}
+var ProvidedChannel = class {
+	token;
+	source;
+	port;
+	subscriptions = new Subscription();
+	/**
+	* What the other side is known to hold, seeded from the token's
+	* initial value — which the replica also starts from, so an app
+	* whose first emission equals the initial sends nothing at all.
+	*/
+	previous = /* @__PURE__ */ new Map();
+	checked = /* @__PURE__ */ new Set();
+	synced = false;
+	constructor(token, source, port) {
+		this.token = token;
+		this.source = source;
+		this.port = port;
+		for (const key of viewKeys(token)) this.previous.set(key, token.initial[key]);
+		this.port.onmessage = (event) => this.receive(event.data);
+	}
+	receive(data) {
+		if (!isChannelClientMessage(data)) return;
+		try {
+			if (data.type === "channel:sync") {
+				this.sync();
+				return;
+			}
+			this.runCommand(data.command, data.payload, data.rest);
+		} catch (error) {
+			this.post({
+				type: "channel:error",
+				message: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : void 0
+			});
+		}
+	}
+	runCommand(name, payload, rest) {
+		const handler = this.source.commands?.[name];
+		if (handler === void 0) {
+			const names = Object.keys(this.source.commands ?? {}).sort().join(", ");
+			throw new Error(`Channel '${this.token.name}' has no command '${name}'. Declared commands: ${names.length > 0 ? names : "(none)"}.`);
+		}
+		handler(payload, ...rest ?? []);
+	}
+	sync() {
+		if (this.synced) {
+			this.resend();
+			return;
+		}
+		this.synced = true;
+		for (const key of viewKeys(this.token)) {
+			const observable = this.source.view[key];
+			if (observable === void 0) {
+				this.post({
+					type: "channel:error",
+					message: `Channel '${this.token.name}' declares view key '${key}' but nothing was provided for it.`
+				});
+				continue;
+			}
+			this.subscriptions.add(observable.subscribe({
+				next: (value) => this.publish(key, value),
+				error: (error) => this.post({
+					type: "channel:error",
+					message: `Channel '${this.token.name}' view key '${key}' errored: ${error instanceof Error ? error.message : String(error)}`,
+					stack: error instanceof Error ? error.stack : void 0
+				})
+			}));
+		}
+	}
+	publish(key, value) {
+		if (!this.checked.has(key)) {
+			this.checked.add(key);
+			try {
+				requirePlainData(this.token.name, key, value);
+			} catch (error) {
+				this.post({
+					type: "channel:error",
+					message: error instanceof Error ? error.message : String(error),
+					stack: error instanceof Error ? error.stack : void 0
+				});
+				return;
+			}
+		}
+		const patches = diffProjection(key, this.previous.get(key), value);
+		this.previous.set(key, value);
+		if (patches.length > 0) this.post({
+			type: "channel:patch",
+			patches
+		});
+	}
+	/** Re-sends every key in full, for a client that reattached. */
+	resend() {
+		const patches = [];
+		for (const [key, value] of this.previous) patches.push({
+			op: "set",
+			projection: key,
+			path: [],
+			value
+		});
+		if (patches.length > 0) this.post({
+			type: "channel:patch",
+			patches
+		});
+	}
+	post(message) {
+		this.port.postMessage(message);
+	}
+	dispose() {
+		this.subscriptions.unsubscribe();
+		this.port.onmessage = null;
+	}
+};
+//#endregion
+//#region src/app/NodeReport.ts
+/**
+* A node as a path somebody can read: `App > TrackScreen > ActionRow >
+* Button "Like"`.
+*
+* Written for error messages rather than for the inspector, and the
+* difference decides the shape. A report is read beside the tree it
+* came from, so an id is a handle; an error is read in a console or an
+* overlay with no tree beside it, and `node-4821` there is a fact
+* about nothing. The owner chain is what a person recognises, because
+* it is the components they wrote.
+*
+* Owners arrive nearest-first, as `UiNodeReport.owners` computes them,
+* and read outermost-first, as a path does. The accessible name is the
+* leaf when there is one: two `Button`s in the same row are only told
+* apart by what they say.
+*/
+function formatNodePath(owners, node) {
+	const names = owners.map((owner) => owner.name).reverse();
+	if (names.length === 0) return node.label === void 0 || node.label === "" ? `${node.type} ${node.id}` : `${node.type} "${node.label}"`;
+	const path = names.join(" > ");
+	return node.label === void 0 || node.label === "" ? path : `${path} "${node.label}"`;
+}
+/**
+* Describes the stream driving a property.
+*
+* `timeOrigin` turns the binding's own reading into an epoch stamp:
+* `performance.timeOrigin` on a thread that has one, and zero where
+* the reading is already an epoch.
+*/
+function describeStream(binding, timeOrigin) {
+	const label = binding.observable?.label;
+	const labelled = typeof label === "string" && label !== "";
+	const emittedAt = binding.emittedAt();
+	return {
+		source: labelled ? label : `observable #${binding.id}`,
+		kind: labelled ? "cell" : "observable",
+		value: printPropValue(binding.value()),
+		emissions: binding.emissionCount(),
+		emittedAt: emittedAt === null ? null : timeOrigin + emittedAt,
+		connected: binding.connected()
+	};
+}
+/** A stream as one line: what feeds the prop, and how long ago it said so. */
+function formatStream(stream, now = Date.now()) {
+	const when = stream.emittedAt === null ? "no value yet" : `${formatAge(Math.max(0, now - stream.emittedAt))} ago`;
+	const emissions = `${stream.emissions} emission${stream.emissions === 1 ? "" : "s"}`;
+	return `${stream.source} · ${emissions} · ${when}${stream.connected ? "" : " · disconnected"}`;
+}
+/** An age in the largest unit that stays readable. */
+function formatAge(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+	return `${Math.round(ms / 6e4)}m`;
+}
+/**
+* A value as one line a person can read.
+*
+* `JSON.stringify` alone is not enough: the two values a canvas UI
+* puts in a property that it cannot handle are a `Set` (a node's
+* visual states) and a function (an event handler), and it prints both
+* as `{}`, which in an inspector reads as a bug in the application
+* rather than one in the inspector.
+*/
+function printPropValue(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "function") return `ƒ ${value.name === "" ? "(anonymous)" : value.name}`;
+	if (typeof value === "symbol") return value.toString();
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value instanceof Set) return `Set { ${[...value].map(printPropValue).join(", ")} }`;
+	if (value instanceof Map) return `Map { ${[...value].map(([key, entry]) => `${printPropValue(key)}: ${printPropValue(entry)}`).join(", ")} }`;
+	if (Array.isArray(value)) return `[${value.map(printPropValue).join(", ")}]`;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/** The report as text, for a console or a test failure. */
+function formatNodeReport(report) {
+	const lines = [`${report.type} '${report.id}'`];
+	if (report.owners.length > 0) lines.push(`rendered by ${report.owners.map((owner) => owner.name).join(" inside ")}`);
+	if (report.modifiers.length > 0) lines.push(`modifiers: ${report.modifiers.join(", ")}`);
+	if (report.listens.length > 0) lines.push(`listens: ${report.listens.join(", ")}`);
+	if (report.beneath.length > 0) {
+		lines.push("beneath, at the pointer:");
+		for (const under of report.beneath) {
+			const owner = under.owner === void 0 ? "" : ` (${under.owner})`;
+			const listens = under.listens.length === 0 ? "" : `, listens: ${under.listens.join(", ")}`;
+			lines.push(`  ${under.type} ${under.id}${owner}${listens}`);
+		}
+	}
+	if (report.props.length > 0) {
+		lines.push("props:");
+		for (const prop of report.props) {
+			lines.push(`  ${prop.name} = ${prop.value}${prop.source === void 0 ? "" : ` (${prop.source})`}`);
+			if (prop.stream !== void 0) lines.push(`    ${formatStream(prop.stream)}`);
+		}
+	}
+	if (report.environment.length > 0) {
+		lines.push("environment:");
+		for (const entry of report.environment) lines.push(`  ${entry.key} = ${entry.value}${entry.provided ? " (provided here)" : ""}`);
+	}
+	if (report.semantics !== void 0) {
+		const parts = [
+			report.semantics.role === void 0 ? void 0 : `role ${report.semantics.role}`,
+			report.semantics.label === void 0 ? void 0 : `label ${report.semantics.label}`,
+			report.semantics.value === void 0 ? void 0 : `value ${report.semantics.value}`,
+			report.semantics.states === void 0 || report.semantics.states.length === 0 ? void 0 : `states ${report.semantics.states.join(", ")}`
+		].filter((part) => part !== void 0);
+		if (parts.length > 0) lines.push(`semantics: ${parts.join(" · ")}`);
+	}
+	lines.push(report.explanation);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/worker/captureConsole.ts
+const LEVELS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug"
+];
+/**
+* Copies every `console.*` call on `target` (the worker global's
+* console by default) to `sink`. Returns a function that restores the
+* original methods.
+*
+* Idempotent per target: a second capture on the same console replaces
+* the first's sink rather than nesting, so toggling a panel on twice
+* does not log twice.
+*/
+function captureConsole(sink, target = console) {
+	const installed = target[CAPTURED];
+	if (installed !== void 0) {
+		installed.sink = sink;
+		return installed.restore;
+	}
+	const originals = /* @__PURE__ */ new Map();
+	const state = {
+		sink,
+		restore: () => {
+			for (const [level, original] of originals) target[level] = original;
+			delete target[CAPTURED];
+		}
+	};
+	for (const level of LEVELS) {
+		const original = target[level];
+		originals.set(level, original);
+		target[level] = (...args) => {
+			original.apply(target, args);
+			try {
+				state.sink({
+					level,
+					args: args.map(formatConsoleArg),
+					at: Date.now()
+				});
+			} catch {}
+		};
+	}
+	target[CAPTURED] = state;
+	return state.restore;
+}
+const CAPTURED = Symbol.for("gesso:console-captured");
+/**
+* One console argument as the panel prints it.
+*
+* `printPropValue` already prints the values a canvas UI is likely to
+* log; an Error is the one thing it prints badly (`{}`), and the one
+* thing a developer most wants to read whole.
+*/
+function formatConsoleArg(value) {
+	if (value instanceof Error) return value.stack !== void 0 && value.stack !== "" ? value.stack : `${value.name}: ${value.message}`;
+	return printPropValue(value);
+}
+function isConsoleForwardingMessage(value) {
+	const message = value;
+	return message?.type === "gesso:console" && typeof message.enabled === "boolean";
+}
+function isConsoleEntryMessage(value) {
+	const message = value;
+	return message?.type === "gesso:console" && typeof message.entry === "object" && message.entry !== null;
+}
+//#endregion
+//#region src/worker/WorkerPorts.ts
+/**
+* Named `MessagePort`s into a worker.
+*
+* A worker's global `onmessage` is a single channel, so a worker that
+* receives messages on it can host exactly one conversation. That is
+* why a store in a data worker used to mean a worker per store: the
+* client claimed the `Worker` object itself, and a second one had
+* nowhere to go.
+*
+* A handshake fixes it. The client opens a `MessageChannel`, keeps one
+* end and transfers the other with a name; the worker serves that name
+* and the two ends talk privately from then on. The global channel is
+* used once per conversation and carries nothing else.
+*
+* Nothing here knows what travels over a port. It is the transport the
+* store replication in `../store/worker` runs on today and the barrier
+* contract will run on next.
+*/
+function isPortHandshake(value) {
+	const message = value;
+	return message?.type === "gesso:port" && typeof message.key === "string";
+}
+/**
+* Stands for "whichever worker the shell spawned for the application".
+*
+* A registration inside the render worker cannot name that worker: it
+* is created by the shell and its port only arrives with `init`, long
+* after `useChannel` and `useService` have run. This sentinel is what a
+* registration puts there instead, and the render worker swaps it for
+* the real handle once the port shows up.
+*
+* Opening a port on it before then is a bug rather than a race, so it
+* says so.
+*/
+const APPLICATION_WORKER = {
+	open() {
+		throw new Error("APPLICATION_WORKER was used directly. It is a placeholder the render worker replaces with the shell's port; reaching it means no application-logic worker was supplied. Pass appLogicWorker to createApp.");
+	},
+	spawned: false,
+	terminate() {}
+};
+/**
+* A handle over an endpoint someone else owns.
+*
+* The shell spawns the application worker and hands the render worker
+* one end of a channel to it; this is what the render worker opens
+* named ports over. `terminate` is a no-op — the lifetime belongs to
+* whoever created the endpoint, and a handle that could kill a worker
+* it did not spawn would be a surprising thing to hand out.
+*/
+function portHandle(endpoint) {
+	return {
+		open(key) {
+			const channel = new MessageChannel();
+			endpoint.postMessage({
+				type: "gesso:port",
+				key
+			}, [channel.port2]);
+			return channel.port1;
+		},
+		get spawned() {
+			return true;
+		},
+		terminate() {}
+	};
+}
+function isHubMessage(value) {
+	return value?.type === "gesso:hub";
+}
+const BASE_INSTALLED = Symbol.for("gesso:port-base-installed");
+const CONSOLE_RESTORE = Symbol.for("gesso:port-console-restore");
+/**
+* Starts or stops copying this worker's console to whoever posts to
+* it, as `ConsoleEntryMessage`s. A host with no `postMessage` (a test's
+* bare object) has nowhere to send them and forwards nothing.
+*/
+function setConsoleForwarding(host, enabled) {
+	host[CONSOLE_RESTORE]?.();
+	delete host[CONSOLE_RESTORE];
+	const post = host.postMessage;
+	if (!enabled || typeof post !== "function") return;
+	host[CONSOLE_RESTORE] = captureConsole((entry) => {
+		const message = {
+			type: "gesso:console",
+			entry
+		};
+		post.call(host, message);
+	});
+}
+/**
+* The handler every `servePorts` chain sits on top of.
+*
+* It owns the two things no individual server can: routing a hub port
+* through the whole chain, and answering a handshake that nobody
+* accepted. Both have to be innermost — the first because the chain is
+* only complete once every server has wrapped `onmessage`, the second
+* because "nobody accepted" is only known after every server has
+* declined.
+*/
+function installBase(host) {
+	if (host[BASE_INSTALLED] === true) return;
+	host[BASE_INSTALLED] = true;
+	const previous = host.onmessage;
+	const registered = host[SERVED_NAMES] ?? [];
+	host.onmessage = (event) => {
+		if (isConsoleForwardingMessage(event.data)) {
+			setConsoleForwarding(host, event.data.enabled);
+			return;
+		}
+		if (isHubMessage(event.data)) {
+			const port = event.ports?.[0];
+			if (port === void 0) throw new Error("A hub message arrived with no port attached.");
+			port.onmessage = host.onmessage;
+			return;
+		}
+		if (!isPortHandshake(event.data)) {
+			previous?.(event);
+			return;
+		}
+		const port = event.ports?.[0];
+		if (port === void 0) throw new Error(`Port handshake for '${event.data.key}' arrived with no port attached.`);
+		const served = registered.flatMap((get) => [...get()]).sort();
+		const error = {
+			type: "port:error",
+			message: `Nothing is served under '${event.data.key}'. This worker serves: ${served.length > 0 ? served.join(", ") : "(nothing)"}.`
+		};
+		port.postMessage(error);
+	};
+}
+/**
+* Wraps a worker factory so the worker is created once and shared.
+*
+* A factory rather than a URL for the same reason the render worker
+* takes one: a bundler only emits a chunk for a worker it can see
+* constructed literally in the calling module.
+*
+*   const data = workerHandle(
+*     () => new Worker(new URL('./data.worker.ts', import.meta.url), { type: 'module' })
+*   );
+*/
+function workerHandle(factory) {
+	let worker;
+	return {
+		open(key) {
+			worker ??= factory();
+			const channel = new MessageChannel();
+			worker.postMessage({
+				type: "gesso:port",
+				key
+			}, [channel.port2]);
+			return channel.port1;
+		},
+		get spawned() {
+			return worker !== void 0;
+		},
+		terminate() {
+			worker?.terminate();
+			worker = void 0;
+		}
+	};
+}
+function isPortErrorMessage(value) {
+	const message = value;
+	return message?.type === "port:error" && typeof message.message === "string";
+}
+/** Every name served on a host, across all `servePorts` calls on it. */
+const SERVED_NAMES = Symbol.for("gesso:served-port-names");
+/**
+* Serves named ports inside a worker.
+*
+* Call it synchronously at the top level of the worker module, before
+* any await, so no handshake is missed.
+*
+* `onPort` returns whether it took the port. Returning false passes
+* the handshake to whatever was serving before, which is what lets two
+* kinds of thing — stores and channels, during the migration — share
+* one worker: each answers for its own names and declines the rest.
+* When nobody accepts, the port is answered with an error naming
+* everything the worker does serve, because a handshake that silently
+* matched nothing leaves the client waiting forever with nothing said.
+*
+* `names` is only read to build that message.
+*
+* Returns a function that stops serving.
+*/
+function servePorts(onPort, names, host = self) {
+	const withNames = host;
+	const registered = withNames[SERVED_NAMES] ??= [];
+	registered.push(names);
+	installBase(host);
+	const previous = host.onmessage;
+	host.onmessage = (event) => {
+		if (!isPortHandshake(event.data)) {
+			previous?.(event);
+			return;
+		}
+		const port = event.ports?.[0];
+		if (port === void 0) throw new Error(`Port handshake for '${event.data.key}' arrived with no port attached.`);
+		if (onPort(event.data.key, port)) return;
+		previous?.(event);
+	};
+	return () => {
+		host.onmessage = previous;
+		const index = registered.indexOf(names);
+		if (index >= 0) registered.splice(index, 1);
+	};
+}
+//#endregion
+//#region src/channel/serveChannels.ts
+/**
+* One served channel, with its source checked against its token.
+*
+* `ServedChannel` is erased on purpose, so one list can hold channels
+* of every shape; the cost is that a view key the token declares and
+* the source forgets is found at startup, by the error `provide`
+* reports, rather than by the compiler. This is the typed seam: the
+* source must hold an Observable for every key of the token's view and
+* a handler for every command, and each handler takes the arguments
+* the token declares, so none of them needs an annotation.
+*
+*   serveChannels([
+*     serve(Catalog, { view: catalog, commands: { add: name => catalog.add(name) } })
+*   ]);
+*
+* The view may be any object with the right observables on it, which
+* is often the domain object itself when its properties are named
+* after the keys. Only the declared keys are read from it.
+*/
+function serve(token, source) {
+	return {
+		token,
+		source
+	};
+}
+/**
+* Publishes channels from an application worker.
+*
+* Call it synchronously at the top level of the worker module, before
+* any await, so no handshake is missed:
+*
+*   const catalog = new CatalogViewModel(new CatalogDomain(new OpfsStore()));
+*   serveChannels([
+*     serve(Catalog, { view: { products: catalog.products$ }, commands: { … } })
+*   ]);
+*
+* Everything above this call is the application's own — plain classes,
+* plain observables, no framework import. This function is the entire
+* seam between it and the view.
+*
+* Returns a function that stops serving and disposes what it provided.
+*/
+function serveChannels(channels, host) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const served of channels) byName.set(served.token.name, served);
+	const provided = [];
+	const stop = servePorts((key, port) => {
+		if (key === "gesso:agent") {
+			serveAgentPort(port, (confirm) => agentSurface(channels, { confirm }));
+			return true;
+		}
+		const served = byName.get(key);
+		if (served === void 0) return false;
+		provided.push(provide(served.token, served.source, port));
+		return true;
+	}, () => [...byName.keys()], host);
+	return () => {
+		stop();
+		for (const channel of provided) channel.dispose();
+		provided.length = 0;
+	};
+}
+//#endregion
+export { structurallyEqual as A, applyPatches as C, channel as D, isChannelHostMessage as E, defineChannel as O, applyPatch as S, isChannelClientMessage as T, printPropValue as _, isPortErrorMessage as a, findUnplainPath as b, servePorts as c, isConsoleEntryMessage as d, describeStream as f, formatStream as g, formatNodeReport as h, isHubMessage as i, viewKeys as k, workerHandle as l, formatNodePath as m, serveChannels as n, isPortHandshake as o, formatAge as p, APPLICATION_WORKER as r, portHandle as s, serve as t, captureConsole as u, ProvidedChannel as v, diffProjection as w, requirePlainData as x, provide as y };
+
+//# sourceMappingURL=serveChannels-Cs22-p8X.js.map