@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/preview/_chunks/runtime-iXdo8CR8.js

@@ -0,0 +1,3635 @@
+import { n as __esmMin } from "./runtime-BdGkqNEt.js";
+import { A as variant, C as pipe, D as string, E as safeParse, J as isEqual, M as init_index_browser, N as nanoid, O as undefined_, S as optional, T as safeInteger, _ as looseObject, b as number, c as slash, d as l, f as array, g as literal, h as init_dist, j as void_, k as unknown, l as g, lt as dedent, m as custom, p as check, q as init_isEqual, u as init_deepsignal_core_module, ut as init_esm, v as minLength, w as record, x as object, y as minValue } from "./runtime-BZSnICCg.js";
+import { n as init_storybook_error, t as StorybookError } from "./runtime-BwSxqk3t.js";
+import { At as init_manager_errors, Dt as OpenServiceStaticSnapshotInvalidError, F as init_channel_slot, Ot as OpenServiceStaticSnapshotLoadError, P as getChannel, Tt as logger, f as init_storyDocsCodePanel, kt as UniversalStoreFollowerTimeoutError, p as shouldSkipStoryDocsEmit, r as definePreviewAddon, wt as init_client_logger } from "./runtime-DrTjJkPY.js";
+import { i as j, n as g$1, o as n, r as init_signals_core_module, s as y, t as f } from "./runtime-BTPtVY1p.js";
+import { i as emitTransformCode, r as init_preview_api } from "./runtime-CsV4HZPV.js";
+//#region src/shared/universal-store/first-party-store-ids.ts
+var FIRST_PARTY_STORE_IDS, isFirstPartyStoreId;
+function init_first_party_store_ids() {
+	return (init_first_party_store_ids = __esmMin((() => {
+		FIRST_PARTY_STORE_IDS = /* @__PURE__ */ new Set([
+			"@aussieljk/forkbook/status",
+			"@aussieljk/forkbook/test-provider",
+			"@aussieljk/forkbook/test"
+		]);
+		isFirstPartyStoreId = (id) => FIRST_PARTY_STORE_IDS.has(id);
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/instances.ts
+var instances;
+function init_instances() {
+	return (init_instances = __esmMin((() => {
+		instances = /* @__PURE__ */ new Map();
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/index.ts
+var CHANNEL_EVENT_PREFIX, ProgressState, UniversalStore;
+function init_universal_store() {
+	return (init_universal_store = __esmMin((() => {
+		init_esm();
+		init_manager_errors();
+		init_first_party_store_ids();
+		init_instances();
+		CHANNEL_EVENT_PREFIX = "UNIVERSAL_STORE:";
+		ProgressState = {
+			PENDING: "PENDING",
+			RESOLVED: "RESOLVED",
+			REJECTED: "REJECTED"
+		};
+		UniversalStore = class UniversalStore {
+			static {
+				this.ActorType = {
+					LEADER: "LEADER",
+					FOLLOWER: "FOLLOWER"
+				};
+			}
+			static {
+				this.Environment = {
+					SERVER: "SERVER",
+					MANAGER: "MANAGER",
+					PREVIEW: "PREVIEW",
+					UNKNOWN: "UNKNOWN",
+					MOCK: "MOCK"
+				};
+			}
+			/** The environment this realm was prepared as, or `undefined` before `__prepare`. */
+			static get preparedEnvironment() {
+				return UniversalStore.preparation.environment;
+			}
+			static {
+				this.InternalEventType = {
+					EXISTING_STATE_REQUEST: "__EXISTING_STATE_REQUEST",
+					EXISTING_STATE_RESPONSE: "__EXISTING_STATE_RESPONSE",
+					SET_STATE: "__SET_STATE",
+					LEADER_CREATED: "__LEADER_CREATED",
+					FOLLOWER_CREATED: "__FOLLOWER_CREATED"
+				};
+			}
+			static {
+				this.Status = {
+					UNPREPARED: "UNPREPARED",
+					SYNCING: "SYNCING",
+					READY: "READY",
+					ERROR: "ERROR"
+				};
+			}
+			static {
+				this.isInternalConstructing = false;
+			}
+			static {
+				UniversalStore.setupPreparationPromise();
+			}
+			static setupPreparationPromise() {
+				let resolveRef;
+				let rejectRef;
+				const promise = new Promise((resolve, reject) => {
+					resolveRef = (args) => {
+						resolve(args);
+					};
+					rejectRef = (...args) => {
+						reject(args);
+					};
+				});
+				UniversalStore.preparation = {
+					resolve: resolveRef,
+					reject: rejectRef,
+					promise
+				};
+			}
+			/** The actor object representing the store instance with a unique ID and a type */
+			get actor() {
+				return Object.freeze({
+					id: this.actorId,
+					type: this.actorType,
+					environment: this.environment ?? UniversalStore.Environment.UNKNOWN
+				});
+			}
+			/**
+			* The current state of the store, that signals both if the store is prepared by Forkbook and
+			* also - in the case of a follower - if the state has been synced with the leader's state.
+			*/
+			get status() {
+				if (!this.channel || !this.environment) return UniversalStore.Status.UNPREPARED;
+				switch (this.syncing?.state) {
+					case ProgressState.PENDING:
+					case void 0: return UniversalStore.Status.SYNCING;
+					case ProgressState.REJECTED: return UniversalStore.Status.ERROR;
+					case ProgressState.RESOLVED:
+					default: return UniversalStore.Status.READY;
+				}
+			}
+			/**
+			* A promise that resolves when the store is fully ready. A leader will be ready when the store
+			* has been prepared by Forkbook, which is almost instantly.
+			*
+			* A follower will be ready when the state has been synced with the leader's state, within a few
+			* hundred milliseconds.
+			*/
+			untilReady() {
+				const preparation = this.channel && this.environment ? Promise.resolve() : UniversalStore.preparation.promise;
+				return Promise.all([preparation, this.syncing?.promise]);
+			}
+			constructor(options, environmentOverrides) {
+				this.debugging = false;
+				this.listeners = /* @__PURE__ */ new Map([["*", /* @__PURE__ */ new Set()]]);
+				this.getState = () => {
+					this.debug("getState", { state: this.state });
+					return this.state;
+				};
+				this.subscribe = (eventTypeOrListener, maybeListener) => {
+					const subscribesToAllEvents = typeof eventTypeOrListener === "function";
+					const eventType = subscribesToAllEvents ? "*" : eventTypeOrListener;
+					const listener = subscribesToAllEvents ? eventTypeOrListener : maybeListener;
+					this.debug("subscribe", {
+						eventType,
+						listener
+					});
+					if (!listener) throw new TypeError(`Missing first subscribe argument, or second if first is the event type, when subscribing to a UniversalStore with id '${this.id}'`);
+					if (!this.listeners.has(eventType)) this.listeners.set(eventType, /* @__PURE__ */ new Set());
+					this.listeners.get(eventType).add(listener);
+					return () => {
+						this.debug("unsubscribe", {
+							eventType,
+							listener
+						});
+						if (!this.listeners.has(eventType)) return;
+						this.listeners.get(eventType).delete(listener);
+						if (this.listeners.get(eventType)?.size === 0) this.listeners.delete(eventType);
+					};
+				};
+				this.send = (event) => {
+					this.debug("send", { event });
+					if (this.status !== UniversalStore.Status.READY) throw new TypeError(dedent`Cannot send event before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify({
+						event,
+						id: this.id,
+						actor: this.actor,
+						environment: this.environment
+					}, null, 2)}`);
+					this.emitToListeners(event, { actor: this.actor });
+					this.emitToChannel(event, { actor: this.actor });
+				};
+				this.debugging = options.debug ?? false;
+				if (!UniversalStore.isInternalConstructing) throw new TypeError("UniversalStore is not constructable - use UniversalStore.create() instead");
+				UniversalStore.isInternalConstructing = false;
+				this.id = options.id;
+				this.actorId = Date.now().toString(36) + Math.random().toString(36).substring(2);
+				this.actorType = options.leader ? UniversalStore.ActorType.LEADER : UniversalStore.ActorType.FOLLOWER;
+				this.state = options.initialState;
+				this.channelEventName = `${CHANNEL_EVENT_PREFIX}${this.id}`;
+				this.debug("constructor", {
+					options,
+					environmentOverrides,
+					channelEventName: this.channelEventName
+				});
+				if (this.actor.type === UniversalStore.ActorType.LEADER) this.syncing = {
+					state: ProgressState.RESOLVED,
+					promise: Promise.resolve()
+				};
+				else {
+					let syncingResolve;
+					let syncingReject;
+					const syncingPromise = new Promise((resolve, reject) => {
+						syncingResolve = () => {
+							if (this.syncing.state !== ProgressState.PENDING) return;
+							this.syncing.state = ProgressState.RESOLVED;
+							resolve();
+						};
+						syncingReject = (reason) => {
+							if (this.syncing.state !== ProgressState.PENDING) return;
+							this.syncing.state = ProgressState.REJECTED;
+							reject(reason);
+						};
+					});
+					this.syncing = {
+						state: ProgressState.PENDING,
+						promise: syncingPromise,
+						resolve: syncingResolve,
+						reject: syncingReject
+					};
+				}
+				this.getState = this.getState.bind(this);
+				this.setState = this.setState.bind(this);
+				this.subscribe = this.subscribe.bind(this);
+				this.onStateChange = this.onStateChange.bind(this);
+				this.send = this.send.bind(this);
+				this.emitToChannel = this.emitToChannel.bind(this);
+				this.prepareThis = this.prepareThis.bind(this);
+				this.emitToListeners = this.emitToListeners.bind(this);
+				this.handleChannelEvents = this.handleChannelEvents.bind(this);
+				this.debug = this.debug.bind(this);
+				this.channel = environmentOverrides?.channel ?? UniversalStore.preparation.channel;
+				this.environment = environmentOverrides?.environment ?? UniversalStore.preparation.environment;
+				if (this.channel && this.environment) {
+					if (!environmentOverrides) UniversalStore.preparation.resolve({
+						channel: this.channel,
+						environment: this.environment
+					});
+					this.prepareThis({
+						channel: this.channel,
+						environment: this.environment
+					});
+				} else UniversalStore.preparation.promise.then(this.prepareThis);
+			}
+			/** Creates a new instance of UniversalStore */
+			static create(options) {
+				if (!options || typeof options?.id !== "string") throw new TypeError("id is required and must be a string, when creating a UniversalStore");
+				if (!isFirstPartyStoreId(options.id)) throw new TypeError(`UniversalStore is internal to Forkbook and cannot create a store with id "${options.id}"`);
+				if (options.debug) console.debug(dedent`[UniversalStore]
+        create`, { options });
+				const existing = instances.get(options.id);
+				if (existing) {
+					console.warn(dedent`UniversalStore with id "${options.id}" already exists in this environment, re-using existing.
+        You should reuse the existing instance instead of trying to create a new one.`);
+					return existing;
+				}
+				UniversalStore.isInternalConstructing = true;
+				const store = new UniversalStore(options);
+				instances.set(options.id, store);
+				return store;
+			}
+			/**
+			* Used by Forkbook to set the channel for all instances of UniversalStore in the given
+			* environment.
+			*
+			* @internal
+			*/
+			static __prepare(channel, environment) {
+				UniversalStore.preparation.channel = channel;
+				UniversalStore.preparation.environment = environment;
+				UniversalStore.preparation.resolve({
+					channel,
+					environment
+				});
+			}
+			/**
+			* Updates the store's state
+			*
+			* Either a new state or a state updater function can be passed to the method.
+			*/
+			setState(updater) {
+				const previousState = this.state;
+				const newState = typeof updater === "function" ? updater(previousState) : updater;
+				this.debug("setState", {
+					newState,
+					previousState,
+					updater
+				});
+				if (this.status !== UniversalStore.Status.READY) throw new TypeError(dedent`Cannot set state before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify({
+					newState,
+					id: this.id,
+					actor: this.actor,
+					environment: this.environment
+				}, null, 2)}`);
+				this.state = newState;
+				const event = {
+					type: UniversalStore.InternalEventType.SET_STATE,
+					payload: {
+						state: newState,
+						previousState
+					}
+				};
+				this.emitToChannel(event, { actor: this.actor });
+				this.emitToListeners(event, { actor: this.actor });
+			}
+			/**
+			* Subscribes to state changes
+			*
+			* @returns Unsubscribe function
+			*/
+			onStateChange(listener) {
+				this.debug("onStateChange", { listener });
+				return this.subscribe(UniversalStore.InternalEventType.SET_STATE, ({ payload }, eventInfo) => {
+					listener(payload.state, payload.previousState, eventInfo);
+				});
+			}
+			emitToChannel(event, eventInfo) {
+				this.debug("emitToChannel", {
+					event,
+					eventInfo,
+					channel: !!this.channel
+				});
+				this.channel?.emit(this.channelEventName, {
+					event,
+					eventInfo
+				});
+			}
+			prepareThis({ channel, environment }) {
+				this.channel = channel;
+				this.environment = environment;
+				this.debug("prepared", {
+					channel: !!channel,
+					environment
+				});
+				this.channel.on(this.channelEventName, this.handleChannelEvents);
+				if (this.actor.type === UniversalStore.ActorType.LEADER) this.emitToChannel({ type: UniversalStore.InternalEventType.LEADER_CREATED }, { actor: this.actor });
+				else {
+					this.emitToChannel({ type: UniversalStore.InternalEventType.FOLLOWER_CREATED }, { actor: this.actor });
+					this.emitToChannel({ type: UniversalStore.InternalEventType.EXISTING_STATE_REQUEST }, { actor: this.actor });
+					setTimeout(() => {
+						this.syncing.reject(new UniversalStoreFollowerTimeoutError(this.id));
+					}, 1e3);
+				}
+			}
+			emitToListeners(event, eventInfo) {
+				const eventTypeListeners = this.listeners.get(event.type);
+				const everythingListeners = this.listeners.get("*");
+				this.debug("emitToListeners", {
+					event,
+					eventInfo,
+					eventTypeListeners,
+					everythingListeners
+				});
+				[...eventTypeListeners ?? [], ...everythingListeners ?? []].forEach((listener) => listener(event, eventInfo));
+			}
+			handleChannelEvents(channelEvent) {
+				const { event, eventInfo } = channelEvent;
+				if ([eventInfo.actor.id, eventInfo.forwardingActor?.id].includes(this.actor.id)) {
+					this.debug("handleChannelEvents: Ignoring event from self", { channelEvent });
+					return;
+				} else if (this.syncing?.state === ProgressState.PENDING && event.type !== UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE) {
+					this.debug("handleChannelEvents: Ignoring event while syncing", { channelEvent });
+					return;
+				}
+				this.debug("handleChannelEvents", { channelEvent });
+				if (this.actor.type === UniversalStore.ActorType.LEADER) {
+					let shouldForwardEvent = true;
+					switch (event.type) {
+						case UniversalStore.InternalEventType.EXISTING_STATE_REQUEST:
+							shouldForwardEvent = false;
+							const responseEvent = {
+								type: UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE,
+								payload: this.state
+							};
+							this.debug("handleChannelEvents: responding to existing state request", { responseEvent });
+							this.emitToChannel(responseEvent, { actor: this.actor });
+							this.emitToListeners(responseEvent, { actor: this.actor });
+							break;
+						case UniversalStore.InternalEventType.LEADER_CREATED:
+							shouldForwardEvent = false;
+							this.syncing.state = ProgressState.REJECTED;
+							this.debug("handleChannelEvents: erroring due to second leader being created", { event });
+							console.error(dedent`Detected multiple UniversalStore leaders created with the same id "${this.id}".
+            Only one leader can exists at a time, your stores are now in an invalid state.
+            Leaders detected:
+            this: ${JSON.stringify(this.actor, null, 2)}
+            other: ${JSON.stringify(eventInfo.actor, null, 2)}`);
+					}
+					if (shouldForwardEvent) {
+						this.debug("handleChannelEvents: forwarding event", { channelEvent });
+						this.emitToChannel(event, {
+							actor: eventInfo.actor,
+							forwardingActor: this.actor
+						});
+					}
+				}
+				if (this.actor.type === UniversalStore.ActorType.FOLLOWER) switch (event.type) {
+					case UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE:
+						this.debug("handleChannelEvents: Setting state from leader's existing state response", { event });
+						if (this.syncing?.state !== ProgressState.PENDING) break;
+						this.syncing.resolve?.();
+						const setStateEvent = {
+							type: UniversalStore.InternalEventType.SET_STATE,
+							payload: {
+								state: event.payload,
+								previousState: this.state
+							}
+						};
+						this.state = event.payload;
+						this.emitToListeners(setStateEvent, eventInfo);
+				}
+				switch (event.type) {
+					case UniversalStore.InternalEventType.SET_STATE:
+						this.debug("handleChannelEvents: Setting state", { event });
+						this.state = event.payload.state;
+				}
+				this.emitToListeners(event, { actor: eventInfo.actor });
+			}
+			debug(message, data) {
+				if (this.debugging) console.debug(dedent`[UniversalStore::${this.id}::${this.environment ?? UniversalStore.Environment.UNKNOWN}]
+        ${message}`, JSON.stringify({
+					data,
+					actor: this.actor,
+					state: this.state,
+					status: this.status
+				}, null, 2));
+			}
+			/**
+			* Used to reset the static fields of the UniversalStore class when cleaning up tests
+			*
+			* @internal
+			*/
+			static __reset() {
+				UniversalStore.preparation.reject(/* @__PURE__ */ new Error("reset"));
+				UniversalStore.setupPreparationPromise();
+				UniversalStore.isInternalConstructing = false;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/utils/local-hosts.ts
+var LOOPBACK_HOSTNAMES, matchesHostname;
+function init_local_hosts() {
+	return (init_local_hosts = __esmMin((() => {
+		LOOPBACK_HOSTNAMES = [
+			"localhost",
+			"*.localhost",
+			"127.0.0.1"
+		];
+		matchesHostname = (hostname, patterns) => patterns.some((pattern) => pattern.startsWith("*.") ? hostname.endsWith(pattern.slice(1)) : hostname === pattern);
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/errors.ts
+/**
+* Formats a schema issue path into the field notation shown in validation errors.
+*
+* Examples:
+* - `['foo']` -> `foo`
+* - `['items', 0, 'id']` -> `items[0].id`
+*/
+function formatIssuePath(path) {
+	if (!path?.length) return "";
+	return path.map((segment) => {
+		const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+		return typeof key === "number" ? `[${key}]` : `.${String(key)}`;
+	}).join("").replace(/^\./, "");
+}
+/**
+* Converts schema issues into the newline-separated detail block appended to user-facing errors.
+*/
+function formatIssues(issues) {
+	return issues.map((issue) => {
+		const path = formatIssuePath(issue.path);
+		return path === "" ? issue.message : `${path}: ${issue.message}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/server-errors.ts
+var OpenServiceValidationError, OpenServiceMissingServiceError, OpenServiceInternalServiceError, OpenServiceUnimplementedOperationError, OpenServiceInvalidStaticPathError, OpenServiceAsyncSchemaError, OpenServiceLoadedDrainExceededError, OpenServiceMissingChannelError, OpenServiceRemoteCommandDisconnectedError, OpenServiceRemoteCommandUnhandledError, OpenServiceRemoteCommandConfigDriftError, OpenServiceAsyncRecipeError, OpenServiceCyclicStateError, OpenServiceOperationNameCollisionError;
+function init_server_errors() {
+	return (init_server_errors = __esmMin((() => {
+		init_storybook_error();
+		OpenServiceValidationError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceValidationError",
+					category: "CORE-COMMON",
+					code: 5,
+					message: `Invalid ${data.phase} for ${data.kind} "${data.serviceId}.${data.name}":\n${formatIssues(data.issues)}`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceMissingServiceError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceMissingServiceError",
+					category: "CORE-COMMON",
+					code: 7,
+					message: `No registered service with id "${data.serviceId}" exists in this environment.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceInternalServiceError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceInternalServiceError",
+					category: "CORE-COMMON",
+					code: 19,
+					message: `Service "${data.serviceId}" is internal. Pass { internal: true } to getService() only if you intentionally depend on an unstable OSA surface. Internal services may change without notice.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceUnimplementedOperationError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceUnimplementedOperationError",
+					category: "CORE-COMMON",
+					code: 8,
+					message: `${data.kind[0].toUpperCase()}${data.kind.slice(1)} "${data.serviceId}.${data.name}" is not implemented for this environment.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceInvalidStaticPathError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceInvalidStaticPathError",
+					category: "CORE-COMMON",
+					code: 10,
+					message: `Invalid static path "${data.path}" for query "${data.serviceId}.${data.name}": use a relative path with forward slashes and no ".." segments.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceAsyncSchemaError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceAsyncSchemaError",
+					category: "CORE-COMMON",
+					code: 9,
+					message: `Async schema for ${data.kind} "${data.serviceId}.${data.name}" (${data.phase}): query input and output schemas must validate synchronously.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceLoadedDrainExceededError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceLoadedDrainExceededError",
+					category: "CORE-COMMON",
+					code: 11,
+					message: `Query "${data.serviceId}.${data.name}".loaded(...) did not settle after ${data.iterations} drain iterations. Check for handlers that keep discovering new dependencies after every state change.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceMissingChannelError = class extends StorybookError {
+			constructor(data = {}) {
+				super({
+					name: "OpenServiceMissingChannelError",
+					category: "CORE-COMMON",
+					code: 13,
+					message: data.serviceId ? `Cannot register service "${data.serviceId}": the Forkbook addons channel is not installed in this runtime.` : "The Forkbook addons channel is not installed in this runtime."
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceRemoteCommandDisconnectedError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceRemoteCommandDisconnectedError",
+					category: "CORE-COMMON",
+					code: 14,
+					message: `Service "${data.serviceId}" was unregistered before a remote command resolved.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceRemoteCommandUnhandledError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceRemoteCommandUnhandledError",
+					category: "CORE-COMMON",
+					code: 15,
+					message: data.delegated ? `The Forkbook this runtime is attached to did not acknowledge remote command "${data.serviceId}.${data.commandName}" in time — it may be busy or unreachable. Retry; note the command may still have executed on that instance.` : `No runtime acknowledged remote command "${data.serviceId}.${data.commandName}"; its handler is not implemented in any connected runtime.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceRemoteCommandConfigDriftError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceRemoteCommandConfigDriftError",
+					category: "CORE-COMMON",
+					code: 30,
+					message: `The Forkbook this runtime is attached to reported it has no handler for remote command "${data.serviceId}.${data.commandName}". The two processes are running different configurations (for example a feature flag enabled in one but not the other). Restart the attached Forkbook with a configuration matching this process.`
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceAsyncRecipeError = class extends StorybookError {
+			constructor() {
+				super({
+					name: "OpenServiceAsyncRecipeError",
+					category: "CORE-COMMON",
+					code: 31,
+					message: "setState recipes must be synchronous. A write after an await would change state without authoring a sync entry. Split the command into one setState per synchronous step."
+				});
+			}
+		};
+		OpenServiceCyclicStateError = class extends StorybookError {
+			constructor() {
+				super({
+					name: "OpenServiceCyclicStateError",
+					category: "CORE-COMMON",
+					code: 32,
+					message: "Service state must be JSON-serializable, but the value is cyclic or nested more than 256 levels deep. Store an id and look the value up in a query instead of a reference."
+				});
+			}
+		};
+		OpenServiceOperationNameCollisionError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceOperationNameCollisionError",
+					category: "CORE-COMMON",
+					code: 16,
+					message: `Service "${data.serviceId}" cannot register "${data.operationName}" as both a query and a command.`
+				});
+				this.data = data;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/status-store/index.ts
+var CHANGE_DETECTION_STATUS_TYPE_ID, REVIEW_STATUS_TYPE_ID, NON_AGGREGATED_STATUS_TYPE_IDS;
+function init_status_store() {
+	return (init_status_store = __esmMin((() => {
+		CHANGE_DETECTION_STATUS_TYPE_ID = "@aussieljk/forkbook/change-detection";
+		REVIEW_STATUS_TYPE_ID = "@aussieljk/forkbook/review";
+		NON_AGGREGATED_STATUS_TYPE_IDS = [CHANGE_DETECTION_STATUS_TYPE_ID, REVIEW_STATUS_TYPE_ID];
+	})))();
+}
+//#endregion
+//#region src/shared/review/events.ts
+var REVIEW_NAMESPACE, REVIEW_EVENTS;
+function init_events() {
+	return (init_events = __esmMin((() => {
+		REVIEW_NAMESPACE = "@aussieljk/forkbook/review";
+		REVIEW_EVENTS = { PAGEVIEW: `${REVIEW_NAMESPACE}/pageview` };
+	})))();
+}
+//#endregion
+//#region src/shared/constants/tags.ts
+var Tag;
+function init_tags() {
+	return (init_tags = __esmMin((() => {
+		Tag = {
+			/** Indicates that autodocs should be generated for this component */
+			AUTODOCS: "autodocs",
+			/** MDX documentation attached to a component's stories file */
+			ATTACHED_MDX: "attached-mdx",
+			/** Standalone MDX documentation not attached to stories */
+			UNATTACHED_MDX: "unattached-mdx",
+			/** Story has a play function */
+			PLAY_FN: "play-fn",
+			/** Story has a test function */
+			TEST_FN: "test-fn",
+			/** Development environment tag */
+			DEV: "dev",
+			/** Test environment tag */
+			TEST: "test",
+			/** Manifest generation tag */
+			MANIFEST: "manifest"
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/plain-object.ts
+function isReservedKey(key) {
+	return FORBIDDEN_KEYS.has(key) || key.startsWith("$");
+}
+function hasOwn(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Deep-copies a JSON-shaped value, giving every path its own object.
+*
+* Used for every value on its way into service state: a definition's `initialState`, an object
+* assigned inside a `setState` recipe, and the value carried by a recorded op.
+*
+* Not `structuredClone`. That keeps a reference shared between two keys as one object, so a write
+* through one key would also change the other on the writing runtime, while peers, who only ever
+* receive JSON, would see one path change. Rebuilding key by key removes the alias on both sides.
+* It also accepts proxies and drops the prototype-pollution keys in {@link FORBIDDEN_KEYS} and
+* deepsignal's `$`-prefixed accessor keys. A cyclic value throws {@link OpenServiceCyclicStateError},
+* since it could never be serialized for peers; the check is a depth limit, which costs nothing per
+* node. An `undefined` property is dropped, as JSON drops it, so the author and peers agree on which
+* keys exist.
+*
+* Only own enumerable string keys are copied. Class instances, `Map`, `Set`, and `Date` become plain
+* objects, which matches the JSON-serializable contract service state already has.
+*/
+function clonePlain(value, depth = 0) {
+	if (value === null || typeof value !== "object") return value;
+	if (depth > MAX_DEPTH) throw new OpenServiceCyclicStateError();
+	if (Array.isArray(value)) return value.map((entry) => clonePlain(entry, depth + 1));
+	const copy = {};
+	for (const key of Object.keys(value)) {
+		const entry = value[key];
+		if (isReservedKey(key) || entry === void 0) continue;
+		copy[key] = clonePlain(entry, depth + 1);
+	}
+	return copy;
+}
+var FORBIDDEN_KEYS, MAX_DEPTH;
+function init_plain_object() {
+	return (init_plain_object = __esmMin((() => {
+		init_server_errors();
+		FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+			"__proto__",
+			"constructor",
+			"prototype"
+		]);
+		MAX_DEPTH = 256;
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-channel.ts
+function decodeSegment(encoded) {
+	return encoded.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+/** RFC 6901 JSON Pointer: `~0` encodes `~`, `~1` encodes `/`; no segments is the root pointer `''`. */
+function encodePointer(segments) {
+	return segments.map((segment) => `/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+}
+/** Inverse of {@link encodePointer}. `pointer` must be empty or start with `/`. */
+function decodePointer(pointer) {
+	if (pointer === "") return [];
+	return pointer.slice(1).split("/").map(decodeSegment);
+}
+function isRfc6901Pointer(pointer) {
+	if (!pointer.startsWith("/")) return false;
+	return pointer.slice(1).split("/").every((encoded) => {
+		return RFC_6901_ENCODED_SEGMENT.test(encoded) && !isReservedKey(decodeSegment(encoded));
+	});
+}
+/** Canonical log key and warning label: `seq:runtimeId:counter`. */
+function entryStampKey(stamp) {
+	return `${stamp.seq}:${stamp.runtimeId}:${stamp.counter}`;
+}
+/**
+* Unique id for one service registration.
+*
+* It is the loop guard that drops a runtime's own `services:sync-request`. `nanoid` is used (over
+* `Math.random`) so collisions cannot silently break that determinism.
+*/
+function generateRuntimeId() {
+	return nanoid();
+}
+/** Unique id for one remote-command invocation. Replies correlate on this, not on `runtimeId`. */
+function generateCallId() {
+	return nanoid();
+}
+var SERVICE_SYNC_REQUEST, SERVICE_SYNC_REPLY, SERVICE_ENTRY, SERVICE_COMMAND_INVOKE, SERVICE_COMMAND_ACK, SERVICE_COMMAND_RESULT, SERVICE_COMMAND_ERROR, SERVICE_COMMAND_UNHANDLED, stateSnapshotSchema, nonNegativeSafeInteger, positiveSafeInteger, RFC_6901_ENCODED_SEGMENT, jsonPointerSchema, jsonPatchOperationSchema, entryStampSchema, entrySchema, frontierSchema, syncRequestSchema, syncReplySchema, commandInvokeSchema, commandAckSchema, commandUnhandledSchema, commandResultSchema, commandErrorSchema;
+function init_service_channel() {
+	return (init_service_channel = __esmMin((() => {
+		init_index_browser();
+		init_dist();
+		init_plain_object();
+		SERVICE_SYNC_REQUEST = "services:sync-request";
+		SERVICE_SYNC_REPLY = "services:sync-reply";
+		SERVICE_ENTRY = "services:entry";
+		SERVICE_COMMAND_INVOKE = "services:command-invoke";
+		SERVICE_COMMAND_ACK = "services:command-ack";
+		SERVICE_COMMAND_RESULT = "services:command-result";
+		SERVICE_COMMAND_ERROR = "services:command-error";
+		SERVICE_COMMAND_UNHANDLED = "services:command-unhandled";
+		stateSnapshotSchema = custom(isPlainObject$1);
+		nonNegativeSafeInteger = pipe(number(), safeInteger(), minValue(0));
+		positiveSafeInteger = pipe(number(), safeInteger(), minValue(1));
+		RFC_6901_ENCODED_SEGMENT = /^(?:[^~]|~[01])*$/;
+		jsonPointerSchema = pipe(string(), check(isRfc6901Pointer));
+		jsonPatchOperationSchema = variant("op", [
+			object({
+				op: literal("add"),
+				path: jsonPointerSchema,
+				value: unknown()
+			}),
+			object({
+				op: literal("replace"),
+				path: jsonPointerSchema,
+				value: unknown()
+			}),
+			object({
+				op: literal("remove"),
+				path: jsonPointerSchema
+			})
+		]);
+		entryStampSchema = object({
+			seq: positiveSafeInteger,
+			runtimeId: string(),
+			counter: positiveSafeInteger
+		});
+		entrySchema = object({
+			serviceId: string(),
+			stamp: entryStampSchema,
+			command: string(),
+			patch: pipe(array(jsonPatchOperationSchema), minLength(1))
+		});
+		frontierSchema = object({
+			vector: record(string(), nonNegativeSafeInteger),
+			clock: nonNegativeSafeInteger
+		});
+		syncRequestSchema = object({
+			serviceId: string(),
+			runtimeId: string(),
+			frontier: frontierSchema
+		});
+		syncReplySchema = object({
+			serviceId: string(),
+			runtimeId: string(),
+			frontier: frontierSchema,
+			state: stateSnapshotSchema
+		});
+		commandInvokeSchema = object({
+			serviceId: string(),
+			commandName: string(),
+			input: optional(unknown()),
+			callId: string(),
+			runtimeId: string()
+		});
+		commandAckSchema = object({
+			serviceId: string(),
+			callId: string(),
+			runtimeId: string()
+		});
+		commandUnhandledSchema = object({
+			serviceId: string(),
+			callId: string()
+		});
+		commandResultSchema = object({
+			serviceId: string(),
+			callId: string(),
+			result: optional(unknown()),
+			runtimeId: string()
+		});
+		commandErrorSchema = object({
+			serviceId: string(),
+			callId: string(),
+			error: custom((value) => typeof value === "object" && value !== null && !Array.isArray(value)),
+			runtimeId: string()
+		});
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/patch-recorder.ts
+function peekProp(obj, key) {
+	return g(obj, key);
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "object";
+}
+function ownValue(inner, name) {
+	const existed = hasOwn(inner, name);
+	return {
+		existed,
+		firstValue: existed ? clonePlain(peekProp(inner, name)) : void 0
+	};
+}
+function readPath(root, segments) {
+	let current = root;
+	for (const segment of segments) {
+		if (current === null || typeof current !== "object") return {
+			found: false,
+			value: void 0
+		};
+		if (!hasOwn(current, segment)) return {
+			found: false,
+			value: void 0
+		};
+		current = peekProp(current, segment);
+	}
+	return {
+		found: true,
+		value: current
+	};
+}
+/**
+* Runs `mutate` against `state` through a recording proxy and passes the resulting RFC 6902 ops to
+* `author`.
+*
+* `author` runs even when the recipe throws, with the paths written before the throw, and the
+* throw then propagates. A recipe that changes nothing does not call `author`. A call made inside
+* another recipe on the same state writes into that recipe's draft, so its writes join that entry.
+*/
+function recordPatch(state, mutate, author) {
+	const activeDraft = activeDrafts.get(state);
+	if (activeDraft) {
+		const nested = mutate(activeDraft);
+		if (isThenable(nested)) {
+			Promise.resolve(nested).catch(() => {});
+			throw new OpenServiceAsyncRecipeError();
+		}
+		return;
+	}
+	const root = state;
+	const touches = /* @__PURE__ */ new Map();
+	const order = [];
+	const wrapperByTarget = /* @__PURE__ */ new WeakMap();
+	const targetByWrapper = /* @__PURE__ */ new WeakMap();
+	const revokes = [];
+	const preRecipeValue = (segments) => {
+		const { found, value } = readPath(root, segments);
+		if (!found) return {
+			existed: false,
+			firstValue: void 0
+		};
+		const snapshot = clonePlain(value);
+		const prefix = encodePointer(segments);
+		for (const pointer of order.toReversed()) {
+			if (!pointer.startsWith(`${prefix}/`)) continue;
+			const descendant = touches.get(pointer);
+			let parent = snapshot;
+			const relative = descendant.segments.slice(segments.length);
+			for (const segment of relative.slice(0, -1)) parent = parent !== null && typeof parent === "object" ? parent[segment] : void 0;
+			if (parent === null || typeof parent !== "object") continue;
+			const key = relative[relative.length - 1];
+			if (descendant.existed) parent[key] = clonePlain(descendant.firstValue);
+			else delete parent[key];
+		}
+		return {
+			existed: true,
+			firstValue: snapshot
+		};
+	};
+	const note = (segments, capture) => {
+		const pointer = encodePointer(segments);
+		if (touches.has(pointer)) return;
+		const prefix = `${pointer}/`;
+		const subsumesEarlierTouch = order.some((recorded) => recorded.startsWith(prefix));
+		touches.set(pointer, {
+			segments,
+			...subsumesEarlierTouch ? preRecipeValue(segments) : capture()
+		});
+		order.push(pointer);
+	};
+	const noteArray = (arrayRoot) => {
+		note(arrayRoot.path, () => ({
+			existed: true,
+			firstValue: clonePlain(arrayRoot.target)
+		}));
+	};
+	const storedValue = (value) => {
+		if (value === null || typeof value !== "object") return value;
+		return clonePlain(targetByWrapper.get(value) ?? value);
+	};
+	const isUnchangedAssignment = (inner, name, value) => {
+		if (!hasOwn(inner, name)) return false;
+		if (Object.is(peekProp(inner, name), value)) return true;
+		if (value !== null && typeof value === "object") {
+			const target = targetByWrapper.get(value);
+			return target !== void 0 && Object.is(Reflect.get(inner, name), target);
+		}
+		return false;
+	};
+	const wrap = (target, path, arrayRoot) => {
+		const cached = wrapperByTarget.get(target);
+		if (cached) return cached;
+		const effectiveArrayRoot = arrayRoot ?? (Array.isArray(target) ? {
+			path,
+			target
+		} : null);
+		const { proxy, revoke } = Proxy.revocable(target, {
+			get(inner, key) {
+				if (typeof key === "symbol") return Reflect.get(inner, key);
+				if (FORBIDDEN_KEYS.has(key) || key.startsWith("$")) return;
+				const value = Reflect.get(inner, key);
+				if (typeof value === "function") return value;
+				if (value !== null && typeof value === "object") return wrap(value, path.concat(String(key)), effectiveArrayRoot);
+				return value;
+			},
+			set(inner, key, value) {
+				if (typeof key === "symbol") return Reflect.set(inner, key, value);
+				const name = String(key);
+				if (FORBIDDEN_KEYS.has(name)) return true;
+				if (name.startsWith("$")) {
+					const plain = name.slice(1);
+					if (FORBIDDEN_KEYS.has(plain)) return true;
+					note(path.concat(plain), () => ownValue(inner, plain));
+					return Reflect.set(inner, key, value);
+				}
+				if (isUnchangedAssignment(inner, name, value)) return true;
+				if (effectiveArrayRoot) {
+					noteArray(effectiveArrayRoot);
+					return Reflect.set(inner, name, storedValue(value));
+				}
+				const segments = path.concat(name);
+				if (value === void 0) {
+					if (hasOwn(inner, name)) {
+						note(segments, () => ownValue(inner, name));
+						return Reflect.deleteProperty(inner, name);
+					}
+					return true;
+				}
+				note(segments, () => ownValue(inner, name));
+				return Reflect.set(inner, name, storedValue(value));
+			},
+			deleteProperty(inner, key) {
+				if (typeof key === "symbol") return Reflect.deleteProperty(inner, key);
+				const name = String(key);
+				if (FORBIDDEN_KEYS.has(name)) return true;
+				if (name.startsWith("$")) return Reflect.deleteProperty(inner, key);
+				if (!hasOwn(inner, name)) return true;
+				if (effectiveArrayRoot) {
+					noteArray(effectiveArrayRoot);
+					return Reflect.deleteProperty(inner, name);
+				}
+				note(path.concat(name), () => ownValue(inner, name));
+				return Reflect.deleteProperty(inner, name);
+			}
+		});
+		revokes.push(revoke);
+		wrapperByTarget.set(target, proxy);
+		targetByWrapper.set(proxy, target);
+		return proxy;
+	};
+	const flush = () => {
+		const touched = new Set(order);
+		const ops = [];
+		const inverse = [];
+		for (const pointer of order) {
+			const touch = touches.get(pointer);
+			if (touch.segments.some((_, index) => {
+				if (index === 0) return false;
+				return touched.has(encodePointer(touch.segments.slice(0, index)));
+			})) continue;
+			const { found, value } = readPath(root, touch.segments);
+			if (!found) {
+				if (touch.existed) {
+					ops.push({
+						op: "remove",
+						path: pointer
+					});
+					inverse.push({
+						op: "add",
+						path: pointer,
+						value: touch.firstValue
+					});
+				}
+				continue;
+			}
+			if (isPrimitive(value) && Object.is(value, touch.firstValue)) continue;
+			ops.push({
+				op: touch.existed ? "replace" : "add",
+				path: pointer,
+				value: clonePlain(value)
+			});
+			inverse.push(touch.existed ? {
+				op: "replace",
+				path: pointer,
+				value: touch.firstValue
+			} : {
+				op: "remove",
+				path: pointer
+			});
+		}
+		return {
+			ops,
+			inverse
+		};
+	};
+	n(() => {
+		f(() => {
+			const draft = wrap(state, [], null);
+			activeDrafts.set(state, draft);
+			try {
+				const result = mutate(draft);
+				if (isThenable(result)) {
+					Promise.resolve(result).catch(() => {});
+					throw new OpenServiceAsyncRecipeError();
+				}
+			} finally {
+				activeDrafts.delete(state);
+				for (const revoke of revokes) revoke();
+				const recorded = flush();
+				if (recorded.ops.length > 0) author(recorded);
+			}
+		});
+	});
+}
+function isThenable(value) {
+	return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+var activeDrafts;
+function init_patch_recorder() {
+	return (init_patch_recorder = __esmMin((() => {
+		init_signals_core_module();
+		init_deepsignal_core_module();
+		init_server_errors();
+		init_plain_object();
+		init_service_channel();
+		activeDrafts = /* @__PURE__ */ new WeakMap();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/query-state.ts
+/**
+* Expands a `(data, lifecycle)` pair into the full {@link QueryState} surfaced to subscribers.
+*
+* The single source of truth for the derived booleans, shared by the runtime's subscription
+* emissions and `useServiceQuery`'s first-render seed so they can never drift apart. The booleans
+* intentionally follow our `load` vocabulary: `isLoading` is "any load in flight" (TanStack's
+* `isFetching`) and `isInitialLoading` is "the first load with nothing to show yet".
+*
+* Unlike TanStack Query, a subscription here can attach to a query whose `data` is already cached in
+* service state (e.g. revisiting an already-extracted component): its per-subscription lifecycle
+* still starts `pending`/`loading`, but `data` is present from the first emission. `isInitialLoading`
+* therefore also requires `data === undefined`, so consumers gate a "nothing yet" skeleton on it
+* without flashing it over already-available data while a background (re)load runs.
+*/
+function buildQueryState(data, lifecycle) {
+	const isPending = lifecycle.status === "pending";
+	const isLoading = lifecycle.loadStatus === "loading";
+	return {
+		data,
+		error: lifecycle.error,
+		status: lifecycle.status,
+		loadStatus: lifecycle.loadStatus,
+		isPending,
+		isSuccess: lifecycle.status === "success",
+		isError: lifecycle.status === "error",
+		isLoading,
+		isInitialLoading: isPending && isLoading && data === void 0,
+		isRefreshing: isLoading && !isPending
+	};
+}
+/** Coerces an unknown thrown value into an `Error` for the `error` field of a {@link QueryState}. */
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+//#endregion
+//#region src/shared/open-service/service-validation.ts
+/**
+* Re-throws asynchronous subscription failures on the microtask queue so they are not silently
+* swallowed by promise chains started from reactive listeners.
+*/
+function rethrowAsync(error) {
+	queueMicrotask(() => {
+		throw error;
+	});
+}
+/**
+* Validates a value with a Standard Schema and returns the parsed output value.
+*
+* Any schema issues are wrapped in `OpenServiceValidationError`, which standardizes the operation
+* metadata while preserving the schema's own expectation text for the actionable details.
+*/
+async function validateSchema(schema, value, meta) {
+	const validationResult = await schema["~standard"].validate(value);
+	if (validationResult.issues) throw new OpenServiceValidationError({
+		...meta,
+		issues: validationResult.issues
+	});
+	return validationResult.value;
+}
+/**
+* Synchronous variant of `validateSchema` used on the sync query call path.
+*
+* Query input and output schemas must produce sync validation results so the public `query(input)`
+* function can return a value immediately. If a schema accidentally returns a Promise, the runtime
+* surfaces a dedicated error instead of silently switching to async behavior.
+*/
+function validateSchemaSync(schema, value, meta) {
+	const validationResult = schema["~standard"].validate(value);
+	if (validationResult instanceof Promise) throw new OpenServiceAsyncSchemaError({
+		kind: meta.kind,
+		serviceId: meta.serviceId,
+		name: meta.name,
+		phase: meta.phase
+	});
+	if (validationResult.issues) throw new OpenServiceValidationError({
+		...meta,
+		issues: validationResult.issues
+	});
+	return validationResult.value;
+}
+function init_service_validation() {
+	return (init_service_validation = __esmMin((() => {
+		init_server_errors();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/query-runtime.ts
+/**
+* Returns a deterministic JSON encoding so the same logical input always produces the same key.
+*
+* Object keys are sorted recursively so `{a:1, b:2}` and `{b:2, a:1}` hash identically. Inputs are
+* expected to be JSON-safe; non-serializable values like `Date`, `Map`, or functions fall back to
+* `JSON.stringify`'s defaults and may produce ambiguous keys.
+*/
+function stableHash(value) {
+	const encode = (raw) => {
+		if (raw === void 0) return { __t: "undefined" };
+		if (raw === null || typeof raw !== "object") return raw;
+		if (Array.isArray(raw)) return raw.map(encode);
+		const sorted = {};
+		for (const k of Object.keys(raw).sort()) sorted[k] = encode(raw[k]);
+		return {
+			__t: "object",
+			value: sorted
+		};
+	};
+	return JSON.stringify(encode(value));
+}
+/**
+* Scopes a load key to one runtime instance for {@link inFlightLoads}.
+*
+* The unscoped {@link makeLoadKey} stays the identity used for cycle detection and settled-key
+* bookkeeping, which are per-load-graph rather than per-runtime.
+*/
+function makeInFlightKey(loadScopeId, loadKey) {
+	return `${loadScopeId}::${loadKey}`;
+}
+function makeLoadKey(serviceId, queryName, validatedInput) {
+	return `${serviceId}::${queryName}::${stableHash(validatedInput)}`;
+}
+/**
+* Surfaces the first rejected settlement as the thrown error, aggregating the rest under `cause`.
+*
+* Drainers use `Promise.allSettled` so one rejected dependency does not prevent siblings from
+* finishing their work; this helper preserves all rejections without losing the primary one.
+*/
+function surfaceRejections(settlements) {
+	const rejections = settlements.filter((s) => s.status === "rejected");
+	if (rejections.length === 0) return;
+	const [first, ...rest] = rejections.map((r) => r.reason);
+	if (rest.length > 0) {
+		if (first instanceof Error) {
+			if (Reflect.get(first, "cause") === void 0) try {
+				Reflect.set(first, "cause", { aggregated: rest });
+			} catch {}
+		}
+	}
+	throw first;
+}
+/**
+* Drains a collector of pending load promises until no new entries appear.
+*
+* Each iteration snapshots the current entries, clears the collector, awaits them with
+* `Promise.allSettled`, marks their keys as settled (for caller bookkeeping), then loops if the
+* settled loads' bodies surfaced more entries. Caps at `MAX_DRAIN_ITERATIONS` to avoid hanging on
+* pathological oscillation.
+*/
+async function drainCollector(collector, settledKeys, serviceId, queryName) {
+	let iterations = 0;
+	while (collector.size > 0) {
+		if (iterations++ > MAX_DRAIN_ITERATIONS) throw new OpenServiceLoadedDrainExceededError({
+			serviceId,
+			name: queryName,
+			iterations: MAX_DRAIN_ITERATIONS
+		});
+		const pending = [...collector];
+		collector.clear();
+		const settlements = await Promise.allSettled(pending.map((entry) => entry.promise));
+		if (settledKeys) for (const entry of pending) settledKeys.add(entry.key);
+		surfaceRejections(settlements);
+	}
+}
+/**
+* Detaches a value from the reactive deep-signal proxy into a plain snapshot.
+*
+* Used for `selector` results on the subscription path: a selector can return a live proxy slice,
+* which we strip so consumers get plain, comparable data (and reads inside the `computed` register
+* only the fields the selector actually touched). Primitives pass through untouched.
+*
+* `structuredClone` cannot clone a `Proxy`, so this uses a JSON round-trip. That is sufficient
+* because open-service state is required to be JSON-serializable (the same constraint the
+* static-build pipeline relies on). For plain (already-detached) values such as the whole-state
+* snapshot, the runtime uses `structuredClone` directly instead.
+*/
+function detachSnapshot(value) {
+	if (value === null || typeof value !== "object") return value;
+	return JSON.parse(JSON.stringify(value));
+}
+/**
+* Validates query input synchronously, falling through to the dedicated async-schema error if a
+* schema returns a Promise.
+*/
+function validateQueryInput(refs, queryName, queryDef, input) {
+	return validateSchemaSync(queryDef.input, input, {
+		kind: "query",
+		serviceId: refs.serviceId,
+		name: queryName,
+		phase: "input"
+	});
+}
+function validateQueryOutput(refs, queryName, queryDef, output) {
+	return validateSchemaSync(queryDef.output, output, {
+		kind: "query",
+		serviceId: refs.serviceId,
+		name: queryName,
+		phase: "output"
+	});
+}
+/**
+* Runs the query handler synchronously and returns its raw result (no output validation).
+*
+* The `selfQueries` parameter lets the caller swap in load-aware wrappers when running inside a
+* load body or a `.loaded()` discovery pass; ordinary handler calls pass the default queries.
+*/
+function runHandlerSync(refs, queryName, queryDef, validatedInput, selfQueries, getService) {
+	if (!queryDef.handler) throw new OpenServiceUnimplementedOperationError({
+		kind: "query",
+		serviceId: refs.serviceId,
+		name: queryName
+	});
+	const handlerCtx = {
+		self: {
+			get state() {
+				return refs.state;
+			},
+			queries: selfQueries
+		},
+		getService
+	};
+	return queryDef.handler(validatedInput, handlerCtx);
+}
+/**
+* Builds the shared synchronous `get(input)` for a query: validate input → fire the load per the
+* caller's policy → run the handler against `selfQueries` → validate output.
+*
+* The three query surfaces — the default consumer query ({@link createDefaultQuery}), the reactive
+* subscription-load wrappers ({@link buildReactiveLoadQueries}), and the awaited load-body wrappers
+* ({@link buildLoadWrappedQueries}) — differ only in (a) which `self.queries` map the handler sees
+* and (b) how a load-backed read fires its `load`. Everything else (the validate → run → validate
+* skeleton, the zero-arg input resolution) is identical, so each surface passes its own `selfQueries`
+* map and `fireLoad` policy and shares this body.
+*
+* `fireLoad` is invoked only for queries that declare a `load`; queries without one skip it. Pass
+* `selfQueries` by reference even when it is the same map being populated by the caller — `get`
+* closes over the reference, which is fully built by the time any handler runs.
+*/
+function createQueryGet(refs, queryName, queryDef, selfQueries, fireLoad) {
+	return function get(input) {
+		const validatedInput = validateQueryInput(refs, queryName, queryDef, arguments.length === 0 ? void 0 : input);
+		if (queryDef.load) fireLoad?.(validatedInput);
+		return validateQueryOutput(refs, queryName, queryDef, runHandlerSync(refs, queryName, queryDef, validatedInput, selfQueries, refs.registryApi.getService));
+	};
+}
+/**
+* Triggers a `load` if one is not already in flight for the same key, or returns the existing
+* promise so concurrent callers share the work.
+*
+* Returns the in-flight promise (whether newly created or reused). The body runs through
+* {@link runLoadBody} and its promise is registered into {@link inFlightLoads} **before** that
+* body starts; see the "register before run" comment below for why.
+*
+* ### Ancestor chain
+*
+* The parent caller passes its own ancestor chain (the load keys it is currently nested
+* inside). This function extends that chain with the dependency's own key before kicking off the
+* body, so any transitive read of an ancestor — e.g. `a.load` calls `b.load` which calls `a.load`
+* again — short-circuits via cycle detection in {@link createDefaultQuery} and
+* {@link buildLoadWrappedQueries}, rather than deadlocking on its own ancestor's promise.
+*
+* ### Cycle example
+*
+* Service exposes queries `a` and `b`; `a.load` reads `b`, `b.load` reads `a`.
+*
+* 1. `a.loaded()` → `triggerLoad(a, parentChain={})` → body runs with chain `{a}`.
+* 2. `a.load` body calls `ctx.self.queries.b.get(...)` → wrapper calls
+*    `triggerLoad(b, parentChain={a})` → body runs with chain `{a, b}`.
+* 3. `b.load` body calls `ctx.self.queries.a.get(...)` → wrapper calls
+*    `triggerLoad(a, parentChain={a, b})`. `a` is already in flight, so the existing promise is
+*    reused. But the wrapper sees `aKey ∈ ancestorChain` and **skips** adding it to b's local
+*    collector — `b` does not wait on `a`'s promise.
+* 4. Both load bodies progress past their sync reads, await their commands, settle.
+*/
+function triggerLoad(refs, queryName, queryDef, validatedInput, loadKey, parentAncestorChain) {
+	const inFlightKey = makeInFlightKey(refs.loadScopeId, loadKey);
+	const existing = inFlightLoads.get(inFlightKey);
+	if (existing) return existing;
+	const extendedChain = new Set(parentAncestorChain);
+	extendedChain.add(loadKey);
+	const promise = Promise.resolve().then(() => runLoadBody(refs, queryName, queryDef, validatedInput, extendedChain)).finally(() => {
+		if (inFlightLoads.get(inFlightKey) === promise) inFlightLoads.delete(inFlightKey);
+	});
+	inFlightLoads.set(inFlightKey, promise);
+	return promise;
+}
+/**
+* Executes one `load` invocation with its own local collector and a wrapped `self`.
+*
+* Each `load` invocation gets its **own** collector and its **own** map of wrapped queries. This
+* matters because the wrappers close over the collector and ancestor chain that belong to this
+* particular load — a different load running concurrently for a different key has a different
+* collector and a different chain, so the same `defaultQuery` cannot serve both.
+*
+* The wrapper around `self.queries` registers transitively triggered loads into the local
+* collector. After the user's load body resolves, we still await that collector via
+* {@link drainCollector} so the returned promise only resolves once every dependency the load
+* body touched has also settled. That is what gives `.loaded()` its transitive guarantee through
+* async load bodies: an outer caller awaiting this load promise is, by construction, also
+* waiting for all descendant loads triggered by self.queries reads.
+*
+* Cross-service `ctx.getService(id).queries.*` calls are intentionally **not** wrapped — that
+* would require recursively wrapping the registry's runtime services and would entangle load
+* scoping across service boundaries. Authors must use `.loaded()` explicitly when they need a
+* cross-service dependency awaited from inside a load body.
+*/
+async function runLoadBody(refs, queryName, queryDef, validatedInput, ancestorChain) {
+	if (!queryDef.load) return;
+	const collector = /* @__PURE__ */ new Set();
+	const loadCtx = {
+		self: {
+			get state() {
+				return refs.state;
+			},
+			queries: buildLoadWrappedQueries(refs, ancestorChain, collector),
+			commands: refs.getLoadCommands()
+		},
+		getService: refs.registryApi.getService
+	};
+	await Promise.resolve(queryDef.load(validatedInput, loadCtx));
+	await drainCollector(collector, void 0, refs.serviceId, queryName);
+}
+/**
+* Runs a query's `load` as the body of a subscription's reactive effect.
+*
+* Unlike {@link runLoadBody}, this is invoked synchronously inside an `effect()`, so the external
+* signals the load reads in its synchronous prefix are tracked — when they later change, the effect
+* re-runs and the load re-fires, turning it into a reactive async resource. Loads are therefore an
+* idempotent warming step (the documented guideline, now a hard contract); one-shot side effects
+* belong in a command.
+*
+* Writes go through gated commands: if `isCurrent()` flips to false because a newer run started
+* (deps changed again), this run's later writes are dropped, so a slow stale load cannot clobber the
+* newer result. Sibling reads use the default queries — their loads fire-and-forget — so transitive
+* dependencies stay warm without the `.loaded()` drain, which is only meaningful for awaited pulls.
+*/
+async function runReactiveLoad(refs, queryName, queryDef, validatedInput, isCurrent) {
+	if (!queryDef.load) return;
+	const loadCtx = {
+		self: {
+			get state() {
+				return refs.state;
+			},
+			queries: refs.reactiveLoadQueries,
+			commands: refs.buildGatedCommands(isCurrent)
+		},
+		getService: refs.registryApi.getService
+	};
+	await Promise.resolve(queryDef.load(validatedInput, loadCtx));
+}
+/**
+* Builds the `ctx.self.queries` map used inside a *reactive subscription load* body.
+*
+* `.get()` here fires the dependency's `load` fire-and-forget (deduped via {@link inFlightLoads}),
+* scoped to the reactive-load context only, so a plain consumer `.get()` stays a pure read. There is no drain: a subscription
+* does not await its dependencies, it re-fires reactively when their tracked state changes.
+*/
+function buildReactiveLoadQueries(refs) {
+	const wrappedQueries = {};
+	for (const [name, queryDef] of refs.queryDefinitions) {
+		const defaultQuery = refs.defaultQueries[name];
+		wrappedQueries[name] = {
+			get: createQueryGet(refs, name, queryDef, wrappedQueries, (validatedInput) => {
+				const loadKey = makeLoadKey(refs.serviceId, name, validatedInput);
+				triggerLoad(refs, name, queryDef, validatedInput, loadKey, EMPTY_SET).catch(rethrowAsync);
+			}),
+			loaded: defaultQuery.loaded,
+			subscribe: defaultQuery.subscribe
+		};
+	}
+	return wrappedQueries;
+}
+/**
+* Builds the wrapped `self.queries` map exposed inside one load body.
+*
+* The returned map shadows the runtime's default query map. Each wrapped call still validates
+* input, fires the dependency's `load` via {@link triggerLoad}, and runs the same sync handler —
+* but it also **registers the dependency's load promise into the load-local collector** so
+* `runLoadBody`'s drain can await it before returning. The wrappers therefore turn an ordinary
+* sync read of a dependency into "fire load + remember it for the outer drain to wait on."
+*
+* ### Why one map per load invocation?
+*
+* Two separate `load` calls (different keys, possibly different services) have different
+* `ancestorChain` sets and different `collector` instances. Each wrapped function closes over
+* those values, so the maps cannot be reused — they are recreated cheaply per invocation. Inside
+* a single load body, all nested handler reads share **this same** wrapped map (the closure
+* captures `wrappedQueries` from this scope), so transitive dependency reads continue to register
+* against the same collector.
+*
+* ### Cycle detection
+*
+* If the dependency's load key is already on this load's ancestor chain, we still call
+* `triggerLoad` (it returns the in-flight promise) but we **skip** adding it to the collector.
+* Adding it would deadlock: the outer load's drain would wait on its own ancestor's promise,
+* which is itself waiting on this load. See {@link triggerLoad}'s walkthrough for a concrete
+* `a → b → a` example.
+*
+* ### `.loaded()` and `.subscribe` on the wrapped queries
+*
+* `.loaded()` on a wrapped query forwards the **current** ancestor chain so a load body author
+* can write `await ctx.self.queries.foo.loaded(input)` and trust that the resulting drain
+* inherits the right cycle-protection set. `.subscribe` is passed through unchanged because
+* subscriptions are never part of a load drain — they have their own lifecycle.
+*/
+function buildLoadWrappedQueries(refs, ancestorChain, collector) {
+	const wrappedQueries = {};
+	for (const [name, queryDef] of refs.queryDefinitions) {
+		const defaultQuery = refs.defaultQueries[name];
+		wrappedQueries[name] = {
+			get: createQueryGet(refs, name, queryDef, wrappedQueries, (validatedInput) => {
+				const loadKey = makeLoadKey(refs.serviceId, name, validatedInput);
+				const promise = triggerLoad(refs, name, queryDef, validatedInput, loadKey, ancestorChain);
+				if (!ancestorChain.has(loadKey)) collector.add({
+					key: loadKey,
+					promise
+				});
+			}),
+			loaded(input) {
+				return runLoaded(refs, name, queryDef, arguments.length === 0 ? void 0 : input, ancestorChain);
+			},
+			subscribe: defaultQuery.subscribe
+		};
+	}
+	return wrappedQueries;
+}
+/**
+* Implements `query.loaded(input)`.
+*
+* Returns a promise that resolves to the validated handler output once this query's `load` and
+* every dependency the handler transitively reads has settled.
+*
+* ### Algorithm
+*
+* 1. **Setup** — validate input, build the session (`ancestorChain` extended with this load key,
+*    an empty `collector`, an empty `settledKeys`). The ancestor chain inherits from
+*    `parentAncestorChain` when this is called from inside a wrapped query (so the inner
+*    `.loaded()` shares cycle protection with the outer load body).
+*
+* 2. **Fire own load** — if this query has a `load` hook, push its in-flight promise into
+*    `session.collector`. Skip if the key is already on the parent's ancestor chain (we are
+*    inside that load already; we cannot deadlock on ourselves).
+*
+* 3. **Drain + discover loop**, up to {@link MAX_DRAIN_ITERATIONS} times:
+*    - Inner loop: while `session.collector` has entries, snapshot them, clear, await with
+*      `Promise.allSettled`, mark their keys in `session.settledKeys`, surface rejections.
+*    - Run the handler synchronously under `activeHandlerLoadSession = session` (a discovery
+*      pass). Sync reads of dependencies inside the handler go through {@link createDefaultQuery}
+*      and register any non-settled, non-ancestor load into `session.collector`.
+*    - If the handler threw, swallow (state might still be partial; a later iteration may fix it).
+*    - If the handler added nothing to the collector, we have converged — exit the loop.
+*
+* 4. **Return** — run the handler one final time under the same session (so dependency reads
+*    respect `settledKeys` and do not refire loads) and return the validated output. This is the
+*    value the caller sees. If state is still incomplete at this point the handler may throw, and
+*    that throw propagates.
+*
+* ### Worked example: `bar.loaded(input)` where `bar.handler` reads `foo`
+*
+* Assume `bar` has no `load` of its own; `foo` does.
+*
+* - **Setup**: session = `{ ancestorChain: {barKey}, collector: ∅, settledKeys: ∅ }`. No own load
+*   to fire (`bar.load` is undefined).
+* - **Iteration 1**:
+*   - Inner drain: collector is empty, skip.
+*   - Discovery pass: handler runs, reads `ctx.self.queries.foo.get(...)`. The default `foo` query
+*     sees `activeHandlerLoadSession === session`, sees that `fooKey` is neither in
+*     `ancestorChain` nor in `settledKeys`, and fires + registers foo's load into
+*     `session.collector`. The handler returns (possibly with stale state).
+*   - `hasMoreWork = true` (collector now has one entry).
+* - **Iteration 2**:
+*   - Inner drain: `await Promise.allSettled([fooPromise])`, mark `fooKey` settled, surface any
+*     rejection.
+*   - Discovery pass: handler runs again. The default `foo` query is now in `settledKeys`, so
+*     it fires nothing and the collector stays empty.
+*   - `hasMoreWork = false`; exit.
+* - **Final**: run handler once more (state is now populated by foo's load), validate, return.
+*
+* The same machinery handles deeper chains — every settled load may have populated state that
+* causes the handler to read **more** queries on the next iteration. The loop keeps draining
+* until the read set stabilizes.
+*/
+async function runLoaded(refs, queryName, queryDef, rawInput, parentAncestorChain = EMPTY_SET) {
+	const validatedInput = validateQueryInput(refs, queryName, queryDef, rawInput);
+	const loadKey = makeLoadKey(refs.serviceId, queryName, validatedInput);
+	const ancestorChain = new Set(parentAncestorChain);
+	ancestorChain.add(loadKey);
+	const session = {
+		ancestorChain,
+		collector: /* @__PURE__ */ new Set(),
+		settledKeys: /* @__PURE__ */ new Set()
+	};
+	if (queryDef.load && !parentAncestorChain.has(loadKey)) {
+		const promise = triggerLoad(refs, queryName, queryDef, validatedInput, loadKey, parentAncestorChain);
+		session.collector.add({
+			key: loadKey,
+			promise
+		});
+	}
+	let iterations = 0;
+	let hasMoreWork = true;
+	while (hasMoreWork) {
+		if (iterations++ > MAX_DRAIN_ITERATIONS) throw new OpenServiceLoadedDrainExceededError({
+			serviceId: refs.serviceId,
+			name: queryName,
+			iterations: MAX_DRAIN_ITERATIONS
+		});
+		while (session.collector.size > 0) {
+			const pending = [...session.collector];
+			session.collector.clear();
+			const settlements = await Promise.allSettled(pending.map((entry) => entry.promise));
+			for (const entry of pending) session.settledKeys.add(entry.key);
+			surfaceRejections(settlements);
+		}
+		const previousSession = activeHandlerLoadSession;
+		activeHandlerLoadSession = session;
+		try {
+			runHandlerSync(refs, queryName, queryDef, validatedInput, refs.defaultQueries, refs.registryApi.getService);
+		} catch {} finally {
+			activeHandlerLoadSession = previousSession;
+		}
+		hasMoreWork = session.collector.size > 0;
+	}
+	const previousSession = activeHandlerLoadSession;
+	activeHandlerLoadSession = session;
+	try {
+		return validateQueryOutput(refs, queryName, queryDef, runHandlerSync(refs, queryName, queryDef, validatedInput, refs.defaultQueries, refs.registryApi.getService));
+	} finally {
+		activeHandlerLoadSession = previousSession;
+	}
+}
+/**
+* Creates the default query object exposed on the service runtime as `service.queries.foo`.
+*
+* The returned object is what consumers use directly **and** what handlers see in
+* `ctx.self.queries.foo` (load bodies see a different, wrapped version — see
+* {@link buildLoadWrappedQueries}). Its surface:
+*
+* - **`get(input)`** validates input synchronously, runs the handler against current state, and
+*   returns the validated result. It does **not** fire this query's `load` for an ordinary consumer
+*   read. The one exception is dependency tracking: when a `.get()` runs inside a `.loaded()`
+*   discovery pass (`activeHandlerLoadSession` set), it fires + registers the load into the session
+*   collector so the outer drain awaits it (skipping cycles and already-settled keys). Reactive
+*   subscription loads warm dependencies through {@link buildReactiveLoadQueries} instead.
+* - **`loaded(input)`** drives the full `.loaded()` drain.
+* - **`subscribe(...)`** sets up a reactive subscription (this is what fires the reactive `load`).
+*/
+function createDefaultQuery(refs, queryName, queryDef) {
+	const resolveInput = (input, argsLength) => argsLength === 0 ? void 0 : input;
+	const get = createQueryGet(refs, queryName, queryDef, refs.defaultQueries, (validatedInput) => {
+		const session = activeHandlerLoadSession;
+		if (!session) return;
+		const loadKey = makeLoadKey(refs.serviceId, queryName, validatedInput);
+		if (!session.ancestorChain.has(loadKey) && !session.settledKeys.has(loadKey)) {
+			const promise = triggerLoad(refs, queryName, queryDef, validatedInput, loadKey, session.ancestorChain);
+			session.collector.add({
+				key: loadKey,
+				promise
+			});
+		}
+	});
+	const subscribe = ((...args) => {
+		if (args.length === 1 && typeof args[0] === "function") return subscribeToQuery(refs, queryName, queryDef, void 0, void 0, args[0]);
+		if (args.length === 2 && typeof args[0] === "function" && typeof args[1] === "function") return subscribeToQuery(refs, queryName, queryDef, void 0, args[0], args[1]);
+		const [input, selectorOrCallback, maybeCallback] = args;
+		return subscribeToQuery(refs, queryName, queryDef, input, maybeCallback ? selectorOrCallback : void 0, maybeCallback ?? selectorOrCallback);
+	});
+	return {
+		get,
+		loaded(input) {
+			return runLoaded(refs, queryName, queryDef, resolveInput(input, arguments.length));
+		},
+		subscribe
+	};
+}
+/**
+* Subscribes to a query by running its handler inside a deep-signal-aware `computed()` and
+* notifying through an `effect()`. The callback receives a {@link QueryState} combining the current
+* `data` (the synchronous handler result, or the selected slice) with the per-subscription `load`
+* lifecycle (`status` / `loadStatus` / `error`).
+*
+* The first emission is **synchronous**: `subscribe()` invokes the callback once with the current
+* {@link QueryState} before it returns the unsubscribe handle. The runtime kicks `load` off in the
+* background but does not wait for it — subscribers see the current state immediately (a load-backed
+* query already reads `loading`, since the reactive-load effect runs synchronously here) and
+* follow-up emissions as the load settles (or re-fires) and tracked state changes.
+*
+* Three layers keep emissions precise:
+*
+* 1. **Fine-grained reads** — the handler (and the optional `selector`) read through the deep-signal
+*    proxy, so the computed only re-runs when the exact fields it touched change. A write to an
+*    unrelated key or field never re-runs the handler.
+* 2. **Lifecycle signal** — a separate per-subscription signal carries `status`/`loadStatus`/`error`,
+*    updated by the reactive-load effect. The emit effect reads both it and the data computed, so a
+*    status change (e.g. a background re-load) fires the callback even when the selected slice is
+*    unchanged.
+* 3. **Object dedup** — the whole emitted `QueryState` is compared with the previously emitted one via
+*    `isEqual`; a re-run that produces a deeply-equal state (e.g. a load rewriting an equal payload
+*    with no status change) does not fire the callback.
+*
+* Error sources all surface as `status: 'error'` (keeping the last successful `data`): input
+* validation failure, a synchronous handler / output-validation throw, and a `load` rejection.
+*/
+function subscribeToQuery(refs, queryName, queryDef, rawInput, selector, callback) {
+	let active = true;
+	let validatedInput;
+	try {
+		validatedInput = validateQueryInput(refs, queryName, queryDef, rawInput);
+	} catch (error) {
+		callback(buildQueryState(void 0, {
+			status: "error",
+			error: toError(error),
+			loadStatus: "idle"
+		}));
+		return () => {
+			active = false;
+		};
+	}
+	const lifecycle = y({
+		status: queryDef.load ? "pending" : "success",
+		error: void 0,
+		loadStatus: "idle"
+	});
+	let loadTeardown;
+	if (queryDef.load) {
+		let epoch = 0;
+		loadTeardown = j(() => {
+			const myEpoch = ++epoch;
+			const isCurrent = () => myEpoch === epoch;
+			const previous = f(() => lifecycle.value);
+			lifecycle.value = {
+				status: previous.status,
+				error: previous.error,
+				loadStatus: "loading"
+			};
+			runReactiveLoad(refs, queryName, queryDef, validatedInput, isCurrent).then(() => {
+				if (!isCurrent()) return;
+				lifecycle.value = {
+					status: "success",
+					error: void 0,
+					loadStatus: "idle"
+				};
+			}, (error) => {
+				if (!isCurrent()) return;
+				lifecycle.value = {
+					status: "error",
+					error: toError(error),
+					loadStatus: "idle"
+				};
+			});
+		});
+	}
+	const comp = g$1(() => {
+		const output = runHandlerSync(refs, queryName, queryDef, validatedInput, refs.defaultQueries, refs.registryApi.getService);
+		if (selector) {
+			const validated = f(() => validateQueryOutput(refs, queryName, queryDef, output));
+			selector(output);
+			return detachSnapshot(selector(validated));
+		}
+		return detachSnapshot(validateQueryOutput(refs, queryName, queryDef, output));
+	});
+	let hasEmitted = false;
+	let lastEmitted;
+	let lastData;
+	const teardown = j(() => {
+		const life = lifecycle.value;
+		let data;
+		let status = life.status;
+		let error = life.error;
+		try {
+			data = comp.value;
+			lastData = data;
+		} catch (handlerError) {
+			data = lastData;
+			status = "error";
+			error = toError(handlerError);
+		}
+		if (!active) return;
+		const state = buildQueryState(data, {
+			status,
+			error,
+			loadStatus: life.loadStatus
+		});
+		if (hasEmitted && isEqual(state, lastEmitted)) return;
+		hasEmitted = true;
+		lastEmitted = state;
+		callback(state);
+	});
+	return () => {
+		active = false;
+		teardown();
+		loadTeardown?.();
+	};
+}
+/** Builds the runtime query map for one service runtime. */
+function buildQueries(refs) {
+	const result = {};
+	for (const [name, queryDef] of refs.queryDefinitions) result[name] = createDefaultQuery(refs, name, queryDef);
+	return result;
+}
+var MAX_DRAIN_ITERATIONS, inFlightLoads, nextLoadScopeSequence, nextLoadScopeId, activeHandlerLoadSession, EMPTY_SET;
+function init_query_runtime() {
+	return (init_query_runtime = __esmMin((() => {
+		init_signals_core_module();
+		init_isEqual();
+		init_server_errors();
+		init_service_validation();
+		MAX_DRAIN_ITERATIONS = 32;
+		inFlightLoads = /* @__PURE__ */ new Map();
+		nextLoadScopeSequence = 0;
+		nextLoadScopeId = () => String(nextLoadScopeSequence += 1);
+		EMPTY_SET = /* @__PURE__ */ new Set();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/json-patch.ts
+function parentAt(root, segments) {
+	let current = root;
+	for (let index = 0; index < segments.length - 1; index += 1) {
+		const segment = segments[index];
+		if (isReservedKey(segment) || !isPlainObject$1(current) || !hasOwn(current, segment)) return;
+		current = current[segment];
+	}
+	if (!isPlainObject$1(current)) return;
+	return {
+		parent: current,
+		key: segments[segments.length - 1]
+	};
+}
+/**
+* Apply an RFC 6902 document onto `target` in place.
+*
+* `add` and `replace` both upsert. `remove` of a missing key calls `onMissingRemove` and continues.
+* Incoming values are cloned. On success, `inverse` is reverse apply order. A missing parent, reserved
+* key, or invalid pointer rolls back every op already applied in this call and returns
+* `{ ok: false, path }` for that pointer. Any other throw also rolls back and reports
+* `{ ok: false, path }` for the op that threw.
+*/
+function applyJsonPatch(target, patch, onMissingRemove) {
+	const undo = [];
+	const inverse = [];
+	let currentPath = "";
+	try {
+		for (const operation of patch) {
+			currentPath = operation.path;
+			applyOne(target, operation, undo, inverse, onMissingRemove);
+		}
+		return {
+			ok: true,
+			inverse: inverse.toReversed()
+		};
+	} catch (error) {
+		for (const revert of undo.toReversed()) revert();
+		if (error instanceof MissingParentError) return {
+			ok: false,
+			path: error.path
+		};
+		return {
+			ok: false,
+			path: currentPath
+		};
+	}
+}
+function applyOne(target, operation, undo, inverse, onMissingRemove) {
+	if (!isRfc6901Pointer(operation.path)) throw new MissingParentError(operation.path);
+	const location = parentAt(target, decodePointer(operation.path));
+	if (!location || isReservedKey(location.key)) throw new MissingParentError(operation.path);
+	const { parent, key } = location;
+	switch (operation.op) {
+		case "add":
+		case "replace": {
+			const existed = hasOwn(parent, key);
+			const previous = existed ? clonePlain(parent[key]) : void 0;
+			parent[key] = clonePlain(operation.value);
+			undo.push(() => {
+				if (existed) parent[key] = previous;
+				else delete parent[key];
+			});
+			if (existed) inverse.push({
+				op: "replace",
+				path: operation.path,
+				value: previous
+			});
+			else inverse.push({
+				op: "remove",
+				path: operation.path
+			});
+			return;
+		}
+		case "remove": {
+			if (!hasOwn(parent, key)) {
+				onMissingRemove(operation.path);
+				return;
+			}
+			const previous = clonePlain(parent[key]);
+			delete parent[key];
+			undo.push(() => {
+				parent[key] = previous;
+			});
+			inverse.push({
+				op: "add",
+				path: operation.path,
+				value: previous
+			});
+			return;
+		}
+	}
+}
+var MissingParentError;
+function init_json_patch() {
+	return (init_json_patch = __esmMin((() => {
+		init_plain_object();
+		init_service_channel();
+		MissingParentError = class extends Error {
+			constructor(path) {
+				super(`Missing parent for JSON Patch path ${path}`);
+				this.name = "MissingParentError";
+				this.path = path;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-sync.ts
+function vectorCounter(vector, runtimeId) {
+	return vector[runtimeId] ?? 0;
+}
+function isEmptyVector(vector) {
+	for (const value of Object.values(vector)) if (value > 0) return false;
+	return true;
+}
+/**
+* Returns whether `left` dominates `right`.
+*
+* Every counter in `left` is at least the matching counter in `right`, and at least one is
+* greater. An empty `right` is dominated by any non-empty `left`, so a fresh joiner hears from
+* every peer that has writes. Two empty vectors do not dominate each other.
+*/
+function vectorDominates(left, right) {
+	if (isEmptyVector(right)) return !isEmptyVector(left);
+	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+	let greater = false;
+	for (const key of keys) {
+		const leftCount = vectorCounter(left, key);
+		const rightCount = vectorCounter(right, key);
+		if (leftCount < rightCount) return false;
+		if (leftCount > rightCount) greater = true;
+	}
+	return greater;
+}
+function vectorsEqual(left, right) {
+	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+	for (const key of keys) if (vectorCounter(left, key) !== vectorCounter(right, key)) return false;
+	return true;
+}
+function vectorsConcurrent(left, right) {
+	return !vectorDominates(left, right) && !vectorDominates(right, left) && !vectorsEqual(left, right);
+}
+function formatFrontier(frontier) {
+	const body = Object.keys(frontier.vector).sort().map((key) => `${key}:${frontier.vector[key]}`).join(",");
+	return `{clock:${frontier.clock} vector:{${body}}}`;
+}
+/**
+* Canonical entry order: ascending `seq`, then ascending `runtimeId` with plain string comparison.
+*
+* "Later in the log", "greater stamp", and "wins the path" coincide.
+*/
+function compareStamps(left, right) {
+	if (left.seq !== right.seq) return left.seq < right.seq ? -1 : 1;
+	if (left.runtimeId !== right.runtimeId) return left.runtimeId < right.runtimeId ? -1 : 1;
+	return 0;
+}
+/**
+* Applies `source` onto `target` in place while preserving object identity for unchanged branches.
+*
+* Open-service runtimes expose their state through deep-signal proxies. Replacing the whole state
+* object for every incoming snapshot would invalidate all subscriptions, even when only one nested
+* field changed. This helper instead walks both objects and mutates `target` only where values
+* differ:
+*
+* - Recurses into plain objects so nested deep-signal subscriptions stay attached.
+* - Replaces arrays wholesale, matching the sync contract that arrays are values rather than maps.
+* - Assigns primitives only when changed to avoid spurious signal invalidation.
+* - Copies `source` through `clonePlain` first, like every other value on its way into state, so
+*   untrusted channel payloads and static files cannot pollute prototypes or write deepsignal's
+*   `$` accessors, and state never shares an object with the payload.
+*
+* The `preserveMissingKeys` mode selects the source contract:
+*
+* - `false` means `source` is a full peer snapshot. Keys missing from `source` are deleted from
+*   `target`, allowing deletions to propagate through cross-peer sync.
+* - `true` means `source` is a partial static snapshot. Keys missing from `source` are left alone
+*   so snapshots for one static query input do not erase state populated by other inputs.
+*/
+function applyStatePatch(target, source, options) {
+	mergeInto(target, clonePlain(source), options.preserveMissingKeys);
+}
+function mergeInto(target, source, preserveMissingKeys) {
+	if (!preserveMissingKeys) {
+		for (const key of Object.keys(target)) if (!hasOwn(source, key)) delete target[key];
+	}
+	for (const key of Object.keys(source)) {
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (isPlainObject$1(sourceValue) && isPlainObject$1(targetValue)) mergeInto(targetValue, sourceValue, preserveMissingKeys);
+		else if (targetValue !== sourceValue) target[key] = sourceValue;
+	}
+}
+/**
+* Builds a {@link Reconciler} bound to one runtime's state.
+*
+* `setState` is the runtime's `applyLocal` adapted to a plain record, so placing and installing never
+* author an entry. `serviceId` names the service in warnings. `window` bounds the Log.
+*/
+function createReconciler(options) {
+	const { serviceId, setState } = options;
+	const logWindow = {
+		maxAgeMs: options.window?.maxAgeMs ?? 15e3,
+		maxEntries: options.window?.maxEntries ?? 256
+	};
+	let clock = 0;
+	let snapshotSeq = 0;
+	const vector = /* @__PURE__ */ new Map();
+	const log = [];
+	const logKeys = /* @__PURE__ */ new Set();
+	const dropped = /* @__PURE__ */ new Set();
+	let floor;
+	const vectorRecord = () => Object.fromEntries(vector);
+	const vectorOf = (runtimeId) => vector.get(runtimeId) ?? 0;
+	const hasStamp = (stamp) => logKeys.has(entryStampKey(stamp));
+	const silentMissingRemove = () => void 0;
+	const patchPaths = (patch) => patch.map((operation) => operation.path).join(",");
+	const undoEntry = (current, entry) => {
+		const result = applyJsonPatch(current, entry.inverse, silentMissingRemove);
+		if (!result.ok) logger.warn(`Open-service sync: undo failed. service=${serviceId} stamp=${entryStampKey(entry.stamp)} path=${result.path} command=${entry.command}`);
+	};
+	const redoEntry = (current, entry) => {
+		const result = applyJsonPatch(current, entry.patch, silentMissingRemove);
+		entry.inverse = result.ok ? result.inverse : [];
+		if (!result.ok) logger.warn(`Open-service sync: replay failed. service=${serviceId} stamp=${entryStampKey(entry.stamp)} path=${result.path} command=${entry.command}`);
+	};
+	const undoToIndex = (current, index) => {
+		const undone = [];
+		for (let cursor = log.length - 1; cursor >= index; cursor -= 1) {
+			const entry = log[cursor];
+			undoEntry(current, entry);
+			undone.push(entry);
+		}
+		return undone;
+	};
+	const redoUndone = (current, undone) => {
+		for (let cursor = undone.length - 1; cursor >= 0; cursor -= 1) redoEntry(current, undone[cursor]);
+	};
+	const insertIndexFor = (stamp) => {
+		let index = 0;
+		while (index < log.length && compareStamps(log[index].stamp, stamp) < 0) index += 1;
+		return index;
+	};
+	const tryAdvanceVector = (stamp) => {
+		if (stamp.counter !== vectorOf(stamp.runtimeId) + 1) return;
+		const counters = /* @__PURE__ */ new Set();
+		for (const entry of log) if (entry.stamp.runtimeId === stamp.runtimeId) counters.add(entry.stamp.counter);
+		let next = stamp.counter;
+		while (counters.has(next + 1)) next += 1;
+		vector.set(stamp.runtimeId, next);
+	};
+	const evict = (now) => {
+		const minKeepIndex = Math.max(0, log.length - logWindow.maxEntries);
+		const kept = [];
+		for (let index = 0; index < log.length; index += 1) {
+			const entry = log[index];
+			const amongNewest = index >= minKeepIndex;
+			const young = now - entry.appliedAt < logWindow.maxAgeMs;
+			if (amongNewest || young) kept.push(entry);
+			else {
+				logKeys.delete(entryStampKey(entry.stamp));
+				if (floor === void 0 || compareStamps(entry.stamp, floor) > 0) floor = entry.stamp;
+			}
+		}
+		if (kept.length === log.length) return;
+		log.length = 0;
+		log.push(...kept);
+	};
+	const remember = (entry) => {
+		logKeys.add(entryStampKey(entry.stamp));
+		tryAdvanceVector(entry.stamp);
+		evict(entry.appliedAt);
+	};
+	const appendOrInsert = (entry, index) => {
+		if (index === log.length) log.push(entry);
+		else log.splice(index, 0, entry);
+		remember(entry);
+	};
+	const advanceClock = (seq) => {
+		if (seq > clock) clock = seq;
+	};
+	return {
+		get clock() {
+			return clock;
+		},
+		get vector() {
+			return vectorRecord();
+		},
+		get frontier() {
+			return {
+				vector: vectorRecord(),
+				clock
+			};
+		},
+		get log() {
+			return log.map(({ stamp, command, patch }) => ({
+				stamp,
+				command,
+				patch
+			}));
+		},
+		has(stamp) {
+			return hasStamp(stamp);
+		},
+		advanceLocal(runtimeId, authored) {
+			const stamp = {
+				seq: clock + 1,
+				runtimeId,
+				counter: vectorOf(runtimeId) + 1
+			};
+			advanceClock(stamp.seq);
+			const now = Date.now();
+			const entry = {
+				stamp,
+				command: authored.command,
+				patch: [...authored.patch],
+				inverse: [...authored.inverse],
+				appliedAt: now
+			};
+			appendOrInsert(entry, log.length);
+			return stamp;
+		},
+		tryInstall(frontier, state) {
+			advanceClock(frontier.clock);
+			const localVector = vectorRecord();
+			if (!vectorDominates(frontier.vector, localVector)) return vectorsConcurrent(frontier.vector, localVector) ? "concurrent" : "not-ahead";
+			snapshotSeq = frontier.clock;
+			const remaining = [];
+			for (const entry of log) {
+				if (entry.stamp.counter <= vectorCounter(frontier.vector, entry.stamp.runtimeId)) continue;
+				if (entry.stamp.seq <= frontier.clock) {
+					logger.warn(`Open-service sync: uncovered entry at or below the reply clock dropped on install. service=${serviceId} stamp=${entryStampKey(entry.stamp)} clock=${frontier.clock} paths=${patchPaths(entry.patch)} command=${entry.command}`);
+					continue;
+				}
+				remaining.push(entry);
+			}
+			setState((current) => {
+				applyStatePatch(current, state, { preserveMissingKeys: false });
+				logKeys.clear();
+				dropped.clear();
+				log.length = 0;
+				floor = void 0;
+				vector.clear();
+				for (const [runtimeId, counter] of Object.entries(frontier.vector)) if (counter > 0) vector.set(runtimeId, counter);
+				for (const entry of remaining) {
+					const replayed = { ...entry };
+					redoEntry(current, replayed);
+					log.push(replayed);
+					remember(replayed);
+				}
+			});
+			return "installed";
+		},
+		tryPlaceEntry(incoming) {
+			const { stamp, command, patch } = incoming;
+			const key = entryStampKey(stamp);
+			advanceClock(stamp.seq);
+			if (hasStamp(stamp) || dropped.has(key) || stamp.counter <= vectorOf(stamp.runtimeId)) return "duplicate";
+			if (stamp.seq <= snapshotSeq || floor && compareStamps(stamp, floor) <= 0) {
+				const floorLabel = floor ? `,${entryStampKey(floor)}` : "";
+				logger.warn(`Open-service sync: entry beyond the log window. service=${serviceId} stamps=${key}${floorLabel} paths=${patchPaths(patch)} command=${command}`);
+				dropped.add(key);
+				return "beyond-window";
+			}
+			const gap = stamp.counter > vectorOf(stamp.runtimeId) + 1;
+			const index = insertIndexFor(stamp);
+			const now = Date.now();
+			let failedPath;
+			setState((current) => {
+				let inverse = [];
+				const undone = index === log.length ? [] : undoToIndex(current, index);
+				const result = applyJsonPatch(current, patch, (path) => {
+					logger.debug(`Open-service sync: remove of missing key. service=${serviceId} stamp=${key} path=${path} command=${command}`);
+				});
+				if (result.ok) inverse = result.inverse;
+				else failedPath = result.path;
+				redoUndone(current, undone);
+				appendOrInsert({
+					stamp,
+					command,
+					patch: [...patch],
+					inverse,
+					appliedAt: now
+				}, index);
+			});
+			if (failedPath !== void 0) logger.warn(`Open-service sync: entry did not apply, kept as a no-op. service=${serviceId} stamp=${key} path=${failedPath} command=${command}`);
+			if (gap) logger.warn(`Open-service sync: gap in writer counters. service=${serviceId} stamps=${key} paths=${patchPaths(patch)} command=${command}`);
+			return gap ? "gap" : failedPath !== void 0 ? "unapplied" : "accepted";
+		}
+	};
+}
+function init_service_sync() {
+	return (init_service_sync = __esmMin((() => {
+		init_client_logger();
+		init_json_patch();
+		init_plain_object();
+		init_service_channel();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-runtime.ts
+/**
+* Resolves which serialized static-state file should back a query input.
+*
+* The returned value is a logical slash-separated store key scoped under the service id, not a raw
+* filesystem path.
+*/
+function normalizeStaticStoragePath(serviceId, name, rawPath) {
+	const segments = rawPath.replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+	if (segments.length === 0 || segments.some((segment) => segment === "..")) throw new OpenServiceInvalidStaticPathError({
+		serviceId,
+		name,
+		path: rawPath
+	});
+	return segments.join("/");
+}
+function resolveStaticPath(serviceId, name, queryDef, input) {
+	return `${serviceId}/${normalizeStaticStoragePath(serviceId, name, queryDef.staticPath(input))}`;
+}
+/**
+* Builds the runtime command map from the declarative command definitions.
+*
+* Each runtime command validates raw caller input, invokes the handler with parsed values, and
+* validates the resolved output before returning it to the caller.
+*/
+function buildCommands(serviceId, commands, createCommandCtx) {
+	return Object.fromEntries(Object.entries(commands).map(([name, def]) => {
+		return [name, async (input) => {
+			if (!def.handler) throw new OpenServiceUnimplementedOperationError({
+				kind: "command",
+				serviceId,
+				name
+			});
+			const validatedInput = await validateSchema(def.input, input, {
+				kind: "command",
+				serviceId,
+				name,
+				phase: "input"
+			});
+			const output = await def.handler(validatedInput, createCommandCtx(name));
+			return validateSchema(def.output, output, {
+				kind: "command",
+				serviceId,
+				name,
+				phase: "output"
+			});
+		}];
+	}));
+}
+/**
+* When a browser static loader is active, queries with `staticPath` fetch prebuilt JSON instead of
+* running their authored `load` hook (which typically invokes server-only commands).
+*/
+function buildQueryDefinitionsWithStaticLoader(serviceId, queries, staticLoader, applyLocal) {
+	return new Map(Object.entries(queries).map(([name, queryDef]) => {
+		if (!queryDef.staticPath) return [name, queryDef];
+		const { staticPath } = queryDef;
+		return [name, {
+			...queryDef,
+			load: async (input) => {
+				const snapshot = await staticLoader(resolveStaticPath(serviceId, name, { staticPath }, input), {
+					serviceId,
+					queryName: name,
+					input
+				});
+				applyLocal((state) => {
+					applyStatePatch(state, snapshot, { preserveMissingKeys: true });
+				});
+			}
+		}];
+	}));
+}
+/**
+* Creates the full runtime backing for a service definition.
+*
+* Callers must supply the registry API that query and command contexts should expose.
+*/
+function createServiceRuntime(def, runtimeOptions, initialState = def.initialState) {
+	const rawState = clonePlain(initialState);
+	const state = l(rawState);
+	const getStateSnapshot = () => structuredClone(rawState);
+	const { registryApi, staticLoader } = runtimeOptions;
+	let author = () => {};
+	const applyLocal = (mutate) => {
+		n(() => {
+			mutate(state);
+		});
+	};
+	const writeState = (command, mutate) => {
+		recordPatch(state, mutate, (recorded) => author({
+			command,
+			...recorded
+		}));
+	};
+	const defaultQueries = {};
+	const reactiveLoadQueries = {};
+	const createCommandSelf = (setState, commandsForSelf) => ({
+		get state() {
+			return state;
+		},
+		setState,
+		queries: defaultQueries,
+		get commands() {
+			return commandsForSelf();
+		}
+	});
+	const commands = buildCommands(def.id, def.commands, (commandName) => ({
+		self: createCommandSelf((mutate) => writeState(commandName, mutate), () => commands),
+		getService: registryApi.getService
+	}));
+	let loadCommands = commands;
+	const remoteCommandNames = /* @__PURE__ */ new Set();
+	const queryDefinitions = staticLoader ? buildQueryDefinitionsWithStaticLoader(def.id, def.queries, staticLoader, applyLocal) : new Map(Object.entries(def.queries));
+	const buildGatedCommands = (isCurrent) => {
+		const gated = buildCommands(def.id, def.commands, (commandName) => ({
+			self: createCommandSelf((mutate) => {
+				if (isCurrent()) writeState(commandName, mutate);
+			}, () => gated),
+			getService: registryApi.getService
+		}));
+		if (remoteCommandNames.size === 0) return gated;
+		return Object.fromEntries(Object.keys(def.commands).map((name) => [name, remoteCommandNames.has(name) ? loadCommands[name] : gated[name]]));
+	};
+	const loadScopeId = nextLoadScopeId();
+	const refs = {
+		serviceId: def.id,
+		loadScopeId,
+		state,
+		registryApi,
+		queryDefinitions,
+		defaultQueries,
+		reactiveLoadQueries,
+		getLoadCommands: () => loadCommands,
+		buildGatedCommands
+	};
+	const builtQueries = buildQueries(refs);
+	for (const [name, query] of Object.entries(builtQueries)) defaultQueries[name] = query;
+	for (const [name, query] of Object.entries(buildReactiveLoadQueries(refs))) reactiveLoadQueries[name] = query;
+	const queries = defaultQueries;
+	const queryCtx = {
+		self: {
+			get state() {
+				return state;
+			},
+			queries: defaultQueries
+		},
+		getService: registryApi.getService
+	};
+	const loadCtxForStatic = {
+		self: {
+			get state() {
+				return state;
+			},
+			queries: defaultQueries,
+			commands
+		},
+		getService: registryApi.getService
+	};
+	/**
+	* Runs one query's `load` body against this runtime instance, drained to completion.
+	*
+	* Used by the static build pipeline to populate state for a single input without holding the
+	* load in the in-flight registry afterwards.
+	*/
+	const runLoadOnce = async (queryName, validatedInput) => {
+		const queryDef = queryDefinitions.get(queryName);
+		if (!queryDef || !queryDef.load) return;
+		const loadKey = makeLoadKey(def.id, queryName, validatedInput);
+		const ancestorChain = /* @__PURE__ */ new Set([loadKey]);
+		const inFlightKey = makeInFlightKey(loadScopeId, loadKey);
+		const promise = Promise.resolve().then(() => runLoadBody(refs, queryName, queryDef, validatedInput, ancestorChain)).finally(() => {
+			if (inFlightLoads.get(inFlightKey) === promise) inFlightLoads.delete(inFlightKey);
+		});
+		inFlightLoads.set(inFlightKey, promise);
+		await promise;
+	};
+	const attachChannelCommands = (channelCommands, implementedCommandNames) => {
+		loadCommands = channelCommands;
+		remoteCommandNames.clear();
+		for (const name of Object.keys(def.commands)) if (!implementedCommandNames.has(name)) remoteCommandNames.add(name);
+	};
+	return {
+		getStateSnapshot,
+		applyLocal,
+		attachEntryAuthor: (next) => {
+			author = next;
+		},
+		queryCtx,
+		loadCtxForStatic,
+		commands,
+		queries,
+		runLoadOnce,
+		attachChannelCommands
+	};
+}
+function init_service_runtime() {
+	return (init_service_runtime = __esmMin((() => {
+		init_signals_core_module();
+		init_deepsignal_core_module();
+		init_server_errors();
+		init_patch_recorder();
+		init_plain_object();
+		init_query_runtime();
+		init_service_sync();
+		init_service_validation();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-error-serialization.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSerializedError(value) {
+	return isPlainObject(value) && value[ERROR_MARKER] === true;
+}
+/**
+* Reduces any value to one a channel transport can clone.
+*
+* Functions, symbols, and `undefined` are dropped (structuredClone throws on functions/symbols);
+* `bigint` is stringified; plain objects and arrays are walked; `Error`s become {@link SerializedError}.
+*/
+function toTransportSafe(value) {
+	if (value instanceof Error) return serializeError(value);
+	if (Array.isArray(value)) return value.map((entry) => toTransportSafe(entry));
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const [key, entry] of Object.entries(value)) result[key] = toTransportSafe(entry);
+		return result;
+	}
+	if (value === null) return null;
+	const kind = typeof value;
+	if (kind === "string" || kind === "number" || kind === "boolean") return value;
+	if (kind === "bigint") return value.toString();
+}
+/**
+* Converts a thrown value into a transport-safe {@link SerializedError}.
+*
+* Non-`Error` throws (a string, an object, …) are wrapped in a synthetic error whose message is the
+* stringified value, so the requester always receives a real `Error` to reject with.
+*/
+function serializeError(value) {
+	if (!(value instanceof Error)) return {
+		[ERROR_MARKER]: true,
+		name: "Error",
+		message: String(value)
+	};
+	const properties = {};
+	for (const key of Object.keys(value)) if (!RESERVED_KEYS.has(key)) properties[key] = toTransportSafe(value[key]);
+	return {
+		[ERROR_MARKER]: true,
+		name: value.name,
+		message: value.message,
+		...value.stack !== void 0 ? { stack: value.stack } : {},
+		...value.cause !== void 0 ? { cause: toTransportSafe(value.cause) } : {},
+		...Object.keys(properties).length > 0 ? { properties } : {}
+	};
+}
+/** Inverse of {@link toTransportSafe}: rebuilds nested errors while passing other values through. */
+function fromTransportSafe(value) {
+	if (isSerializedError(value)) return deserializeError(value);
+	if (Array.isArray(value)) return value.map((entry) => fromTransportSafe(entry));
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const [key, entry] of Object.entries(value)) result[key] = fromTransportSafe(entry);
+		return result;
+	}
+	return value;
+}
+/**
+* Rebuilds an `Error` from a {@link SerializedError}, restoring its `name`, `stack`, `cause` chain,
+* and any extra fields (so a Forkbook error arrives with `code`/`fromStorybook` intact).
+*
+* The result is a plain `Error`, not the original subclass — reconstructing arbitrary classes across
+* a realm boundary is neither possible nor needed; callers branch on the restored fields instead.
+*/
+function deserializeError(serialized) {
+	const error = new Error(serialized.message);
+	error.name = serialized.name;
+	if (serialized.stack !== void 0) error.stack = serialized.stack;
+	if ("cause" in serialized) error.cause = fromTransportSafe(serialized.cause);
+	if (serialized.properties) for (const [key, value] of Object.entries(serialized.properties)) error[key] = fromTransportSafe(value);
+	return error;
+}
+var ERROR_MARKER, RESERVED_KEYS;
+function init_service_error_serialization() {
+	return (init_service_error_serialization = __esmMin((() => {
+		ERROR_MARKER = "__openServiceError__";
+		RESERVED_KEYS = /* @__PURE__ */ new Set([
+			ERROR_MARKER,
+			"name",
+			"message",
+			"stack",
+			"cause"
+		]);
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-transport.ts
+/**
+* Builds the receiver for the entries a runtime's `setState` recipes author.
+*
+* Each entry is stamped BEFORE it is emitted, so the copy that bounces back carries a stamp this
+* runtime has already seen and is dropped as a duplicate.
+*/
+function createEntryAuthor(context) {
+	const { serviceId, ownRuntimeId, reconciler, channel } = context;
+	return ({ command, ops, inverse }) => {
+		const stamp = reconciler.advanceLocal(ownRuntimeId, {
+			command,
+			patch: ops,
+			inverse
+		});
+		channel.emit(SERVICE_ENTRY, {
+			serviceId,
+			stamp,
+			command,
+			patch: ops
+		});
+	};
+}
+/**
+* Attaches the channel listeners that keep one runtime in sync with its peers, and returns a teardown.
+*
+* Wires three handlers and emits a bootstrap `services:sync-request` so a freshly-registered runtime
+* catches up to state authored before it joined:
+* - sync-request → reply `{ frontier, state }` only when our vector dominates the requester's;
+* - sync-reply → install only if dominating (and, on a relay hub, forward the original payload);
+* - entry → place by the five-case rule (and, on a relay hub, forward when logged or dropped as
+*   beyond-window for the first time).
+*
+* A hub forwards the original payload object so unknown fields survive the hop. Leaves keep
+* `relay: false`. The request policy (one outstanding, {@link SYNC_REQUEST_SILENCE_MS} of silence,
+* one queued repair) is in the README's Bootstrap and repair section.
+*/
+function connectRuntimeToChannel(context) {
+	const { serviceId, ownRuntimeId, reconciler, getSnapshot, channel, relay } = context;
+	let requestOutstanding = false;
+	let withinReplyWindow = false;
+	let repairQueued = false;
+	let silenceTimer;
+	let forwardedReplyKey;
+	const clearSilenceTimer = () => {
+		if (silenceTimer !== void 0) {
+			clearTimeout(silenceTimer);
+			silenceTimer = void 0;
+		}
+	};
+	const emitSyncRequest = () => {
+		if (requestOutstanding) {
+			repairQueued = true;
+			return;
+		}
+		requestOutstanding = true;
+		withinReplyWindow = true;
+		repairQueued = false;
+		channel.emit(SERVICE_SYNC_REQUEST, {
+			serviceId,
+			runtimeId: ownRuntimeId,
+			frontier: reconciler.frontier
+		});
+		clearSilenceTimer();
+		silenceTimer = setTimeout(() => {
+			silenceTimer = void 0;
+			withinReplyWindow = false;
+			settleOutstandingRequest();
+		}, SYNC_REQUEST_SILENCE_MS);
+	};
+	const settleOutstandingRequest = () => {
+		const queued = repairQueued;
+		requestOutstanding = false;
+		if (queued) emitSyncRequest();
+	};
+	const onSyncRequest = (payload) => {
+		const request = safeParse(syncRequestSchema, payload);
+		if (!request.success || request.output.serviceId !== serviceId || request.output.runtimeId === ownRuntimeId) return;
+		if (!vectorDominates(reconciler.vector, request.output.frontier.vector)) return;
+		channel.emit(SERVICE_SYNC_REPLY, {
+			serviceId,
+			runtimeId: ownRuntimeId,
+			frontier: reconciler.frontier,
+			state: getSnapshot()
+		});
+	};
+	const onSyncReply = (payload) => {
+		const snapshot = safeParse(syncReplySchema, payload);
+		if (!snapshot.success || snapshot.output.serviceId !== serviceId || snapshot.output.runtimeId === ownRuntimeId) return;
+		const replyKey = `${snapshot.output.runtimeId}:${formatFrontier(snapshot.output.frontier)}`;
+		if (replyKey === forwardedReplyKey) return;
+		let outcome;
+		try {
+			outcome = reconciler.tryInstall(snapshot.output.frontier, snapshot.output.state);
+		} finally {
+			const settled = outcome ?? "installed";
+			if (settled === "concurrent" && withinReplyWindow) {
+				logger.warn(`Open-service sync: concurrent snapshot reply dropped. service=${serviceId} local=${formatFrontier(reconciler.frontier)} reply=${formatFrontier(snapshot.output.frontier)}`);
+				repairQueued = true;
+			}
+			settleOutstandingRequest();
+			if (settled === "installed" && relay) {
+				forwardedReplyKey = replyKey;
+				channel.emit(SERVICE_SYNC_REPLY, payload);
+			}
+		}
+	};
+	const onEntry = (payload) => {
+		const parsed = safeParse(entrySchema, payload);
+		if (!parsed.success || parsed.output.serviceId !== serviceId) return;
+		let outcome;
+		try {
+			outcome = reconciler.tryPlaceEntry(parsed.output);
+		} finally {
+			const placed = outcome ?? (reconciler.has(parsed.output.stamp) ? "unapplied" : void 0);
+			const logged = placed === "accepted" || placed === "gap" || placed === "unapplied";
+			const needsRepair = placed === "gap" || placed === "beyond-window" || placed === "unapplied";
+			if ((logged || placed === "beyond-window") && relay) channel.emit(SERVICE_ENTRY, payload);
+			if (needsRepair) emitSyncRequest();
+		}
+	};
+	channel.on(SERVICE_SYNC_REQUEST, onSyncRequest);
+	channel.on(SERVICE_SYNC_REPLY, onSyncReply);
+	channel.on(SERVICE_ENTRY, onEntry);
+	emitSyncRequest();
+	return () => {
+		channel.off(SERVICE_SYNC_REQUEST, onSyncRequest);
+		channel.off(SERVICE_SYNC_REPLY, onSyncReply);
+		channel.off(SERVICE_ENTRY, onEntry);
+		repairQueued = false;
+		requestOutstanding = false;
+		withinReplyWindow = false;
+		clearSilenceTimer();
+	};
+}
+/**
+* Wires the remote-command-execution protocol for one service runtime, returning the command map
+* callers should use plus a teardown.
+*
+* ## Why this exists
+*
+* A command handler can be supplied at registration in only *some* runtimes — the canonical case is
+* a server-only handler that needs Node APIs or server context. Runtimes without a local handler
+* still expose the command (so `useServiceCommand`, tests, and other services can call it), but they
+* cannot run it themselves; they must ask a peer that can.
+*
+* ## Protocol
+*
+* - **Requester** (no local handler): the returned command emits `services:command-invoke` with a
+*   unique `callId` and returns a promise. The promise resolves with the first
+*   `services:command-result` for that `callId`, or rejects with the (deserialized) error from the
+*   first `services:command-error`.
+* - **Responder** (has a local handler): on a matching `services:command-invoke` it emits
+*   `services:command-ack` immediately, runs the command locally on a deferred macrotask — so an
+*   async channel flushes the ack before any handler work starts (each `setState` write is
+*   broadcast by the entry author, so peers converge as usual) — then emits
+*   `services:command-result` or `services:command-error`.
+* - **Non-implementer**: a non-delegated runtime that hosts the service but not the invoked
+*   command's handler replies `services:command-unhandled` instead of staying silent. Only a
+*   delegated requester acts on that reply (rejecting with config-drift guidance, since the
+*   Forkbook it attached to is the only runtime that sees its invokes); other requesters ignore
+*   it, because one peer's report cannot speak for the others.
+*
+* Both roles coexist on one runtime: it responds for the commands it implements and requests the
+* ones it does not. A runtime never requests a command it implements (it runs that locally), so it
+* never answers its own invoke echo.
+*
+* ## Multiple implementers
+*
+* If several peers implement the same command they will each run it and reply. The requester keeps
+* only the first reply per `callId` and ignores the rest. Running a command in more than one runtime
+* is therefore possible by construction; it is constrained by usage conventions and documentation
+* rather than enforced here.
+*
+* ## Topology
+*
+* Replies travel back over the same channel the invoke went out on. A request reaches every peer on
+* the requester's transports; the manager is connected to both the dev server and the preview, so it
+* can invoke a command implemented in either. Command events are *not* relayed across a hub's other
+* transports, so a preview cannot directly invoke a server-only command (and vice versa) — route such
+* calls through the manager or implement the command on a directly-connected peer.
+*
+* ## Delegated mode
+*
+* A delegated runtime (one attached to an already-running Forkbook) owns no dispatch at all: it
+* requests *every* command over the channel and answers no invoke, because the runtime it attached
+* to is the implementer. Local handlers stay registered and inspectable but never run, so a service
+* author writes the same definition either way.
+*/
+function connectCommandTransport(context) {
+	const { serviceId, ownRuntimeId, channel, localCommands, implementedCommandNames, commandNames, delegated } = context;
+	const dispatchesLocally = (commandName) => !delegated && implementedCommandNames.has(commandName);
+	const pending = /* @__PURE__ */ new Map();
+	const settle = (callId, apply) => {
+		const entry = pending.get(callId);
+		if (!entry) return;
+		pending.delete(callId);
+		clearTimeout(entry.noAckTimer);
+		apply(entry);
+	};
+	const onInvoke = (payload) => {
+		const parsed = safeParse(commandInvokeSchema, payload);
+		if (!parsed.success || parsed.output.serviceId !== serviceId) return;
+		const invoke = parsed.output;
+		if (!dispatchesLocally(invoke.commandName)) {
+			if (!delegated && invoke.runtimeId !== ownRuntimeId) channel.emit(SERVICE_COMMAND_UNHANDLED, {
+				serviceId,
+				callId: invoke.callId
+			});
+			return;
+		}
+		channel.emit(SERVICE_COMMAND_ACK, {
+			serviceId,
+			callId: invoke.callId,
+			runtimeId: ownRuntimeId
+		});
+		setTimeout(() => {
+			Promise.resolve().then(() => localCommands[invoke.commandName](invoke.input)).then((result) => {
+				channel.emit(SERVICE_COMMAND_RESULT, {
+					serviceId,
+					callId: invoke.callId,
+					result,
+					runtimeId: ownRuntimeId
+				});
+			}, (error) => {
+				channel.emit(SERVICE_COMMAND_ERROR, {
+					serviceId,
+					callId: invoke.callId,
+					error: serializeError(error),
+					runtimeId: ownRuntimeId
+				});
+			});
+		}, 0);
+	};
+	const onResult = (payload) => {
+		const result = safeParse(commandResultSchema, payload);
+		if (!result.success || result.output.serviceId !== serviceId) return;
+		settle(result.output.callId, (entry) => entry.resolve(result.output.result));
+	};
+	const onError = (payload) => {
+		const failure = safeParse(commandErrorSchema, payload);
+		if (!failure.success || failure.output.serviceId !== serviceId) return;
+		settle(failure.output.callId, (entry) => entry.reject(deserializeError(failure.output.error)));
+	};
+	const onAck = (payload) => {
+		const ack = safeParse(commandAckSchema, payload);
+		if (!ack.success || ack.output.serviceId !== serviceId) return;
+		const entry = pending.get(ack.output.callId);
+		if (!entry) return;
+		clearTimeout(entry.noAckTimer);
+	};
+	const onUnhandled = (payload) => {
+		const report = safeParse(commandUnhandledSchema, payload);
+		if (!report.success || report.output.serviceId !== serviceId || !delegated) return;
+		settle(report.output.callId, (entry) => entry.reject(new OpenServiceRemoteCommandConfigDriftError({
+			serviceId,
+			commandName: entry.commandName
+		})));
+	};
+	channel.on(SERVICE_COMMAND_INVOKE, onInvoke);
+	channel.on(SERVICE_COMMAND_RESULT, onResult);
+	channel.on(SERVICE_COMMAND_ERROR, onError);
+	channel.on(SERVICE_COMMAND_ACK, onAck);
+	channel.on(SERVICE_COMMAND_UNHANDLED, onUnhandled);
+	const requestRemote = (commandName, input) => {
+		const callId = generateCallId();
+		return new Promise((resolve, reject) => {
+			const noAckTimer = setTimeout(() => {
+				settle(callId, (entry) => entry.reject(new OpenServiceRemoteCommandUnhandledError({
+					serviceId,
+					commandName: entry.commandName,
+					delegated
+				})));
+			}, 300);
+			pending.set(callId, {
+				commandName,
+				resolve,
+				reject,
+				noAckTimer
+			});
+			channel.emit(SERVICE_COMMAND_INVOKE, {
+				serviceId,
+				commandName,
+				input,
+				callId,
+				runtimeId: ownRuntimeId
+			});
+		});
+	};
+	const commands = {};
+	for (const name of commandNames) commands[name] = dispatchesLocally(name) ? localCommands[name] : (input) => requestRemote(name, input);
+	return {
+		commands,
+		disconnect: () => {
+			channel.off(SERVICE_COMMAND_INVOKE, onInvoke);
+			channel.off(SERVICE_COMMAND_RESULT, onResult);
+			channel.off(SERVICE_COMMAND_ERROR, onError);
+			channel.off(SERVICE_COMMAND_ACK, onAck);
+			channel.off(SERVICE_COMMAND_UNHANDLED, onUnhandled);
+			for (const [, entry] of pending) {
+				clearTimeout(entry.noAckTimer);
+				entry.reject(new OpenServiceRemoteCommandDisconnectedError({ serviceId }));
+			}
+			pending.clear();
+		}
+	};
+}
+/**
+* Reports invokes for service ids this realm does not register at all.
+*
+* The per-service transport can only speak for services it hosts, but the common config-drift
+* shape — a feature flag gating a whole service — leaves the invoke with no listener at all. One
+* realm-global listener closes that gap: a non-delegated realm replies `services:command-unhandled`
+* for any invoke whose service id it has never registered, so a delegated caller learns the drift
+* positively instead of waiting out the ack window. Delegated realms answer nothing, a realm never
+* reports its own invokes (they are only ever for services it registers), and an id that was
+* registered before (mid-HMR re-registration) is not reported — staying silent degrades to the
+* retryable timeout error, while a false report would hand out restart guidance for a transient.
+*/
+function connectUnknownServiceReporter(context) {
+	const { channel, isServiceRegistered, isDelegated } = context;
+	const onInvoke = (payload) => {
+		const parsed = safeParse(commandInvokeSchema, payload);
+		if (!parsed.success || isDelegated() || isServiceRegistered(parsed.output.serviceId)) return;
+		channel.emit(SERVICE_COMMAND_UNHANDLED, {
+			serviceId: parsed.output.serviceId,
+			callId: parsed.output.callId
+		});
+	};
+	channel.on(SERVICE_COMMAND_INVOKE, onInvoke);
+	return () => {
+		channel.off(SERVICE_COMMAND_INVOKE, onInvoke);
+	};
+}
+/**
+* Wires one service runtime to the channel end to end and returns the command map callers expose plus
+* a single teardown.
+*
+* This is the one entry point `registerService` uses, so the three transport halves — entry
+* authoring, the remote-command protocol, and the sync-request + entry listeners — are always
+* assembled together against the same `channel` and can never drift into using different channels.
+* The channel-routed command map is also installed on the runtime so load bodies invoke
+* peer-implemented commands remotely instead of throwing locally.
+*/
+function connectServiceToChannel(context) {
+	const { serviceId, ownRuntimeId, reconciler, getSnapshot, channel, relay, commands, implementedCommandNames, commandNames, delegated, runtime } = context;
+	runtime.attachEntryAuthor(createEntryAuthor({
+		serviceId,
+		ownRuntimeId,
+		reconciler,
+		channel
+	}));
+	const commandTransport = connectCommandTransport({
+		serviceId,
+		ownRuntimeId,
+		channel,
+		localCommands: commands,
+		implementedCommandNames,
+		commandNames,
+		delegated
+	});
+	const disconnectSync = connectRuntimeToChannel({
+		serviceId,
+		ownRuntimeId,
+		reconciler,
+		getSnapshot,
+		channel,
+		relay
+	});
+	runtime.attachChannelCommands(commandTransport.commands, delegated ? /* @__PURE__ */ new Set() : implementedCommandNames);
+	return {
+		commands: commandTransport.commands,
+		disconnect: () => {
+			disconnectSync();
+			commandTransport.disconnect();
+		}
+	};
+}
+var SYNC_REQUEST_SILENCE_MS;
+function init_service_transport() {
+	return (init_service_transport = __esmMin((() => {
+		init_dist();
+		init_client_logger();
+		init_server_errors();
+		init_service_channel();
+		init_service_error_serialization();
+		init_service_sync();
+		SYNC_REQUEST_SILENCE_MS = 1e3;
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-registry.ts
+/**
+* Returns the realm-global inventory backing service registration and delegated mode.
+*
+* Lazily created so importing the module does not eagerly mutate global state. Anchoring it on a
+* `globalThis` symbol keeps the service map and the delegated-mode flag shared even when this file is
+* reached through different import paths.
+*/
+function getInventory() {
+	const registryGlobal = globalThis;
+	registryGlobal[REGISTRY_SYMBOL] ??= {
+		entries: /* @__PURE__ */ new Map(),
+		delegatedMode: false,
+		everRegisteredIds: /* @__PURE__ */ new Set()
+	};
+	return registryGlobal[REGISTRY_SYMBOL];
+}
+function getRegistry() {
+	return getInventory().entries;
+}
+/** Whether this runtime delegates command dispatch to the Forkbook it is attached to. */
+function isDelegatedMode() {
+	return getInventory().delegatedMode;
+}
+function ensureUnknownServiceReporter(channel) {
+	const inventory = getInventory();
+	if (inventory.unknownServiceReporter?.channel === channel) return;
+	inventory.unknownServiceReporter?.disconnect();
+	inventory.unknownServiceReporter = {
+		channel,
+		disconnect: connectUnknownServiceReporter({
+			channel,
+			isServiceRegistered: (serviceId) => inventory.everRegisteredIds.has(serviceId),
+			isDelegated: () => inventory.delegatedMode
+		})
+	};
+}
+function assertUniqueOperationNames(definition) {
+	const duplicateName = Object.keys(definition.queries).find((name) => Object.hasOwn(definition.commands, name));
+	if (duplicateName) throw new OpenServiceOperationNameCollisionError({
+		serviceId: definition.id,
+		operationName: duplicateName
+	});
+}
+/**
+* Converts one service definition into the serializable descriptor returned by registry metadata APIs.
+*
+* Descriptors expose schemas and descriptions but not runtime handlers, so callers can inspect a
+* service's contract without gaining access to executable behavior. `staticPath: true` is surfaced so
+* manager code can choose between live runtime queries and prebuilt JSON snapshots.
+*/
+function describeDefinition(definition) {
+	return {
+		id: definition.id,
+		description: definition.description,
+		queries: Object.fromEntries(Object.entries(definition.queries).filter(([, query]) => !query.internal).map(([name, query]) => [name, {
+			name,
+			description: query.description,
+			input: query.input,
+			output: query.output,
+			...query.staticPath ? { staticPath: true } : {}
+		}])),
+		commands: Object.fromEntries(Object.entries(definition.commands).filter(([, command]) => !command.internal).map(([name, command]) => [name, {
+			name,
+			description: command.description,
+			input: command.input,
+			output: command.output
+		}]))
+	};
+}
+/** Derives the lightweight summary returned by `listServices()` from a full descriptor. */
+function summarizeDescriptor(descriptor) {
+	return {
+		id: descriptor.id,
+		description: descriptor.description,
+		queryNames: Object.keys(descriptor.queries),
+		commandNames: Object.keys(descriptor.commands)
+	};
+}
+/**
+* Applies optional registration overrides to an authored definition.
+*
+* Query registration may supply dependency-aware `staticInputs` (used by server static builds);
+* command registration may override the `handler`. Anything not overridden is forwarded unchanged so
+* every runtime shares the same contract.
+*/
+function applyRegistration(definition, registration) {
+	if (!registration) return definition;
+	return {
+		...definition,
+		queries: Object.fromEntries(Object.entries(definition.queries).map(([name, query]) => {
+			const override = registration.queries?.[name];
+			return [name, override && "staticInputs" in override ? {
+				...query,
+				staticInputs: override.staticInputs
+			} : query];
+		})),
+		commands: Object.fromEntries(Object.entries(definition.commands).map(([name, command]) => {
+			const override = registration.commands?.[name];
+			return [name, override && "handler" in override ? {
+				...command,
+				handler: override.handler
+			} : command];
+		}))
+	};
+}
+/**
+* Registers one service definition in the realm-global registry and returns its runtime surface.
+*
+* Registration resolves any registration-time overrides, builds the runtime that query and command
+* callers use, installs the entry author that emits a `services:entry` for each `setState` write, and
+* joins the cross-peer sync protocol as a hub or leaf (`relay`). Each runtime must install the addons
+* channel at its entry boundary before calling this (builders, manager boot, server `services`
+* preset, or Node import bootstrap). Registration is idempotent by id: a repeated registration
+* returns the existing runtime.
+*/
+function registerService$1(definition, registration, { relay = false, staticLoader, window } = {}) {
+	assertUniqueOperationNames(definition);
+	const registry = getRegistry();
+	const existingEntry = registry.get(definition.id);
+	if (existingEntry) return existingEntry.instance;
+	const ownRuntimeId = generateRuntimeId();
+	const resolvedDefinition = applyRegistration(definition, registration);
+	const runtime = createServiceRuntime(resolvedDefinition, {
+		registryApi: serviceRegistryApi,
+		staticLoader
+	});
+	const reconciler = createReconciler({
+		serviceId: definition.id,
+		setState: (mutate) => runtime.applyLocal((state) => mutate(state)),
+		window
+	});
+	const getSnapshot = () => runtime.getStateSnapshot();
+	const descriptor = describeDefinition(resolvedDefinition);
+	const channel = getChannel();
+	if (!channel) throw new OpenServiceMissingChannelError({ serviceId: definition.id });
+	getInventory().everRegisteredIds.add(definition.id);
+	ensureUnknownServiceReporter(channel);
+	const implementedCommandNames = new Set(Object.entries(resolvedDefinition.commands).filter(([, command]) => typeof command.handler === "function").map(([name]) => name));
+	const { commands, disconnect } = connectServiceToChannel({
+		serviceId: definition.id,
+		ownRuntimeId,
+		reconciler,
+		getSnapshot,
+		channel,
+		relay: isDelegatedMode() ? false : relay,
+		commands: runtime.commands,
+		implementedCommandNames,
+		commandNames: Object.keys(resolvedDefinition.commands),
+		delegated: isDelegatedMode(),
+		runtime
+	});
+	const instance = {
+		queries: runtime.queries,
+		commands,
+		...serviceRegistryApi
+	};
+	registry.set(definition.id, {
+		definition: resolvedDefinition,
+		instance,
+		descriptor,
+		summary: summarizeDescriptor(descriptor),
+		disconnect
+	});
+	return instance;
+}
+/** Returns one summary entry per registered service — the lowest-cost discovery endpoint. */
+async function listServices() {
+	return Array.from(getRegistry().values()).filter(({ definition }) => !definition.internal).map(({ summary }) => summary);
+}
+/** Returns the schema-backed descriptor for one registered service. */
+async function describeService(serviceId) {
+	const entry = getRegistry().get(serviceId);
+	if (!entry) throw new OpenServiceMissingServiceError({ serviceId });
+	return entry.descriptor;
+}
+/**
+* Resolves a registered runtime service by id from the current realm.
+*
+* Query and command contexts delegate cross-service calls through this lookup so one service can reuse
+* another's runtime contract. Synchronous because callers need it inside sync query handlers.
+*
+* Services with `internal: true` require `{ internal: true }` — otherwise this throws
+* {@link OpenServiceInternalServiceError}. Do not depend on internal OSA from public adapters;
+* prefer public toolsets (`defineToolset`) instead.
+*/
+function getService$1(serviceId, options) {
+	const entry = getRegistry().get(serviceId);
+	if (!entry) throw new OpenServiceMissingServiceError({ serviceId });
+	if (entry.definition.internal && !options?.internal) throw new OpenServiceInternalServiceError({ serviceId });
+	return entry.instance;
+}
+var REGISTRY_SYMBOL, serviceRegistryApi;
+function init_service_registry() {
+	return (init_service_registry = __esmMin((() => {
+		init_channel_slot();
+		init_server_errors();
+		init_service_channel();
+		init_service_runtime();
+		init_service_sync();
+		init_service_transport();
+		REGISTRY_SYMBOL = Symbol.for("storybook.open-service.registry");
+		serviceRegistryApi = {
+			listServices,
+			describeService,
+			getService: getService$1
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/static-fetch.ts
+function shouldUseBrowserStaticLoader() {
+	return globalThis.CONFIG_TYPE === "PRODUCTION";
+}
+/**
+* Returns a fetch-based loader for static build output, or `undefined` in development.
+*
+* Snapshot paths are logical keys such as `core/docgen/foo.json`, resolved relative to the
+* document (`./services/...`), so the manager and preview iframes share the same base wherever
+* the build is deployed.
+*/
+function createBrowserStaticLoader() {
+	if (!shouldUseBrowserStaticLoader()) return;
+	return async (logicalPath, context) => {
+		const url = `${STATIC_SERVICES_PREFIX}${logicalPath}`;
+		let res;
+		try {
+			res = await fetch(url);
+		} catch (cause) {
+			throw new OpenServiceStaticSnapshotLoadError({
+				...context,
+				logicalPath,
+				url,
+				cause
+			});
+		}
+		if (!res.ok) {
+			const cause = {
+				status: res.status,
+				statusText: res.statusText
+			};
+			throw new OpenServiceStaticSnapshotLoadError({
+				...context,
+				logicalPath,
+				url,
+				cause,
+				status: res.status,
+				statusText: res.statusText
+			});
+		}
+		let snapshot;
+		try {
+			snapshot = await res.json();
+		} catch (cause) {
+			throw new OpenServiceStaticSnapshotLoadError({
+				...context,
+				logicalPath,
+				url,
+				cause
+			});
+		}
+		if (snapshot && typeof snapshot === "object" && !Array.isArray(snapshot)) return snapshot;
+		throw new OpenServiceStaticSnapshotInvalidError({
+			...context,
+			logicalPath,
+			url,
+			received: snapshot
+		});
+	};
+}
+var STATIC_SERVICES_PREFIX;
+function init_static_fetch() {
+	return (init_static_fetch = __esmMin((() => {
+		init_manager_errors();
+		STATIC_SERVICES_PREFIX = "./services/";
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/preview.ts
+/**
+* Registers a service in the preview and returns its runtime surface.
+*
+* The preview is a leaf (`relay: false`). Builders install the addons channel before preview config
+* loads, so registration can assume the channel is already present.
+*/
+function registerService(definition, registration) {
+	return registerService$1(definition, registration, { staticLoader: createBrowserStaticLoader() });
+}
+var getService;
+function init_preview() {
+	return (init_preview = __esmMin((() => {
+		init_service_registry();
+		init_static_fetch();
+		getService = getService$1;
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/service-definition.ts
+var defineService;
+function init_service_definition() {
+	return (init_service_definition = __esmMin((() => {
+		defineService = (def) => def;
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/services/story-docs/snippet.ts
+/** Prepends a CSF file import block to a story snippet for display in docs and the Code panel. */
+function prependImportToSnippet(importBlock, snippet) {
+	const trimmedImport = importBlock?.trim();
+	if (!trimmedImport) return snippet;
+	return `${trimmedImport}\n\n${snippet}`;
+}
+/** Resolves the display snippet for one story from a story-docs payload. */
+function selectSnippetForStory(payload, storyId) {
+	const story = payload?.stories[storyId];
+	if (story?.snippet === void 0) return;
+	return prependImportToSnippet(payload?.import, story.snippet);
+}
+/** Resolves the incomplete-snippet warning for one story from a story-docs payload. */
+function selectWarningForStory(payload, storyId) {
+	return payload?.stories[storyId]?.warning;
+}
+//#endregion
+//#region src/shared/open-service/services/docgen/paths.ts
+/**
+* Relative path segment for one component's static snapshot file, as returned by the `docgen`
+* query's `staticPath`. Must stay aligned with {@link docgenServiceDef} and manifest `$ref`s.
+*/
+function docgenQueryStaticPath(id) {
+	return `${id}.json`;
+}
+function init_paths() {
+	return (init_paths = __esmMin((() => {})))();
+}
+//#endregion
+//#region src/shared/open-service/services/docgen/definition.ts
+var docgenInputSchema, argTypesSchema, docgenErrorSchema, docgenJsDocTagsSchema, docgenComponentFields, docgenSubcomponentFields, docgenSubcomponentSchema, docgenPayloadSchema, docgenOutputSchema, docgenServiceDef;
+function init_definition() {
+	return (init_definition = __esmMin((() => {
+		init_dist();
+		init_service_definition();
+		init_paths();
+		docgenInputSchema = object({ id: string() });
+		argTypesSchema = custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+		docgenErrorSchema = object({
+			name: string(),
+			message: string()
+		});
+		docgenJsDocTagsSchema = record(string(), array(string()));
+		docgenComponentFields = {
+			name: string(),
+			path: string(),
+			description: optional(string()),
+			summary: optional(string()),
+			jsDocTags: docgenJsDocTagsSchema,
+			argTypes: optional(argTypesSchema),
+			error: optional(docgenErrorSchema)
+		};
+		docgenSubcomponentFields = {
+			...docgenComponentFields,
+			import: optional(string())
+		};
+		docgenSubcomponentSchema = looseObject(docgenSubcomponentFields);
+		docgenPayloadSchema = looseObject({
+			id: string(),
+			...docgenComponentFields,
+			subcomponents: optional(record(string(), docgenSubcomponentSchema))
+		});
+		docgenOutputSchema = optional(docgenPayloadSchema);
+		docgenServiceDef = defineService({
+			id: "core/docgen",
+			internal: true,
+			description: "Component documentation (name, description, props, JSDoc tags) keyed by component id.",
+			initialState: { components: {} },
+			queries: {
+				docgen: {
+					description: "Returns the docgen payload for one component id, or undefined when not loaded.",
+					input: docgenInputSchema,
+					output: docgenOutputSchema,
+					handler: (input, ctx) => ctx.self.state.components[input.id],
+					load: async (input, ctx) => {
+						await ctx.self.commands.extractDocgen(input);
+					},
+					staticPath: (input) => docgenQueryStaticPath(input.id)
+				},
+				docgenForAllComponents: {
+					description: "Returns docgen payloads for every component in the story index.",
+					input: void_(),
+					output: record(string(), docgenPayloadSchema),
+					handler: (_input, ctx) => ctx.self.state.components,
+					load: async (_input, ctx) => {
+						await ctx.self.commands.extractAllDocgen(void 0);
+					}
+				}
+			},
+			commands: {
+				extractDocgen: {
+					description: "Resolves the story entry for a component id, runs the registered provider chain, writes the result into state, and returns it (or undefined when no provider produced docgen).",
+					input: docgenInputSchema,
+					output: docgenOutputSchema
+				},
+				extractAllDocgen: {
+					description: "Extracts docgen for every component id in the story index by invoking `extractDocgen` for each.",
+					input: undefined_(),
+					output: void_()
+				}
+			}
+		});
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/services/docgen/preview.ts
+var preview_default$1;
+function init_preview$1() {
+	return (init_preview$1 = __esmMin((() => {
+		init_preview();
+		init_definition();
+		preview_default$1 = () => definePreviewAddon({ beforeAll: () => {
+			if (globalThis.FEATURES?.docgenServer) registerService(docgenServiceDef);
+		} });
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/services/story-docs/paths.ts
+/**
+* Relative path segment for one component's static snapshot file, as returned by the `storyDocs`
+* query's `staticPath`. Must stay aligned with {@link storyDocsServiceDef} and manifest `$ref`s.
+*/
+function storyDocsQueryStaticPath(id) {
+	return `${id}.json`;
+}
+function init_paths$1() {
+	return (init_paths$1 = __esmMin((() => {})))();
+}
+//#endregion
+//#region src/shared/open-service/services/story-docs/definition.ts
+var storyDocsInputSchema, storyDocsErrorSchema, storyDocSchema, storyDocsPayloadSchema, storyDocsOutputSchema, storyDocsServiceDef;
+function init_definition$1() {
+	return (init_definition$1 = __esmMin((() => {
+		init_dist();
+		init_service_definition();
+		init_paths$1();
+		storyDocsInputSchema = object({ id: string() });
+		storyDocsErrorSchema = object({
+			name: string(),
+			message: string()
+		});
+		storyDocSchema = object({
+			id: string(),
+			name: string(),
+			snippet: optional(string()),
+			description: optional(string()),
+			summary: optional(string()),
+			warning: optional(string()),
+			error: optional(storyDocsErrorSchema)
+		});
+		storyDocsPayloadSchema = object({
+			id: string(),
+			name: string(),
+			path: string(),
+			import: optional(string()),
+			stories: record(string(), storyDocSchema),
+			error: optional(storyDocsErrorSchema)
+		});
+		storyDocsOutputSchema = optional(storyDocsPayloadSchema);
+		storyDocsServiceDef = defineService({
+			id: "core/story-docs",
+			internal: true,
+			description: "Story documentation (snippets, descriptions, imports) keyed by component id.",
+			initialState: { components: {} },
+			queries: {
+				storyDocs: {
+					description: "Returns the story-docs payload for one component id, or undefined when not loaded.",
+					input: storyDocsInputSchema,
+					output: storyDocsOutputSchema,
+					handler: (input, ctx) => Object.hasOwn(ctx.self.state.components, input.id) ? ctx.self.state.components[input.id] : void 0,
+					load: async (input, ctx) => {
+						await ctx.self.commands.extractStoryDocs(input);
+					},
+					staticPath: (input) => storyDocsQueryStaticPath(input.id)
+				},
+				storyDocsForAllComponents: {
+					description: "Returns story-docs payloads for every component in the story index.",
+					input: void_(),
+					output: record(string(), storyDocsPayloadSchema),
+					handler: (_input, ctx) => ctx.self.state.components,
+					load: async (_input, ctx) => {
+						await ctx.self.commands.extractAllStoryDocs(void 0);
+					}
+				}
+			},
+			commands: {
+				extractStoryDocs: {
+					description: "Resolves the story entry for a component id, runs the registered provider chain, writes the result into state, and returns it (or undefined when no provider produced story docs).",
+					input: storyDocsInputSchema,
+					output: storyDocsOutputSchema
+				},
+				extractAllStoryDocs: {
+					description: "Extracts story docs for every component id in the story index by invoking `extractStoryDocs` for each.",
+					input: undefined_(),
+					output: void_()
+				}
+			}
+		});
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/services/story-docs/story-docs-source-before-each.ts
+/**
+* Preview `beforeEach` hook that emits a static story-docs snippet to the manager Code panel via
+* {@link emitTransformCode}. Runs once per story invocation; the snippet itself is static.
+*/
+function storyDocsSourceBeforeEach(context) {
+	if (!globalThis.FEATURES?.docgenServer) return;
+	if (shouldSkipStoryDocsEmit(context.parameters)) return;
+	const service = (() => {
+		try {
+			return getService("core/story-docs", { internal: true });
+		} catch {
+			return;
+		}
+	})();
+	if (!service) return;
+	const storyId = context.id;
+	const componentId = storyId.split("--")[0];
+	let cancelled = false;
+	const codePanelSnippetPromise = service.queries.storyDocs.loaded({ id: componentId }).then((payload) => {
+		if (cancelled) return;
+		const snippet = selectSnippetForStory(payload, storyId);
+		const source = snippet ?? context.parameters?.docs?.source?.originalSource;
+		if (source === void 0) return;
+		const warning = selectWarningForStory(payload, storyId);
+		return emitTransformCode(source, context, snippet === void 0 && warning ? `${warning} Showing the story source instead.` : warning);
+	}).catch((error) => {
+		logger.debug(`Story docs snippet for ${storyId} unavailable: ${String(error)}`);
+	});
+	return () => {
+		cancelled = true;
+		return codePanelSnippetPromise;
+	};
+}
+function init_story_docs_source_before_each() {
+	return (init_story_docs_source_before_each = __esmMin((() => {
+		init_client_logger();
+		init_storyDocsCodePanel();
+		init_preview_api();
+	})))();
+}
+//#endregion
+//#region src/shared/open-service/services/story-docs/preview.ts
+var preview_default;
+function init_preview$2() {
+	return (init_preview$2 = __esmMin((() => {
+		init_preview();
+		init_definition$1();
+		init_story_docs_source_before_each();
+		preview_default = () => {
+			if (!("FEATURES" in globalThis && globalThis.FEATURES?.docgenServer)) return definePreviewAddon({});
+			return definePreviewAddon({
+				beforeAll: () => {
+					registerService(storyDocsServiceDef);
+				},
+				beforeEach: storyDocsSourceBeforeEach
+			});
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/story-index/autoTitle.ts
+/**
+* Combines path parts together, without duplicating separators (slashes). Used instead of
+* `path.join` because this code runs in the browser.
+*
+* @param paths Array of paths to join together.
+* @returns Joined path string, with single '/' between parts
+*/
+function pathJoin(paths) {
+	return paths.flatMap((p) => p.split("/")).filter(Boolean).join("/");
+}
+var sanitize, userOrAutoTitleFromSpecifier, userOrAutoTitle;
+function init_autoTitle() {
+	return (init_autoTitle = __esmMin((() => {
+		sanitize = (parts) => {
+			if (parts.length === 0) return parts;
+			const last = parts[parts.length - 1];
+			const lastStripped = last?.replace(/(?:[.](?:story|stories))?([.][^.]+)$/i, "");
+			if (parts.length === 1) return [lastStripped];
+			const nextToLast = parts[parts.length - 2];
+			if (lastStripped && nextToLast && lastStripped.toLowerCase() === nextToLast.toLowerCase()) return [...parts.slice(0, -2), lastStripped];
+			return lastStripped && (/^(story|stories)([.][^.]+)$/i.test(last) || /^index$/i.test(lastStripped)) ? parts.slice(0, -1) : [...parts.slice(0, -1), lastStripped];
+		};
+		userOrAutoTitleFromSpecifier = (fileName, entry, userTitle) => {
+			const { directory, importPathMatcher, titlePrefix = "" } = entry || {};
+			const normalizedFileName = slash(String(fileName));
+			if (importPathMatcher.exec(normalizedFileName)) {
+				if (!userTitle) {
+					let parts = pathJoin([titlePrefix, normalizedFileName.replace(directory, "")]).split("/");
+					parts = sanitize(parts);
+					return parts.join("/");
+				}
+				if (!titlePrefix) return userTitle;
+				return pathJoin([titlePrefix, userTitle]);
+			}
+		};
+		userOrAutoTitle = (fileName, storiesEntries, userTitle) => {
+			for (let i = 0; i < storiesEntries.length; i += 1) {
+				const title = userOrAutoTitleFromSpecifier(fileName, storiesEntries[i], userTitle);
+				if (title) return title;
+			}
+			return userTitle || void 0;
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/story-index/storySort.ts
+var STORY_KIND_PATH_SEPARATOR, storySort;
+function init_storySort() {
+	return (init_storySort = __esmMin((() => {
+		STORY_KIND_PATH_SEPARATOR = /\s*\/\s*/;
+		storySort = (options = {}) => (a, b) => {
+			if (a.title === b.title && !options.includeNames) return 0;
+			const method = options.method || "configure";
+			let order = options.order || [];
+			const storyTitleA = a.title.trim().split(STORY_KIND_PATH_SEPARATOR);
+			const storyTitleB = b.title.trim().split(STORY_KIND_PATH_SEPARATOR);
+			if (options.includeNames) {
+				storyTitleA.push(a.name);
+				storyTitleB.push(b.name);
+			}
+			let depth = 0;
+			while (storyTitleA[depth] || storyTitleB[depth]) {
+				if (!storyTitleA[depth]) return -1;
+				if (!storyTitleB[depth]) return 1;
+				const nameA = storyTitleA[depth];
+				const nameB = storyTitleB[depth];
+				if (nameA !== nameB) {
+					let indexA = order.indexOf(nameA);
+					let indexB = order.indexOf(nameB);
+					const indexWildcard = order.indexOf("*");
+					if (indexA !== -1 || indexB !== -1) {
+						if (indexA === -1) {
+							if (indexWildcard !== -1) indexA = indexWildcard;
+							else indexA = order.length;
+						}
+						if (indexB === -1) {
+							if (indexWildcard !== -1) indexB = indexWildcard;
+							else indexB = order.length;
+						}
+						return indexA - indexB;
+					}
+					if (method === "configure") return 0;
+					return nameA.localeCompare(nameB, options.locales ? options.locales : void 0, {
+						numeric: true,
+						sensitivity: "accent"
+					});
+				}
+				let index = order.indexOf(nameA);
+				if (index === -1) index = order.indexOf("*");
+				const nestedOrder = order[index + 1];
+				order = index !== -1 && Array.isArray(nestedOrder) ? nestedOrder : [];
+				depth += 1;
+			}
+			/* istanbul ignore next */
+			return 0;
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/story-index/sortStories.ts
+var toComparator, sortStoriesCommon, sortStoriesV7;
+function init_sortStories() {
+	return (init_sortStories = __esmMin((() => {
+		init_esm();
+		init_storySort();
+		toComparator = (storySortParameter) => typeof storySortParameter === "function" ? storySortParameter : storySort(Array.isArray(storySortParameter) ? { order: storySortParameter } : storySortParameter);
+		sortStoriesCommon = (stories, storySortParameter, fileNameOrder) => {
+			if (storySortParameter) stories.sort(toComparator(storySortParameter));
+			else stories.sort((s1, s2) => fileNameOrder.indexOf(s1.importPath) - fileNameOrder.indexOf(s2.importPath));
+			return stories;
+		};
+		sortStoriesV7 = (stories, storySortParameter, fileNameOrder) => {
+			try {
+				return sortStoriesCommon(stories, storySortParameter, fileNameOrder);
+			} catch (err) {
+				throw new Error(dedent`
+    Error sorting stories with sort parameter ${storySortParameter}:
+
+    > ${err.message}
+
+    Are you using a V6-style sort function in V7 mode?
+
+    More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#v7-style-story-sort
+  `);
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/utils/story-index-filters.ts
+/** Was this docs entry generated by a `.mdx` file (as opposed to an autodocs page)? */
+function isMdxEntry({ tags }) {
+	return tags?.includes(Tag.UNATTACHED_MDX) || tags?.includes(Tag.ATTACHED_MDX);
+}
+function init_story_index_filters() {
+	return (init_story_index_filters = __esmMin((() => {
+		init_tags();
+	})))();
+}
+//#endregion
+//#region src/shared/constants/iframe-resize.ts
+var IFRAME_RESIZE_CONTEXT, IFRAME_RESIZE_REQUEST_CONTEXT, iframeResizeViewportsEqual;
+function init_iframe_resize() {
+	return (init_iframe_resize = __esmMin((() => {
+		IFRAME_RESIZE_CONTEXT = "iframe.resize";
+		IFRAME_RESIZE_REQUEST_CONTEXT = "iframe.resize.request";
+		iframeResizeViewportsEqual = (left, right) => {
+			if (left === right) return true;
+			if (!left || !right) return !left && !right;
+			return left.name === right.name && left.value === right.value && left.width === right.width && left.height === right.height;
+		};
+	})))();
+}
+//#endregion
+export { matchesHostname as A, init_events as C, init_status_store as D, REVIEW_STATUS_TYPE_ID as E, init_universal_store as M, LOOPBACK_HOSTNAMES as O, REVIEW_NAMESPACE as S, NON_AGGREGATED_STATUS_TYPE_IDS as T, init_preview as _, init_story_index_filters as a, init_tags as b, sortStoriesV7 as c, userOrAutoTitleFromSpecifier as d, init_preview$2 as f, getService as g, preview_default$1 as h, init_iframe_resize as i, UniversalStore as j, init_local_hosts as k, init_autoTitle as l, init_preview$1 as m, IFRAME_RESIZE_REQUEST_CONTEXT as n, isMdxEntry as o, preview_default as p, iframeResizeViewportsEqual as r, init_sortStories as s, IFRAME_RESIZE_CONTEXT as t, userOrAutoTitle as u, registerService as v, CHANGE_DETECTION_STATUS_TYPE_ID as w, REVIEW_EVENTS as x, Tag as y };