ignotum 0.0.13 → 0.0.15

package/dist/runtime/router-BSBI1oN1.js

@@ -0,0 +1,2377 @@
+import { A as RuntimeFileMetadata, B as makeFileValue, D as encodeTransportObject, E as decodeTransportValue, F as fileIdOf, G as InvocationId, H as AppId, I as fileLimits, J as TableId, K as SessionEpoch, L as fileMimeTypes, N as fileFormats, P as fileGrantUrlOf, R as grantFileValue, U as GeneratedId, W as IdAlphabet, Y as VersionId, _ as Result$1, a as SessionResponse, d as sessionPath, f as sessionRequestsPath, i as SessionRequest, j as RuntimeFileOccurrence, k as FileId, l as developmentSelectionKey, n as SessionOutcome, o as SessionState, p as initial, q as SubscriptionId, r as SessionRedirect, t as DevelopmentSelection, x as pending, y as failureFromWire, z as isFileValue } from "./id--1m0NuUL.js";
+import { a as ActivationGeneration, i as WireSuccess, l as DataHistoryId, n as WireFailure, o as AppStateRevision, r as WireResult, t as FunctionAddress, u as InvocationKey } from "./sync-DzUwA8W9.js";
+import { a as RouteDefinition, d as RecoveryIdentity, f as RecoverySessionId, l as appDefinitionLimits, n as getRouteDefinition, p as sameExecutionSelection, r as LayoutDefinition, u as ExecutionSelection } from "./routes-Ce8TVP-T.js";
+import { Array as Array$1, Cause, Context, DateTime, Deferred, Effect, ErrorReporter, Layer, ManagedRuntime, Option, Predicate, Schema, Semaphore, String as String$1 } from "effect";
+import { customAlphabet } from "nanoid";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { useContext, useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
+import { createContext, createElement } from "preact";
+//#region ../contracts/dist/json.js
+const encodeJson = (value) => {
+	if (Array$1.isArray(value)) return `[${value.map(encodeJson).join(",")}]`;
+	if (value === null || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return JSON.stringify(value);
+	return `{${Array$1.sortWith(Object.entries(value), ([key]) => key, String$1.Order).map(([key, field]) => `${JSON.stringify(key)}:${encodeJson(field)}`).join(",")}}`;
+};
+const encodeCanonicalJson = (value) => encodeJson(Schema.decodeSync(Schema.Json)(value));
+//#endregion
+//#region src/client/errors.ts
+/** @effect-diagnostics globalConsole:skip-file */
+var ConnectionUnavailable = class extends Schema.TaggedError()("ConnectionUnavailable", {
+	cause: Schema.optional(Schema.Defect()),
+	message: Schema.String
+}) {};
+var PlatformUpgrading = class extends Schema.TaggedError()("PlatformUpgrading", { message: Schema.String }) {};
+var InvalidMutationArguments = class extends Schema.TaggedError()("InvalidMutationArguments", {
+	cause: Schema.Defect(),
+	function: FunctionAddress,
+	message: Schema.String
+}) {};
+var InvalidServerMessage = class extends Schema.TaggedError()("InvalidServerMessage", {
+	cause: Schema.Defect(),
+	message: Schema.String
+}) {};
+var ServerError = class extends Schema.TaggedError()("ServerError", {
+	code: Schema.Literals([
+		"PlatformUpgrading",
+		"SessionExpired",
+		"InvalidMessage",
+		"Unavailable",
+		"InvalidArguments",
+		"InvocationIdConflict",
+		"ResourceLimitExceeded"
+	]),
+	message: Schema.String
+}) {};
+const ClientInfrastructureError = Schema.Union([
+	PlatformUpgrading,
+	ConnectionUnavailable,
+	InvalidMutationArguments,
+	InvalidServerMessage,
+	ServerError
+]);
+const browserErrorReporter = ErrorReporter.make(({ attributes, error }) => {
+	globalThis.console.error("Ignotum infrastructure error", error, attributes);
+});
+const clientErrorReporterLayer = ErrorReporter.layer([browserErrorReporter]);
+Effect.fn("ClientErrorReporter.report")(function* (error) {
+	yield* ErrorReporter.report(Cause.fail(error));
+});
+//#endregion
+//#region ../shared/dist/id.js
+const decodeGenerated = (definition, payload) => Schema.decodeSync(definition)(definition.idPrefix === void 0 ? payload : `${definition.idPrefix}_${payload}`);
+var IdGenerator = class IdGenerator extends Context.Service()("@ignotum/shared/id/IdGenerator") {
+	static layer = Layer.sync(IdGenerator, () => {
+		const generatePayload = customAlphabet(IdAlphabet, 24);
+		return IdGenerator.of({ generate: (definition) => Effect.sync(() => decodeGenerated(definition, generatePayload())) });
+	});
+	static deterministic = (startAt = 1) => Layer.sync(IdGenerator, () => {
+		const counters = /* @__PURE__ */ new Map();
+		return IdGenerator.of({ generate: (definition) => Effect.sync(() => {
+			const counter = (counters.get(definition.idPrefix) ?? startAt - 1) + 1;
+			counters.set(definition.idPrefix, counter);
+			return decodeGenerated(definition, counter.toString(36).padStart(24, "0"));
+		}) });
+	});
+};
+//#endregion
+//#region src/client/files.ts
+const Files = { url: (file) => {
+	const url = fileGrantUrlOf(file);
+	if (url === void 0) throw new Error("This FileValue has no active query grant.");
+	return url;
+} };
+const formatByMime = {};
+for (const format of fileFormats) formatByMime[fileMimeTypes[format]] = format;
+const MutationObject = Schema.ObjectKeyword.check(Schema.makeFilter((value) => Object.prototype.toString.call(value) === "[object Object]", { message: "Mutation objects must contain ordinary fields; built-in collections are unsupported." }));
+const collectNativeFiles = (value, files) => {
+	if (value instanceof File) {
+		files.add(value);
+		return;
+	}
+	if (isFileValue(value) || Predicate.isDate(value)) return;
+	if (globalThis.Array.isArray(value)) {
+		for (const child of value) collectNativeFiles(child, files);
+		return;
+	}
+	if (!Predicate.isObject(value)) return;
+	for (const child of Object.values(Schema.decodeSync(MutationObject)(value))) collectNativeFiles(child, files);
+};
+const replaceNativeFiles = (value, replacements) => {
+	if (value instanceof File) return replacements.get(value);
+	if (isFileValue(value) || Predicate.isDate(value)) return value;
+	if (globalThis.Array.isArray(value)) return value.map((child) => replaceNativeFiles(child, replacements));
+	if (!Predicate.isObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, replaceNativeFiles(child, replacements)]));
+};
+const prepareMutationArguments = Effect.fn("SyncClient.prepareMutationArguments")(function* (input) {
+	const ids = yield* IdGenerator;
+	const unique = yield* Effect.try(() => {
+		const files = /* @__PURE__ */ new Set();
+		collectNativeFiles(input, files);
+		if (files.size > fileLimits.filesPerMutation) throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
+		if ([...files].reduce((total, file) => total + file.size, 0) > fileLimits.mutationBytes) throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
+		return files;
+	});
+	const replacements = /* @__PURE__ */ new Map();
+	const nativeFiles = /* @__PURE__ */ new Map();
+	for (const file of unique) {
+		const format = yield* Effect.try(() => {
+			const format = formatByMime[file.type.toLowerCase()];
+			if (format === void 0) throw new Error(`File '${file.name}' has unsupported media type '${file.type || "unknown"}'.`);
+			if (file.size === 0 || file.size > fileLimits.fileBytes) throw new Error(`File '${file.name}' must be between 1 and ${fileLimits.fileBytes} bytes.`);
+			if (new TextEncoder().encode(file.name).byteLength > fileLimits.filenameBytes) throw new Error(`File '${file.name}' has a filename that is too long.`);
+			return format;
+		});
+		const id = yield* ids.generate(FileId);
+		replacements.set(file, makeFileValue(id, {
+			format,
+			name: file.name,
+			size: file.size
+		}));
+		nativeFiles.set(id, file);
+	}
+	return {
+		value: unique.size === 0 ? input : yield* Effect.try(() => replaceNativeFiles(input, replacements)),
+		nativeFiles,
+		fileIds: Array.from(nativeFiles.keys())
+	};
+});
+const applyFileGrants = (value, grants) => {
+	if (grants.length === 0) return value;
+	const byId = /* @__PURE__ */ new Map();
+	for (const grant of grants) {
+		if (byId.has(grant.id)) throw new Error("A query file grant ID is duplicated.");
+		byId.set(grant.id, grant.url);
+	}
+	const matched = /* @__PURE__ */ new Set();
+	const visit = (current) => {
+		if (isFileValue(current)) {
+			const id = fileIdOf(current);
+			const url = byId.get(id);
+			if (url === void 0) return current;
+			matched.add(id);
+			return grantFileValue(current, url);
+		}
+		if (globalThis.Array.isArray(current)) return current.map(visit);
+		if (!Predicate.isObject(current) || Predicate.isDate(current)) return current;
+		return Object.fromEntries(Object.entries(current).map(([key, child]) => [key, visit(child)]));
+	};
+	const granted = visit(value);
+	if (matched.size !== byId.size) throw new Error("A query file grant has no result value.");
+	return granted;
+};
+const uploadPreparedFiles = Effect.fn("uploadPreparedFiles")(function* (nativeFiles, uploads, functionAddress) {
+	const expected = new Set(nativeFiles.keys());
+	const received = /* @__PURE__ */ new Set();
+	const transfers = [];
+	for (const upload of uploads) {
+		if (!expected.has(upload.id) || received.has(upload.id)) return yield* InvalidServerMessage.make({
+			cause: /* @__PURE__ */ new Error(`Unexpected prepared file '${upload.id}'.`),
+			message: "The server returned invalid application file preparation data."
+		});
+		received.add(upload.id);
+		const file = nativeFiles.get(upload.id);
+		if (file === void 0) return yield* InvalidServerMessage.make({
+			cause: /* @__PURE__ */ new Error(`Missing native file '${upload.id}'.`),
+			message: "The server prepared an unknown application file."
+		});
+		if (upload.url === void 0) continue;
+		transfers.push({
+			file,
+			url: upload.url
+		});
+	}
+	if (received.size !== expected.size) return yield* InvalidServerMessage.make({
+		cause: /* @__PURE__ */ new Error("The server omitted a prepared file."),
+		message: "The server returned incomplete application file preparation data."
+	});
+	yield* Effect.forEach(transfers, Effect.fn("SyncClient.uploadFile")(function* ({ file, url }) {
+		const response = yield* Effect.tryPromise({
+			try: (signal) => fetch(url, {
+				method: "PUT",
+				body: file,
+				headers: { "content-type": file.type },
+				signal
+			}),
+			catch: (cause) => ConnectionUnavailable.make({
+				cause,
+				message: `File '${file.name}' could not be uploaded.`
+			})
+		});
+		if (!response.ok) {
+			const detail = yield* Effect.promise(() => response.text());
+			return yield* InvalidMutationArguments.make({
+				cause: new Error(detail),
+				function: functionAddress,
+				message: `File '${file.name}' was rejected by application storage.`
+			});
+		}
+	}), {
+		concurrency: 3,
+		discard: true
+	});
+});
+//#endregion
+//#region src/client/id.ts
+var IdRequestError = class extends Schema.TaggedError()("IdRequestError", { message: Schema.String }) {};
+const outcomeKey = "ignotum.id.outcome";
+const selectionJson = Schema.fromJsonString(DevelopmentSelection);
+var BrowserSession = class BrowserSession extends Context.Service()("ignotum/client/id/BrowserSession") {
+	static layer = Layer.effect(BrowserSession, Effect.gen(function* () {
+		const client = (yield* HttpClient.HttpClient).pipe(HttpClient.filterStatusOk);
+		const ids = yield* IdGenerator;
+		const bootstrapLock = yield* Semaphore.make(1);
+		const listeners = /* @__PURE__ */ new Set();
+		let state = { status: "pending" };
+		let current;
+		let generation = 0;
+		let deadline = Infinity;
+		let development = false;
+		let selection;
+		let expiry;
+		const notify = () => {
+			for (const listener of listeners) listener();
+		};
+		const suspend = (error) => {
+			generation += 1;
+			deadline = Infinity;
+			if (expiry !== void 0) clearTimeout(expiry);
+			current = void 0;
+			state = error === void 0 ? {
+				status: "pending",
+				outcome: state.outcome
+			} : {
+				status: "error",
+				error,
+				outcome: state.outcome
+			};
+			notify();
+		};
+		const accept = (session, serverTime) => {
+			generation += 1;
+			if (expiry !== void 0) clearTimeout(expiry);
+			current = session;
+			state = session.user === null ? {
+				status: "signedOut",
+				outcome: state.outcome
+			} : {
+				status: "signedIn",
+				user: session.user,
+				outcome: state.outcome
+			};
+			const delay = Math.max(0, session.validUntil - serverTime);
+			deadline = performance.now() + delay;
+			if (delay < 2147483647) expiry = setTimeout(() => suspend(), delay);
+			notify();
+		};
+		const checkExpiry = () => {
+			if (current !== void 0 && performance.now() >= deadline) suspend();
+		};
+		globalThis.addEventListener?.("focus", checkExpiry);
+		globalThis.document?.addEventListener("visibilitychange", checkExpiry);
+		yield* Effect.addFinalizer(() => Effect.sync(() => {
+			if (expiry !== void 0) clearTimeout(expiry);
+			listeners.clear();
+			globalThis.removeEventListener?.("focus", checkExpiry);
+			globalThis.document?.removeEventListener("visibilitychange", checkExpiry);
+		}));
+		const readOutcome = () => {
+			try {
+				const raw = globalThis.sessionStorage.getItem(outcomeKey);
+				if (raw !== null) {
+					const decoded = Schema.decodeUnknownOption(SessionOutcome)(raw);
+					if (Option.isSome(decoded)) state = {
+						...state,
+						outcome: decoded.value
+					};
+					globalThis.sessionStorage.removeItem(outcomeKey);
+				}
+			} catch {}
+		};
+		const parameters = () => {
+			if (!development || selection === void 0) return "";
+			const params = new URLSearchParams({ epoch: selection.epoch });
+			if (selection.username !== null) params.set("username", selection.username);
+			return `?${params}`;
+		};
+		const readSession = Effect.fn("BrowserSession.read")(function* () {
+			return yield* client.get(`${sessionPath}${parameters()}`, { headers: { "x-ignotum-request": "1" } }).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(SessionResponse)));
+		});
+		let bootstrapGeneration = 0;
+		const bootstrap = bootstrapLock.withPermits(1)(Effect.gen(function* () {
+			const admittedGeneration = generation;
+			bootstrapGeneration = admittedGeneration;
+			const startedAt = performance.now();
+			let session = yield* readSession();
+			development = session.development === true;
+			if (development && selection === void 0) {
+				const saved = globalThis.sessionStorage.getItem(developmentSelectionKey);
+				const decoded = saved === null ? Option.none() : Schema.decodeOption(selectionJson)(saved);
+				selection = Option.getOrElse(decoded, () => ({
+					formatVersion: 1,
+					username: null,
+					epoch: ""
+				}));
+				if (selection.epoch === "") selection = {
+					...selection,
+					epoch: yield* ids.generate(SessionEpoch)
+				};
+				globalThis.sessionStorage.setItem(developmentSelectionKey, Schema.encodeSync(selectionJson)(selection));
+				session = yield* readSession();
+			}
+			if (generation !== admittedGeneration) {
+				if (current !== void 0) return current;
+				return yield* IdRequestError.make({ message: "Your ID session changed while loading." });
+			}
+			readOutcome();
+			if (session.outcome !== void 0) state = {
+				...state,
+				outcome: session.outcome
+			};
+			accept(session, session.serverTime + performance.now() - startedAt);
+			return session;
+		})).pipe(Effect.mapError(() => IdRequestError.make({ message: "Could not load your ID session." })), Effect.tapError((error) => Effect.sync(() => {
+			if (generation === bootstrapGeneration) suspend(error.message);
+		})));
+		const start = Effect.fn("BrowserSession.start")(function* (intent, profile, returnTo) {
+			const session = current ?? (yield* bootstrap);
+			if (intent === "requestProfile" && session.user === null) return yield* IdRequestError.make({ message: "Sign in before requesting profile information." });
+			const request = yield* Schema.decodeUnknownEffect(SessionRequest)({
+				intent,
+				profile,
+				sessionEpoch: session.sessionEpoch,
+				returnTo: returnTo ?? `${globalThis.location.pathname}${globalThis.location.search}${globalThis.location.hash}`
+			}).pipe(Effect.mapError(() => IdRequestError.make({ message: "The ID request is invalid." })));
+			const redirect = yield* HttpClientRequest.post(sessionRequestsPath).pipe(HttpClientRequest.setHeader("x-ignotum-request", "1"), HttpClientRequest.bodyJsonUnsafe(request), client.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(SessionRedirect)), Effect.mapError(() => IdRequestError.make({ message: "Could not start the ID request." })));
+			if (current?.sessionEpoch !== session.sessionEpoch) return yield* IdRequestError.make({ message: "Your ID session changed. Try again." });
+			globalThis.location.assign(redirect.redirectUrl);
+		});
+		const signOut = Effect.gen(function* () {
+			const session = current ?? (yield* bootstrap);
+			yield* HttpClientRequest.delete(sessionPath).pipe(HttpClientRequest.setHeader("x-ignotum-request", "1"), HttpClientRequest.bodyJsonUnsafe({ sessionEpoch: session.sessionEpoch }), client.execute, Effect.mapError(() => IdRequestError.make({ message: "Could not sign out." })));
+			suspend();
+			if (development) {
+				selection = {
+					formatVersion: 1,
+					username: null,
+					epoch: yield* ids.generate(SessionEpoch)
+				};
+				globalThis.sessionStorage.setItem(developmentSelectionKey, Schema.encodeSync(selectionJson)(selection));
+			}
+			globalThis.location.reload();
+		});
+		return BrowserSession.of({
+			snapshot: () => {
+				checkExpiry();
+				return state;
+			},
+			current: () => {
+				checkExpiry();
+				return current;
+			},
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			},
+			accept,
+			suspend,
+			bootstrap,
+			start,
+			signOut,
+			socketParameters: parameters
+		});
+	})).pipe(Layer.provide(FetchHttpClient.layer));
+};
+//#endregion
+//#region ../contracts/dist/runtime/index.js
+const IndexIdentity = Schema.String.pipe(Schema.brand("ignotum/runtime/IndexIdentity"));
+const EncodedIndexKey = Schema.String.check(Schema.isPattern(/^(?:[0-9a-f]{2})*$/)).pipe(Schema.brand("ignotum/runtime/EncodedIndexKey"));
+Schema.Union([
+	Schema.Boolean,
+	Schema.Finite,
+	Schema.String
+]);
+Schema.String.pipe(Schema.brand("ignotum/hosted/QueryKey"));
+const TableDependency = Schema.Struct({
+	type: Schema.Literal("Table"),
+	tableId: TableId
+});
+const DocumentDependency = Schema.Struct({
+	type: Schema.Literal("Document"),
+	tableId: TableId,
+	id: GeneratedId
+});
+const IndexRangeDependency = Schema.Struct({
+	type: Schema.Literal("IndexRange"),
+	tableId: TableId,
+	index: IndexIdentity,
+	lower: Schema.optional(EncodedIndexKey),
+	upper: Schema.optional(EncodedIndexKey)
+});
+const IndexPointInvalidation = Schema.Struct({
+	type: Schema.Literal("IndexPoint"),
+	tableId: TableId,
+	index: IndexIdentity,
+	key: EncodedIndexKey
+});
+const IdDependency = Schema.Struct({ type: Schema.Literal("Id") });
+const ReadDependency = Schema.Union([
+	IdDependency,
+	TableDependency,
+	DocumentDependency,
+	IndexRangeDependency
+]);
+const WriteInvalidation = Schema.Union([
+	TableDependency,
+	DocumentDependency,
+	IndexPointInvalidation
+]);
+Schema.Union([ReadDependency, IndexPointInvalidation]);
+const DependencySet = Schema.Array(ReadDependency);
+const InvalidationSet = Schema.Array(WriteInvalidation);
+const RuntimeQueryResult = Schema.Struct({
+	type: Schema.Literal("Query"),
+	result: WireResult,
+	dependencies: DependencySet,
+	observedRevision: AppStateRevision,
+	files: Schema.optional(Schema.Array(RuntimeFileOccurrence))
+});
+const FileReferenceAdded = Schema.Struct({
+	type: Schema.Literal("AddReference"),
+	file: RuntimeFileMetadata,
+	tableId: TableId,
+	documentId: GeneratedId
+});
+const FileReferenceRemoved = Schema.Struct({
+	type: Schema.Literal("RemoveReference"),
+	fileId: FileId,
+	tableId: TableId,
+	documentId: GeneratedId
+});
+const FileReferenceEffect = Schema.Union([FileReferenceAdded, FileReferenceRemoved]);
+const FileEffectBatch = Schema.Struct({
+	id: InvocationId,
+	dataHistoryId: Schema.optional(DataHistoryId),
+	committedRevision: AppStateRevision,
+	effects: Schema.Array(FileReferenceEffect)
+});
+Schema.Struct({ appId: AppId });
+Schema.Struct({ batches: Schema.Array(FileEffectBatch) });
+Schema.Struct({
+	appId: AppId,
+	invocationId: InvocationId,
+	acknowledgedAt: Schema.Int,
+	dataHistoryId: DataHistoryId
+});
+Schema.Struct({ completed: Schema.Literal(true) });
+const RuntimeMutationSuccess = Schema.Struct({
+	type: Schema.Literal("Mutation"),
+	result: WireSuccess,
+	invalidations: InvalidationSet,
+	committedRevision: AppStateRevision,
+	fileEffects: Schema.optional(FileEffectBatch)
+});
+const RuntimeMutationFailure = Schema.Struct({
+	type: Schema.Literal("Mutation"),
+	result: WireFailure
+});
+const RuntimeMutationResult = Schema.Union([RuntimeMutationSuccess, RuntimeMutationFailure]);
+Schema.Union([RuntimeQueryResult, RuntimeMutationResult]);
+const RuntimeRecoveryOwner = Schema.Struct({
+	clientSessionId: RecoverySessionId,
+	sessionEpoch: Schema.NullOr(Schema.String)
+});
+Schema.Struct({
+	appId: AppId,
+	identity: RecoveryIdentity,
+	owner: RuntimeRecoveryOwner
+});
+const RuntimeMutationOutcome = Schema.Union([
+	Schema.Struct({
+		type: Schema.Literal("Settled"),
+		result: RuntimeMutationResult
+	}),
+	Schema.Struct({ type: Schema.Literal("Interrupted") }),
+	Schema.Struct({ type: Schema.Literal("Pending") }),
+	Schema.Struct({ type: Schema.Literal("Uncertain") })
+]);
+const InvocationBase = {
+	appId: AppId,
+	versionId: VersionId,
+	generation: ActivationGeneration,
+	selection: Schema.optional(ExecutionSelection),
+	invocationKey: InvocationKey,
+	function: FunctionAddress,
+	args: Schema.Json,
+	identity: Schema.optional(SessionState)
+};
+const QueryInvocation = Schema.Struct({
+	...InvocationBase,
+	type: Schema.Literal("Query")
+});
+const MutationInvocation = Schema.Struct({
+	...InvocationBase,
+	type: Schema.Literal("Mutation"),
+	invocationId: InvocationId,
+	recoveryOwner: Schema.optional(RuntimeRecoveryOwner),
+	files: Schema.optional(Schema.Array(RuntimeFileOccurrence))
+});
+Schema.Union([QueryInvocation, MutationInvocation]);
+Schema.Struct({
+	appId: AppId,
+	expectedRevision: AppStateRevision
+});
+Schema.Struct({ currentRevision: AppStateRevision });
+var RuntimeVersionUnavailable = class extends Schema.TaggedError()("RuntimeVersionUnavailable", {
+	versionId: VersionId,
+	message: Schema.String
+}) {};
+const RuntimeInvocationRejectionCode = Schema.Literals([
+	"SessionExpired",
+	"FunctionUnavailable",
+	"InvalidArguments",
+	"InvocationIdConflict",
+	"ResourceLimitExceeded",
+	"UnknownFunction",
+	"WrongFunctionKind"
+]);
+var RuntimeInvocationRejected = class extends Schema.TaggedError()("RuntimeInvocationRejected", {
+	code: RuntimeInvocationRejectionCode,
+	invocationKey: InvocationKey,
+	message: Schema.String
+}) {};
+var RuntimeInvocationUnavailable = class extends Schema.TaggedError()("RuntimeInvocationUnavailable", {
+	invocationKey: InvocationKey,
+	message: Schema.String
+}) {};
+Schema.TaggedError()("RuntimeRevisionRejected", {
+	appId: AppId,
+	message: Schema.String
+});
+Schema.Union([
+	RuntimeVersionUnavailable,
+	RuntimeInvocationRejected,
+	RuntimeInvocationUnavailable
+]);
+//#endregion
+//#region ../contracts/dist/managed-sync.js
+const managedSyncPath = "/_ignotum/v2/sync";
+const managedSelectionPath = "/_ignotum/v2/selection";
+const ManagedSelectionResponse = Schema.Struct({
+	protocolVersion: Schema.Literal(1),
+	selection: ExecutionSelection
+});
+const ManagedClientMessage = Schema.Union([
+	Schema.Struct({
+		type: Schema.Literal("Connect"),
+		protocolVersion: Schema.Natural,
+		selection: ExecutionSelection,
+		clientSessionId: RecoverySessionId
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Prepare"),
+		invocationId: InvocationId,
+		function: FunctionAddress,
+		args: Schema.Json,
+		files: Schema.Array(FileId).check(Schema.isMaxLength(fileLimits.filesPerMutation))
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Invoke"),
+		invocationId: InvocationId,
+		function: FunctionAddress,
+		args: Schema.Json
+	}),
+	Schema.Struct({
+		type: Schema.Literal("RecoverMutation"),
+		id: Schema.String.check(Schema.isMaxLength(128)),
+		identity: RecoveryIdentity
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Subscribe"),
+		id: SubscriptionId,
+		function: FunctionAddress,
+		args: Schema.Json
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Unsubscribe"),
+		id: SubscriptionId
+	})
+]);
+/** Decode this envelope before the normal server protocol, including on unsupported versions. */
+const ManagedUpgradeRequired = Schema.Struct({
+	type: Schema.Literal("UpgradeRequired"),
+	selection: ExecutionSelection
+});
+const ManagedServerMessage = Schema.Union([
+	ManagedUpgradeRequired,
+	Schema.Struct({
+		type: Schema.Literal("Handshake"),
+		protocolVersion: Schema.Literal(1),
+		selection: ExecutionSelection,
+		session: SessionState,
+		serverTime: Schema.Finite
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Preparation"),
+		invocationId: InvocationId,
+		uploads: Schema.Array(Schema.Struct({
+			id: FileId,
+			url: Schema.optional(Schema.String)
+		}))
+	}),
+	Schema.Struct({
+		type: Schema.Literal("MutationOutcome"),
+		id: Schema.String,
+		identity: RecoveryIdentity,
+		outcome: RuntimeMutationOutcome
+	}),
+	Schema.Struct({
+		type: Schema.Literal("QuerySnapshot"),
+		selection: ExecutionSelection,
+		id: SubscriptionId,
+		result: RuntimeQueryResult,
+		files: Schema.optional(Schema.Array(Schema.Struct({
+			id: FileId,
+			url: Schema.String
+		})))
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Error"),
+		id: Schema.optional(Schema.String),
+		code: Schema.Literals([
+			"PlatformUpgrading",
+			"SessionExpired",
+			"InvalidMessage",
+			"Unavailable",
+			"InvalidArguments",
+			"InvocationIdConflict",
+			"ResourceLimitExceeded"
+		]),
+		message: Schema.String
+	})
+]);
+//#endregion
+//#region src/client/managed-upgrade.ts
+const TabStateV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	appId: AppId,
+	clientSessionId: RecoverySessionId,
+	attempts: Schema.Natural.check(Schema.isLessThanOrEqualTo(3)),
+	attemptedAt: Schema.Natural,
+	target: Schema.NullOr(ExecutionSelection),
+	uncertainStorage: Schema.Boolean
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+const TabState = initial(TabStateV1);
+const TabStateJson = Schema.fromJsonString(TabState);
+/** One attempt owns admission, the settling deadline, and the reload across target changes. */
+var ManagedUpgrade = class {
+	selection;
+	browser;
+	callbacks;
+	clientSessionId;
+	key;
+	tab;
+	snapshot = {
+		phase: "connecting",
+		recovery: []
+	};
+	listeners = /* @__PURE__ */ new Set();
+	target;
+	attempt;
+	disposed = false;
+	storageAvailable = true;
+	readyTimer;
+	constructor(selection, browser, callbacks) {
+		this.selection = selection;
+		this.browser = browser;
+		this.callbacks = callbacks;
+		this.key = `ignotum.managed.tab.${selection.appId}`;
+		this.tab = {
+			formatVersion: 1,
+			appId: selection.appId,
+			clientSessionId: RecoverySessionId.make(`rec_${browser.crypto.randomUUID().replaceAll("-", "").slice(0, 24)}`),
+			attempts: 0,
+			attemptedAt: 0,
+			target: null,
+			uncertainStorage: false
+		};
+		try {
+			const raw = browser.sessionStorage.getItem(this.key);
+			if (raw !== null) {
+				const decoded = Schema.decodeOption(TabStateJson)(raw);
+				if (Option.isSome(decoded) && decoded.value.appId === selection.appId && (decoded.value.target === null || decoded.value.target.appId === selection.appId)) this.tab = decoded.value;
+				else this.reportRecovery("Saved update information could not be read. Previous mutation outcomes may be unknown.");
+			}
+		} catch {
+			this.storageAvailable = false;
+		}
+		const history = Schema.decodeUnknownOption(Schema.Struct({ __ignotumUpdate: TabState }))(browser.history.state);
+		if (Option.isSome(history) && history.value.__ignotumUpdate.appId === selection.appId && history.value.__ignotumUpdate.attemptedAt >= this.tab.attemptedAt && (history.value.__ignotumUpdate.target === null || history.value.__ignotumUpdate.target.appId === selection.appId)) this.tab = history.value.__ignotumUpdate;
+		if (this.tab.uncertainStorage) this.reportRecovery("Some previous mutation outcomes could not be saved in browser storage and remain unknown.");
+		this.clientSessionId = this.tab.clientSessionId;
+		this.save();
+	}
+	getSnapshot = () => this.snapshot;
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	update(next) {
+		if (this.disposed) return;
+		this.snapshot = next;
+		for (const listener of this.listeners) listener();
+	}
+	reportRecovery(message) {
+		if (!this.snapshot.recovery.includes(message)) this.update({
+			...this.snapshot,
+			recovery: [...this.snapshot.recovery, message].slice(-100)
+		});
+	}
+	dismissRecovery = () => {
+		this.tab = {
+			...this.tab,
+			uncertainStorage: false
+		};
+		this.save();
+		this.update({
+			...this.snapshot,
+			recovery: []
+		});
+	};
+	save() {
+		let saved = false;
+		try {
+			this.browser.sessionStorage.setItem(this.key, Schema.encodeSync(TabStateJson)(this.tab));
+			this.storageAvailable = true;
+			saved = true;
+		} catch {
+			this.storageAvailable = false;
+		}
+		try {
+			const existing = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))(this.browser.history.state);
+			this.browser.history.replaceState({
+				...Option.getOrElse(existing, () => ({})),
+				__ignotumUpdate: Schema.encodeSync(TabState)(this.tab)
+			}, "");
+			saved = true;
+		} catch {}
+		return saved;
+	}
+	get obsolete() {
+		return this.target !== void 0 || this.attempt !== void 0;
+	}
+	get ready() {
+		return this.snapshot.phase === "ready" && !this.obsolete;
+	}
+	connecting() {
+		if (this.readyTimer !== void 0) clearTimeout(this.readyTimer);
+		if (!this.obsolete) this.update({
+			...this.snapshot,
+			phase: "connecting",
+			message: void 0
+		});
+	}
+	accepted() {
+		if (this.obsolete) return;
+		this.update({
+			...this.snapshot,
+			phase: "ready",
+			message: void 0
+		});
+		if (this.readyTimer !== void 0) clearTimeout(this.readyTimer);
+		this.readyTimer = setTimeout(() => {
+			this.tab = {
+				...this.tab,
+				attempts: 0,
+				attemptedAt: 0,
+				target: null
+			};
+			this.save();
+		}, 6e4);
+	}
+	unavailable(message = "The app could not check for updates. Reconnect and try again.") {
+		if (this.readyTimer !== void 0) clearTimeout(this.readyTimer);
+		if (!this.obsolete) this.update({
+			...this.snapshot,
+			phase: "error",
+			message
+		});
+	}
+	require(target) {
+		if (this.disposed) return Promise.resolve();
+		if (target !== void 0) this.target = target;
+		this.callbacks.stopAdmission();
+		if (this.attempt !== void 0 && this.snapshot.phase !== "error") return this.attempt;
+		if (this.readyTimer !== void 0) clearTimeout(this.readyTimer);
+		this.update({
+			...this.snapshot,
+			phase: "settling",
+			message: "Updating the app. Waiting briefly for pending changes…"
+		});
+		this.attempt = this.run();
+		return this.attempt;
+	}
+	async run() {
+		const deadline = Date.now() + 2e3;
+		while (!this.disposed && this.callbacks.unresolved() > 0 && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 25));
+		if (this.disposed) return;
+		try {
+			const issues = this.callbacks.persist();
+			for (const issue of issues) this.reportRecovery(issue);
+			if (issues.length > 0) {
+				this.tab = {
+					...this.tab,
+					uncertainStorage: true
+				};
+				await new Promise((resolve) => setTimeout(resolve, 1e3));
+			}
+			const fresh = await this.callbacks.freshSelection();
+			if (fresh !== void 0 && fresh.appId !== this.selection.appId) throw new Error("The app address now refers to a different app.");
+			this.target = fresh ?? this.target;
+			const response = await this.browser.fetch(this.browser.location.href, {
+				cache: "no-store",
+				credentials: "same-origin",
+				headers: { accept: "text/html" },
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (!response.ok) throw new Error("The updated app document is temporarily unavailable.");
+			await response.body?.cancel();
+			if (this.disposed) return;
+			const attempts = fresh !== void 0 && this.tab.target !== null && !sameExecutionSelection(this.tab.target, fresh) ? 0 : this.tab.attempts;
+			if (attempts >= 2) throw new Error("The app update could not load a consistent release. Try again when the connection or release is available.");
+			this.tab = {
+				...this.tab,
+				attempts: attempts + 1,
+				attemptedAt: Date.now(),
+				target: fresh ?? this.target ?? this.selection
+			};
+			if (!this.save()) throw new Error("Browser storage is unavailable. Pending changes may have unknown outcomes. Use Reload app to continue the update.");
+			this.update({
+				...this.snapshot,
+				phase: "reloading",
+				message: "Loading the updated app…"
+			});
+			this.callbacks.reload();
+		} catch (error) {
+			this.update({
+				...this.snapshot,
+				phase: "error",
+				message: error instanceof Error ? error.message : "The app update could not be loaded. Try again."
+			});
+		}
+	}
+	/** An explicit retry resets the automatic budget, while obsolete code remains fenced. */
+	retry = () => {
+		if (this.disposed) return;
+		if (!this.storageAvailable) {
+			this.callbacks.persist();
+			this.callbacks.reload();
+			return;
+		}
+		this.tab = {
+			...this.tab,
+			attempts: 0,
+			attemptedAt: 0
+		};
+		this.save();
+		this.attempt = void 0;
+		this.require(this.target);
+	};
+	async check() {
+		if (this.obsolete || this.disposed) return false;
+		try {
+			const fresh = await this.callbacks.freshSelection();
+			if (fresh === void 0 || !sameExecutionSelection(this.selection, fresh)) {
+				this.require(fresh);
+				return false;
+			}
+			return !this.obsolete && !this.disposed;
+		} catch {
+			this.unavailable();
+			return false;
+		}
+	}
+	dispose() {
+		this.disposed = true;
+		if (this.readyTimer !== void 0) clearTimeout(this.readyTimer);
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/client/recovery-journal.ts
+const RecoveryJournalLimits = {
+	maxEntries: 100,
+	retentionMs: 864e5,
+	maxBytes: 65536
+};
+const RecoveryEntry = Schema.Struct({
+	identity: RecoveryIdentity,
+	recordedAt: Schema.Natural,
+	expiresAt: Schema.Natural,
+	state: Schema.Literals([
+		"pending",
+		"settled",
+		"interrupted",
+		"uncertain"
+	])
+});
+const RecoveryJournalV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	appId: AppId,
+	sessionEpoch: Schema.String,
+	clientSessionId: RecoverySessionId,
+	entries: Schema.Array(RecoveryEntry).check(Schema.isMaxLength(RecoveryJournalLimits.maxEntries))
+}).check(Schema.makeFilter((record) => {
+	const keys = record.entries.map((entry) => identityKey(entry.identity));
+	return new Set(keys).size === keys.length && record.entries.every((entry) => entry.identity.originalSelection.appId === record.appId && entry.expiresAt > entry.recordedAt && entry.expiresAt - entry.recordedAt <= RecoveryJournalLimits.retentionMs);
+})).annotate({ parseOptions: { onExcessProperty: "error" } });
+const RecoveryJournalRecord = initial(RecoveryJournalV1);
+const identityKey = (identity) => `${identity.originalSelection.dataHistoryId}/${identity.invocationId}`;
+const bytes = (value) => new TextEncoder().encode(value).byteLength;
+/** sessionStorage isolates tabs. A cloned tab may look up copied identities, never replay them. */
+var RecoveryJournal = class {
+	options;
+	storageKey;
+	clientSessionId;
+	constructor(options) {
+		this.options = options;
+		this.storageKey = `ignotum:recovery:${options.appId}`;
+		this.clientSessionId = options.clientSessionId;
+	}
+	storage() {
+		const storage = this.options.storage;
+		return storage === void 0 ? globalThis.sessionStorage : Predicate.isFunction(storage) ? storage() : storage;
+	}
+	now() {
+		return this.options.now?.() ?? DateTime.toEpochMillis(DateTime.nowUnsafe());
+	}
+	snapshot(entries, issues) {
+		return {
+			clientSessionId: this.clientSessionId,
+			entries,
+			issues
+		};
+	}
+	read() {
+		let raw;
+		try {
+			raw = this.storage().getItem(this.storageKey);
+		} catch {
+			return this.snapshot([], ["denied"]);
+		}
+		if (raw === null) return this.snapshot([], []);
+		if (bytes(raw) > RecoveryJournalLimits.maxBytes) return this.discard("full");
+		const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(RecoveryJournalRecord))(raw);
+		if (parsed._tag === "None" || parsed.value.appId !== this.options.appId) return this.discard("corrupt");
+		if (parsed.value.sessionEpoch !== this.options.sessionEpoch) return this.discard("session-changed");
+		this.clientSessionId = parsed.value.clientSessionId;
+		const now = this.now();
+		const entries = parsed.value.entries.filter((entry) => entry.expiresAt > now && entry.recordedAt <= now);
+		const issues = entries.length === parsed.value.entries.length ? [] : ["expired"];
+		return issues.length === 0 ? this.snapshot(entries, issues) : this.persist(entries, issues);
+	}
+	discard(issue) {
+		try {
+			this.storage().removeItem(this.storageKey);
+			return this.snapshot([], [issue]);
+		} catch {
+			return this.snapshot([], [issue, "denied"]);
+		}
+	}
+	persist(entries, issues) {
+		const record = {
+			formatVersion: 1,
+			appId: this.options.appId,
+			sessionEpoch: this.options.sessionEpoch,
+			clientSessionId: this.clientSessionId,
+			entries
+		};
+		const encoded = Schema.encodeOption(Schema.fromJsonString(RecoveryJournalRecord))(record);
+		if (encoded._tag === "None") return this.snapshot(entries, [...issues, "corrupt"]);
+		if (bytes(encoded.value) > RecoveryJournalLimits.maxBytes) return this.snapshot(entries, [...issues, "full"]);
+		try {
+			this.storage().setItem(this.storageKey, encoded.value);
+			return this.snapshot(entries, issues);
+		} catch (error) {
+			return this.snapshot(entries, [...issues, error instanceof DOMException && error.name === "QuotaExceededError" ? "full" : "denied"]);
+		}
+	}
+	/** Call before abandoning the page; any issue means durable recovery is not proven. */
+	write(identities) {
+		const current = this.read();
+		if (current.issues.includes("denied")) return current;
+		const entries = new Map(current.entries.map((entry) => [identityKey(entry.identity), entry]));
+		const now = this.now();
+		for (const identity of identities) {
+			if (identity.originalSelection.appId !== this.options.appId) return this.snapshot(current.entries, [...current.issues, "corrupt"]);
+			const key = identityKey(identity);
+			if (!entries.has(key)) entries.set(key, {
+				identity: {
+					invocationId: identity.invocationId,
+					originalSelection: identity.originalSelection
+				},
+				recordedAt: now,
+				expiresAt: now + RecoveryJournalLimits.retentionMs,
+				state: "pending"
+			});
+		}
+		if (entries.size > RecoveryJournalLimits.maxEntries) return this.snapshot(current.entries, [...current.issues, "full"]);
+		return this.persist([...entries.values()], current.issues);
+	}
+	reconcile(identity, state) {
+		const current = this.read();
+		if (current.issues.includes("denied")) return current;
+		return this.persist(current.entries.map((entry) => identityKey(entry.identity) === identityKey(identity) ? {
+			...entry,
+			state
+		} : entry), current.issues);
+	}
+	remove(identity) {
+		const current = this.read();
+		if (current.issues.includes("denied")) return current;
+		return this.persist(current.entries.filter((entry) => identityKey(entry.identity) !== identityKey(identity)), current.issues);
+	}
+	clear() {
+		try {
+			this.storage().removeItem(this.storageKey);
+			return this.snapshot([], []);
+		} catch {
+			return this.snapshot([], ["denied"]);
+		}
+	}
+};
+//#endregion
+//#region src/client/managed-client.ts
+const issueMessage = (issue) => {
+	switch (issue) {
+		case "denied": return "Browser storage is unavailable. Some previous mutation outcomes may be unknown.";
+		case "full": return "Browser recovery storage is full. Some mutation outcomes could not be saved.";
+		case "corrupt": return "Saved mutation information could not be read. Its outcomes remain unknown.";
+		case "expired": return "Some saved mutation information expired. Its outcomes remain unknown.";
+		case "session-changed": return "The browser session changed. Previous mutation outcomes cannot be retrieved in this session.";
+	}
+};
+/** The managed connection is mounted by bootstrap, independently of query observers. */
+var ManagedBrowserClient = class {
+	selection;
+	browser;
+	helpers;
+	upgrade;
+	queries;
+	socket;
+	acceptedSocket;
+	session;
+	ids;
+	sessionEpoch;
+	sessionViewRevision;
+	unsubscribeSession;
+	sessionDeadline = 0;
+	clientSessionId;
+	journal;
+	pending = /* @__PURE__ */ new Map();
+	recovery = /* @__PURE__ */ new Map();
+	recoveryDeadlines = /* @__PURE__ */ new Map();
+	recoveryTimeouts = /* @__PURE__ */ new Map();
+	recoveryTimers = /* @__PURE__ */ new Set();
+	reconnectTimer;
+	handshakeTimer;
+	sessionTimer;
+	heartbeat;
+	reconnectDelay = 250;
+	disposed = false;
+	readyWaiters = /* @__PURE__ */ new Set();
+	suspended = true;
+	lastActivity = Date.now();
+	validation;
+	connectionGeneration = 0;
+	constructor(selection, browser, helpers, callbacks) {
+		this.selection = selection;
+		this.browser = browser;
+		this.helpers = helpers;
+		this.upgrade = new ManagedUpgrade(selection, browser, {
+			stopAdmission: () => {
+				this.suspended = true;
+				for (const pending of this.pending.values()) if (pending.preparation !== void 0) Deferred.doneUnsafe(pending.prepared, Effect.fail(PlatformUpgrading.make({ message: "The app is updating. This upload was interrupted before its mutation ran." })));
+				callbacks.stopAdmission();
+			},
+			unresolved: () => this.pending.size,
+			persist: () => this.persistPending(),
+			reload: callbacks.reload,
+			freshSelection: this.freshSelection
+		});
+		this.clientSessionId = this.upgrade.clientSessionId;
+		this.queries = helpers.makeQueryCache(Effect.suspend(() => this.ids === void 0 ? Effect.die("The client identity service is not ready.") : this.ids.generate(SubscriptionId)), (message) => Effect.sync(() => {
+			if (this.canSend()) this.send(message);
+		}));
+	}
+	attachSession(session, ids) {
+		if (this.disposed) return;
+		this.unsubscribeSession?.();
+		this.session = session;
+		this.ids = ids;
+		this.unsubscribeSession = session.subscribe(() => {
+			const current = session.current();
+			if (current === void 0 || this.sessionEpoch !== void 0 && (current.sessionEpoch !== this.sessionEpoch || current.viewRevision !== this.sessionViewRevision)) {
+				this.queries.invalidatePrivate();
+				this.suspended = true;
+				this.acceptedSocket = void 0;
+				this.socket?.close();
+			}
+		});
+	}
+	whenReady() {
+		if (this.upgrade.ready) return Promise.resolve(true);
+		if (this.upgrade.obsolete || this.disposed) return Promise.resolve(false);
+		return new Promise((resolve) => {
+			const finish = (ready) => {
+				unsubscribe();
+				this.readyWaiters.delete(finish);
+				resolve(ready);
+			};
+			const unsubscribe = this.upgrade.subscribe(() => {
+				if (this.upgrade.ready || this.upgrade.obsolete || this.disposed) finish(this.upgrade.ready);
+			});
+			this.readyWaiters.add(finish);
+		});
+	}
+	retry = () => {
+		if (this.upgrade.obsolete) this.upgrade.retry();
+		else this.resume();
+	};
+	recoverLoad = async () => {
+		await this.upgrade.check();
+	};
+	freshSelection = async () => {
+		const response = await this.browser.fetch(managedSelectionPath, {
+			cache: "no-store",
+			credentials: "same-origin",
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) throw new Error("The current app selection is unavailable.");
+		const current = Schema.decodeUnknownOption(ManagedSelectionResponse)(await response.json());
+		return Option.getOrUndefined(current)?.selection;
+	};
+	start() {
+		if (this.disposed) return;
+		this.browser.addEventListener("pageshow", this.resume);
+		this.browser.addEventListener("pagehide", this.hide);
+		this.browser.addEventListener("online", this.resume);
+		this.browser.addEventListener("offline", this.offline);
+		this.browser.addEventListener("focus", this.resume);
+		this.browser.document.addEventListener("visibilitychange", this.visibility);
+		this.heartbeat = setInterval(() => {
+			const now = Date.now();
+			if (now - this.lastActivity > 15e3) this.resume();
+			this.lastActivity = now;
+		}, 5e3);
+		this.connect();
+	}
+	canSend() {
+		return !this.disposed && !this.suspended && !this.upgrade.obsolete && this.acceptedSocket !== void 0 && this.acceptedSocket === this.socket && this.socket.readyState === 1 && Date.now() < this.sessionDeadline;
+	}
+	send(message) {
+		if (this.socket?.readyState !== 1) return;
+		this.socket.send(Schema.encodeSync(Schema.fromJsonString(ManagedClientMessage))(message));
+	}
+	connect() {
+		if (this.disposed || this.upgrade.obsolete) return;
+		this.suspended = true;
+		this.upgrade.connecting();
+		this.acceptedSocket = void 0;
+		this.recovery.clear();
+		for (const timer of this.recoveryTimers) clearTimeout(timer);
+		this.recoveryTimers.clear();
+		this.recoveryTimeouts.clear();
+		if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
+		if (this.handshakeTimer !== void 0) clearTimeout(this.handshakeTimer);
+		this.socket?.close();
+		this.socket = void 0;
+		const generation = ++this.connectionGeneration;
+		if (this.session === void 0) return;
+		Effect.runPromise(this.session.bootstrap).then(() => {
+			if (this.disposed || this.upgrade.obsolete || generation !== this.connectionGeneration) return;
+			this.openSocket();
+		}, () => {
+			if (this.disposed || this.upgrade.obsolete || generation !== this.connectionGeneration) return;
+			this.upgrade.unavailable("The browser session could not be verified. Reconnecting…");
+			this.reconnectTimer = setTimeout(() => this.connect(), 1e3);
+		});
+	}
+	openSocket() {
+		const url = new URL(managedSyncPath, this.browser.location.href);
+		url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+		const socket = new WebSocket(url);
+		this.socket = socket;
+		socket.onopen = () => {
+			if (this.socket !== socket || this.disposed) return;
+			this.send({
+				type: "Connect",
+				protocolVersion: 1,
+				selection: this.selection,
+				clientSessionId: this.clientSessionId
+			});
+		};
+		this.handshakeTimer = setTimeout(() => {
+			if (this.socket === socket && this.acceptedSocket !== socket) socket.close();
+		}, 1e4);
+		socket.onmessage = (event) => {
+			if (this.socket !== socket || this.disposed) return;
+			const stable = Schema.decodeUnknownOption(Schema.fromJsonString(ManagedUpgradeRequired))(event.data);
+			if (Option.isSome(stable)) {
+				this.upgrade.require(stable.value.selection);
+				return;
+			}
+			const decoded = Schema.decodeUnknownOption(Schema.fromJsonString(ManagedServerMessage))(event.data);
+			if (Option.isNone(decoded)) {
+				this.upgrade.require();
+				return;
+			}
+			this.message(socket, decoded.value);
+		};
+		socket.onerror = () => socket.close();
+		socket.onclose = (event) => {
+			if (this.socket !== socket || this.disposed) return;
+			if (event.code === 1012 || event.code === 1008) this.queries.invalidatePrivate();
+			this.acceptedSocket = void 0;
+			this.suspended = true;
+			if (this.handshakeTimer !== void 0) clearTimeout(this.handshakeTimer);
+			if (this.upgrade.obsolete) return;
+			this.upgrade.unavailable("The connection was lost. Checking for updates before resuming…");
+			this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectDelay);
+			this.reconnectDelay = Math.min(this.reconnectDelay * 2, 5e3);
+		};
+	}
+	message(socket, message) {
+		if (message.type === "UpgradeRequired") {
+			this.upgrade.require(message.selection);
+			return;
+		}
+		if (message.type === "Handshake") {
+			if (!sameExecutionSelection(this.selection, message.selection)) {
+				this.upgrade.require(message.selection);
+				return;
+			}
+			if (this.upgrade.obsolete) return;
+			if (this.handshakeTimer !== void 0) clearTimeout(this.handshakeTimer);
+			const previousEpoch = this.sessionEpoch;
+			if (previousEpoch !== void 0 && (previousEpoch !== message.session.sessionEpoch || this.sessionViewRevision !== message.session.viewRevision)) this.queries.invalidatePrivate();
+			this.sessionEpoch = message.session.sessionEpoch;
+			this.sessionViewRevision = message.session.viewRevision;
+			this.sessionDeadline = Date.now() + Math.max(0, message.session.validUntil - message.serverTime);
+			if (this.sessionTimer !== void 0) clearTimeout(this.sessionTimer);
+			this.sessionTimer = setTimeout(() => {
+				this.session?.suspend();
+				this.queries.invalidatePrivate();
+				this.resume();
+			}, Math.min(2147483647, Math.max(0, this.sessionDeadline - Date.now())));
+			this.session?.accept(message.session, message.serverTime);
+			this.journal = new RecoveryJournal({
+				appId: this.selection.appId,
+				sessionEpoch: message.session.sessionEpoch,
+				clientSessionId: this.clientSessionId,
+				storage: () => this.browser.sessionStorage
+			});
+			const saved = this.journal.read();
+			for (const issue of saved.issues) this.upgrade.reportRecovery(issueMessage(issue));
+			if (saved.clientSessionId !== this.clientSessionId) {
+				this.clientSessionId = saved.clientSessionId;
+				this.connect();
+				return;
+			}
+			if (previousEpoch !== void 0 && previousEpoch !== this.sessionEpoch) {
+				for (const [id, pending] of this.pending) {
+					Deferred.doneUnsafe(pending.prepared, Effect.fail(ConnectionUnavailable.make({ message: "The session changed before file preparation completed." })));
+					this.upgrade.reportRecovery(`Mutation ${id} has an unknown outcome because the session changed.`);
+					Deferred.doneUnsafe(pending.done, Effect.fail(ConnectionUnavailable.make({ message: "The session changed. This mutation may already have completed." })));
+				}
+				this.pending.clear();
+			}
+			this.acceptedSocket = socket;
+			this.suspended = false;
+			this.reconnectDelay = 250;
+			this.upgrade.accepted();
+			for (const entry of this.queries.entries()) this.send({
+				type: "Subscribe",
+				id: entry.subscriptionId,
+				function: entry.function,
+				args: entry.args
+			});
+			for (const entry of saved.entries) if (entry.state === "pending") {
+				if (!this.pending.has(entry.identity.invocationId)) this.recover(entry.identity);
+			} else {
+				this.upgrade.reportRecovery(`Mutation ${entry.identity.invocationId}: ${entry.state}.`);
+				this.journal.remove(entry.identity);
+			}
+			for (const pending of this.pending.values()) if (pending.preparation !== void 0) this.send(pending.preparation);
+			else this.recover(pending.identity);
+			this.journal.write([]);
+			return;
+		}
+		if (this.acceptedSocket !== socket) {
+			socket.close();
+			return;
+		}
+		switch (message.type) {
+			case "Preparation": {
+				if (!this.canSend()) return;
+				const pending = this.pending.get(message.invocationId);
+				if (pending?.preparation !== void 0) Deferred.doneUnsafe(pending.prepared, Effect.succeed(message.uploads));
+				return;
+			}
+			case "QuerySnapshot": {
+				if (!this.canSend()) return;
+				if (!sameExecutionSelection(this.selection, message.selection)) {
+					this.upgrade.require(message.selection);
+					return;
+				}
+				const result = Effect.runSync(this.helpers.resultFromWire(message.result.result, message.files).pipe(Effect.catchTags({ InvalidServerMessage: (error) => Effect.succeed(error) })));
+				this.queries.setResult(message.id, result, message.result.observedRevision);
+				return;
+			}
+			case "MutationOutcome":
+				if (!sameExecutionSelection(message.identity.originalSelection, this.selection) && !this.recovery.has(message.id)) return;
+				this.outcome(message.id, message.identity, message.outcome);
+				return;
+			case "Error":
+				if (message.code === "PlatformUpgrading") {
+					this.upgrade.require();
+					return;
+				}
+				if (message.code === "SessionExpired") {
+					this.suspended = true;
+					this.session?.suspend();
+					this.queries.invalidatePrivate();
+					socket.close();
+					return;
+				}
+				if (message.code === "InvalidArguments" || message.code === "InvocationIdConflict" || message.code === "ResourceLimitExceeded") {
+					for (const [invocationId, pending] of this.pending) {
+						if (invocationId !== message.id) continue;
+						const failure = Effect.fail(ServerError.make({
+							code: message.code,
+							message: message.message
+						}));
+						Deferred.doneUnsafe(pending.prepared, failure);
+						Deferred.doneUnsafe(pending.done, failure);
+						this.pending.delete(invocationId);
+						this.journal?.remove(pending.identity);
+						return;
+					}
+					for (const query of this.queries.entries()) {
+						if (query.subscriptionId !== message.id) continue;
+						this.queries.setResult(query.subscriptionId, ServerError.make({
+							code: message.code,
+							message: message.message
+						}));
+						return;
+					}
+					return;
+				}
+				this.upgrade.unavailable(message.message);
+				socket.close();
+				return;
+		}
+	}
+	recover(identity) {
+		if (!this.canSend()) return;
+		const id = `recovery:${identity.originalSelection.dataHistoryId}:${identity.invocationId}`;
+		if (this.recovery.has(id)) return;
+		this.recovery.set(id, identity);
+		const deadline = this.recoveryDeadlines.get(id) ?? Date.now() + 3e4;
+		this.recoveryDeadlines.set(id, deadline);
+		if (Date.now() >= deadline) {
+			this.outcome(id, identity, { type: "Uncertain" });
+			return;
+		}
+		this.send({
+			type: "RecoverMutation",
+			id,
+			identity
+		});
+		const timer = setTimeout(() => {
+			this.recoveryTimers.delete(timer);
+			this.recoveryTimeouts.delete(id);
+			if (!this.recovery.has(id)) return;
+			this.recovery.delete(id);
+			this.recover(identity);
+		}, 5e3);
+		this.recoveryTimers.add(timer);
+		this.recoveryTimeouts.set(id, timer);
+	}
+	outcome(id, identity, outcome) {
+		const recovery = this.recovery.get(id);
+		const pending = this.pending.get(identity.invocationId);
+		if (recovery === void 0 && pending === void 0) return;
+		const expected = recovery ?? pending.identity;
+		if (expected.invocationId !== identity.invocationId || !sameExecutionSelection(expected.originalSelection, identity.originalSelection)) return;
+		this.recovery.delete(id);
+		const timeout = this.recoveryTimeouts.get(id);
+		if (timeout !== void 0) {
+			clearTimeout(timeout);
+			this.recoveryTimers.delete(timeout);
+			this.recoveryTimeouts.delete(id);
+		}
+		if (outcome.type === "Pending") {
+			const timer = setTimeout(() => {
+				this.recoveryTimers.delete(timer);
+				this.recover(identity);
+			}, 1e3);
+			this.recoveryTimers.add(timer);
+			return;
+		}
+		const recoveryId = `recovery:${identity.originalSelection.dataHistoryId}:${identity.invocationId}`;
+		this.recovery.delete(recoveryId);
+		this.recoveryDeadlines.delete(recoveryId);
+		if (pending !== void 0) {
+			this.pending.delete(identity.invocationId);
+			if (outcome.type === "Settled") Deferred.doneUnsafe(pending.done, this.helpers.resultFromWire(outcome.result.result));
+			else Deferred.doneUnsafe(pending.done, Effect.fail(ConnectionUnavailable.make({ message: outcome.type === "Interrupted" ? "The mutation was interrupted before it committed." : "The mutation outcome is unknown. Check the app before trying it again." })));
+		}
+		const state = outcome.type === "Settled" ? "settled" : outcome.type === "Interrupted" ? "interrupted" : "uncertain";
+		if (recovery !== void 0 || outcome.type !== "Settled") {
+			const detail = outcome.type === "Settled" ? outcome.result.result.type === "Success" ? "completed" : "completed with an error" : state;
+			this.upgrade.reportRecovery(`Mutation ${identity.invocationId}: ${detail}.`);
+		}
+		for (const issue of this.journal?.reconcile(identity, state).issues ?? []) this.upgrade.reportRecovery(issueMessage(issue));
+		for (const issue of this.journal?.remove(identity).issues ?? []) this.upgrade.reportRecovery(issueMessage(issue));
+	}
+	persistPending() {
+		if (this.pending.size === 0) return [];
+		if (this.journal === void 0) return ["Pending mutation outcomes could not be saved and remain unknown."];
+		return this.journal.write([...this.pending.values()].map((entry) => entry.identity)).issues.map(issueMessage);
+	}
+	observe = Effect.fn("ManagedBrowserClient.observe")((address, args) => this.queries.observe(address, args));
+	mutate = Effect.fn("ManagedBrowserClient.mutate")(function* (address, args) {
+		if (this.upgrade.obsolete) return yield* PlatformUpgrading.make({ message: "The platform is updating. Try again after the app reloads." });
+		const valid = yield* Effect.promise(() => this.validate());
+		if (this.upgrade.obsolete) return yield* PlatformUpgrading.make({ message: "The platform is updating. Try again after the app reloads." });
+		if (!valid || !this.canSend() || this.sessionEpoch === void 0) return yield* ConnectionUnavailable.make({ message: "The app must reconnect and verify its selection before accepting a mutation." });
+		if (this.pending.size >= RecoveryJournalLimits.maxEntries) return yield* ConnectionUnavailable.make({ message: "Too many mutations are waiting for outcomes. Wait for them to settle before trying again." });
+		const ids = this.ids;
+		if (ids === void 0) return yield* ConnectionUnavailable.make({ message: "The client is not ready." });
+		const prepared = yield* prepareMutationArguments(args).pipe(Effect.provideService(IdGenerator, ids), Effect.mapError((cause) => InvalidMutationArguments.make({
+			cause,
+			function: address,
+			message: "The mutation arguments cannot be sent."
+		})));
+		const encoded = yield* Effect.try({
+			try: () => encodeTransportObject(prepared.value),
+			catch: (cause) => InvalidMutationArguments.make({
+				cause,
+				function: address,
+				message: "The mutation arguments cannot be sent."
+			})
+		});
+		if (!this.canSend()) return yield* PlatformUpgrading.make({ message: "The app is reconnecting or updating. Try again when it is ready." });
+		const invocationId = yield* ids.generate(InvocationId);
+		const done = yield* Deferred.make();
+		const identity = {
+			invocationId,
+			originalSelection: this.selection
+		};
+		const uploadsReady = yield* Deferred.make();
+		const preparation = prepared.fileIds.length === 0 ? void 0 : {
+			type: "Prepare",
+			invocationId,
+			function: address,
+			args: encoded,
+			files: prepared.fileIds
+		};
+		this.pending.set(invocationId, {
+			identity,
+			sessionEpoch: this.sessionEpoch,
+			done,
+			prepared: uploadsReady,
+			preparation
+		});
+		for (const issue of this.persistPending()) this.upgrade.reportRecovery(issue);
+		if (preparation !== void 0) {
+			this.send(preparation);
+			yield* Effect.gen({ self: this }, function* () {
+				const uploads = yield* Deferred.await(uploadsReady);
+				yield* uploadPreparedFiles(prepared.nativeFiles, uploads, address);
+				if (!this.canSend()) return yield* PlatformUpgrading.make({ message: "The app is reconnecting or updating. Try again when it is ready." });
+			}).pipe(Effect.tapError(() => Effect.sync(() => {
+				this.pending.delete(invocationId);
+				this.journal?.remove(identity);
+			})));
+			const pending = this.pending.get(invocationId);
+			if (pending === void 0) return yield* Deferred.await(done);
+			this.pending.set(invocationId, {
+				...pending,
+				preparation: void 0
+			});
+		}
+		this.send({
+			type: "Invoke",
+			invocationId,
+			function: address,
+			args: encoded
+		});
+		const timer = setTimeout(() => {
+			this.recoveryTimers.delete(timer);
+			if (this.pending.has(invocationId)) this.recover(identity);
+		}, 5e3);
+		this.recoveryTimers.add(timer);
+		return yield* Deferred.await(done);
+	}).bind(this);
+	validate = () => {
+		if (this.upgrade.obsolete || this.disposed) return Promise.resolve(false);
+		if (this.validation !== void 0) return this.validation;
+		this.validation = this.upgrade.check().then((current) => {
+			const ready = current && this.canSend();
+			if (ready && this.upgrade.getSnapshot().phase !== "ready") this.upgrade.accepted();
+			return ready;
+		}).finally(() => {
+			this.validation = void 0;
+		});
+		return this.validation;
+	};
+	resume = () => {
+		if (this.disposed || this.upgrade.obsolete) return;
+		this.suspended = true;
+		this.acceptedSocket = void 0;
+		this.recovery.clear();
+		this.queries.invalidate(void 0);
+		this.connect();
+	};
+	offline = () => {
+		this.suspended = true;
+		this.acceptedSocket = void 0;
+		this.upgrade.unavailable("The app is offline. Reconnect to check for updates and mutation outcomes.");
+		this.socket?.close();
+	};
+	hide = () => {
+		for (const issue of this.persistPending()) this.upgrade.reportRecovery(issue);
+		this.suspended = true;
+		this.acceptedSocket = void 0;
+		this.socket?.close();
+	};
+	visibility = () => {
+		if (this.browser.document.visibilityState === "visible") this.resume();
+		else this.hide();
+	};
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const finish of this.readyWaiters) finish(false);
+		this.unsubscribeSession?.();
+		this.persistPending();
+		this.socket?.close();
+		if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
+		if (this.handshakeTimer !== void 0) clearTimeout(this.handshakeTimer);
+		if (this.sessionTimer !== void 0) clearTimeout(this.sessionTimer);
+		if (this.heartbeat !== void 0) clearInterval(this.heartbeat);
+		for (const timer of this.recoveryTimers) clearTimeout(timer);
+		this.browser.removeEventListener("pageshow", this.resume);
+		this.browser.removeEventListener("pagehide", this.hide);
+		this.browser.removeEventListener("online", this.resume);
+		this.browser.removeEventListener("offline", this.offline);
+		this.browser.removeEventListener("focus", this.resume);
+		this.browser.document.removeEventListener("visibilitychange", this.visibility);
+		this.upgrade.dispose();
+	}
+};
+//#endregion
+//#region src/client/sync.ts
+const queryKey = (functionAddress, args) => encodeCanonicalJson([functionAddress, args]);
+const subscribeMessage = (entry) => ({
+	type: "Subscribe",
+	id: entry.subscriptionId,
+	function: entry.function,
+	args: entry.args
+});
+const makeQueryCache = (allocateId, sendLifecycleMessage) => {
+	const queries = /* @__PURE__ */ new Map();
+	const queriesById = /* @__PURE__ */ new Map();
+	const observe = Effect.fn("SyncClient.QueryCache.observe")(function* (functionAddress, args) {
+		const key = queryKey(functionAddress, args);
+		let entry = queries.get(key);
+		if (entry === void 0) {
+			const created = {
+				args,
+				function: functionAddress,
+				generation: 0,
+				listeners: /* @__PURE__ */ new Set(),
+				revision: void 0,
+				references: 0,
+				result: pending(),
+				subscriptionId: yield* allocateId
+			};
+			queries.set(key, created);
+			queriesById.set(created.subscriptionId, created);
+			yield* sendLifecycleMessage(subscribeMessage(created));
+			entry = created;
+		}
+		const observed = entry;
+		observed.references += 1;
+		observed.generation += 1;
+		let released = false;
+		return {
+			getSnapshot: () => observed.result,
+			subscribe: (listener) => {
+				observed.listeners.add(listener);
+				return () => observed.listeners.delete(listener);
+			},
+			release: Effect.gen(function* () {
+				if (released) return;
+				released = true;
+				observed.references -= 1;
+				if (observed.references !== 0) return;
+				const generation = ++observed.generation;
+				yield* Effect.sleep("25 millis");
+				if (observed.references !== 0 || observed.generation !== generation || queries.get(key) !== observed) return;
+				queries.delete(key);
+				queriesById.delete(observed.subscriptionId);
+				yield* sendLifecycleMessage({
+					type: "Unsubscribe",
+					id: observed.subscriptionId
+				});
+			})
+		};
+	});
+	const clear = (entry) => {
+		entry.result = pending();
+		entry.revision = void 0;
+		for (const listener of entry.listeners) listener();
+	};
+	return {
+		invalidate: (ids) => {
+			for (const entry of queries.values()) if (ids === void 0 || ids.includes(entry.subscriptionId)) clear(entry);
+		},
+		invalidatePrivate: () => {
+			for (const entry of queries.values()) if (entry.dependsOnId !== false) clear(entry);
+		},
+		entries: () => queries.values(),
+		getById: (id) => queriesById.get(id),
+		observe,
+		setResult: (id, result, revision) => {
+			const entry = queriesById.get(id);
+			if (entry === void 0) return;
+			if (revision !== void 0) {
+				if (entry.revision !== void 0 && revision < entry.revision) return;
+				entry.revision = revision;
+			}
+			entry.result = result;
+			for (const listener of entry.listeners) listener();
+		}
+	};
+};
+const syncClientInternals = {
+	makeQueryCache,
+	queryIdentity: queryKey,
+	resultFromWire: Effect.fn("SyncClient.resultFromWire")((wire, files = []) => Effect.try({
+		try: () => wire.type === "Success" ? Result$1.succeed(wire.value === void 0 ? void 0 : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files)) : failureFromWire(wire.error, wire.dates),
+		catch: (cause) => InvalidServerMessage.make({
+			cause,
+			message: "The server returned an invalid function result."
+		})
+	}))
+};
+var SyncClient = class extends Context.Service()("ignotum/client/sync/SyncClient") {};
+const makeUnmountedSyncRuntime = () => ManagedRuntime.make(Layer.succeed(SyncClient)({
+	observe: () => Effect.fail(ConnectionUnavailable.make({ message: "The application has not mounted." })),
+	mutate: () => Effect.fail(ConnectionUnavailable.make({ message: "The application has not mounted." }))
+}).pipe(Layer.provideMerge(BrowserSession.layer), Layer.provideMerge(clientErrorReporterLayer), Layer.provideMerge(IdGenerator.layer)));
+let syncRuntime = makeUnmountedSyncRuntime();
+const mountManagedSync = (selection, browser, callbacks) => {
+	const client = new ManagedBrowserClient(selection, browser, syncClientInternals, callbacks);
+	syncRuntime.dispose();
+	syncRuntime = ManagedRuntime.make(Layer.effect(SyncClient, Effect.gen(function* () {
+		client.attachSession(yield* BrowserSession, yield* IdGenerator);
+		return SyncClient.of({
+			observe: client.observe,
+			mutate: client.mutate
+		});
+	})).pipe(Layer.provideMerge(BrowserSession.layer), Layer.provideMerge(clientErrorReporterLayer), Layer.provideMerge(IdGenerator.layer)));
+	const runtime = syncRuntime;
+	runtime.runPromise(SyncClient).then(() => client.start(), () => client.dispose());
+	return {
+		client,
+		dispose: () => {
+			client.dispose();
+			runtime.dispose();
+			if (syncRuntime === runtime) syncRuntime = makeUnmountedSyncRuntime();
+		}
+	};
+};
+const hot = import.meta.hot;
+if (hot !== void 0) hot.dispose(() => void syncRuntime.dispose());
+//#endregion
+//#region ../shared/dist/routing/pattern.js
+var RoutingDefinitionError = class extends Schema.TaggedError()("RoutingDefinitionError", {
+	message: Schema.String,
+	pattern: Schema.optional(Schema.String)
+}) {};
+const reservedIdentifiers = /* @__PURE__ */ new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+const ParameterName = Schema.String.check(Schema.isPattern(/^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u), Schema.makeFilter((name) => !reservedIdentifiers.has(name) || "Parameter names must be TypeScript identifiers"));
+const CanonicalPattern = RouteDefinition.fields.pattern.check(Schema.makeFilter((pattern) => pattern === "/" || !pattern.endsWith("/") && !pattern.includes("//") || "Patterns must not contain empty segments or trailing slashes"), Schema.makeFilter((pattern) => !/[[\]()\u0000-\u001F\u007F\uD800-\uDFFF]/u.test(pattern) || "Patterns must use decoded literal segments and supported parameter syntax"));
+const invalid$1 = (message, pattern) => new RoutingDefinitionError({
+	message,
+	pattern
+});
+const weight = (segment) => segment.kind === "Literal" ? 3 : segment.kind === "Parameter" ? 2 : 1;
+const segmentText = (segment) => segment.kind === "Literal" ? segment.value : `${segment.kind === "Parameter" ? ":" : "*"}${segment.name}`;
+const makePattern = (segments) => ({
+	pattern: `/${segments.map(segmentText).join("/")}`,
+	segments,
+	precedence: segments.map(weight)
+});
+const structuralKey = (pattern) => JSON.stringify(pattern.segments.map((segment) => segment.kind === "Literal" ? [segment.kind, segment.value] : [segment.kind]));
+const compare = (left, right) => {
+	for (let index = 0; index < Math.max(left.precedence.length, right.precedence.length); index++) {
+		const difference = (right.precedence[index] ?? 0) - (left.precedence[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+};
+const contains = (directory, pattern) => directory.segments.length <= pattern.segments.length && directory.segments.every((segment, index) => segmentText(segment) === segmentText(pattern.segments[index]));
+const parsePattern = Effect.fn("Routing.parsePattern")(function* (input) {
+	const pattern = yield* Schema.decodeUnknownEffect(CanonicalPattern)(input).pipe(Effect.mapError(() => invalid$1("Route patterns must be canonical absolute paths outside /_ignotum.", input)));
+	if (pattern === "/") return makePattern([]);
+	const parts = pattern.slice(1).split("/");
+	if (parts.length > 128) return yield* invalid$1("Route patterns exceed the segment limit.", pattern);
+	const segments = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [index, part] of parts.entries()) if (part.startsWith(":") || part.startsWith("*")) {
+		const name = yield* Schema.decodeUnknownEffect(ParameterName)(part.slice(1)).pipe(Effect.mapError(() => invalid$1("Route parameter names must be valid TypeScript identifiers.", pattern)));
+		if (names.has(name)) return yield* invalid$1(`Repeated route parameter '${name}'.`, pattern);
+		names.add(name);
+		if (part.startsWith("*")) {
+			if (index !== parts.length - 1) return yield* invalid$1("A catch-all must be the final segment.", pattern);
+			segments.push({
+				kind: "CatchAll",
+				name
+			});
+		} else segments.push({
+			kind: "Parameter",
+			name
+		});
+	} else {
+		if (part === "." || part === ".." || /[:*]/.test(part)) return yield* invalid$1("Route literals must not contain dot segments or parameter syntax.", pattern);
+		segments.push({
+			kind: "Literal",
+			value: part
+		});
+	}
+	return makePattern(segments);
+});
+const compileRoute = Effect.fn("Routing.compileRoute")(function* (input) {
+	const route = yield* Schema.decodeUnknownEffect(RouteDefinition)(input).pipe(Effect.mapError(() => invalid$1("The route definition is invalid.")));
+	const parsed = yield* parsePattern(route.pattern);
+	const directory = yield* parsePattern(route.directoryScope ?? route.pattern);
+	if (!contains(directory, parsed) || directory.segments.length < parsed.segments.length - 1) return yield* invalid$1("A route directory must be its full pattern for an index page or its immediate parent for a page file.", route.pattern);
+	if (route.precedence.length !== parsed.precedence.length || route.precedence.some((value, index) => value !== parsed.precedence[index])) return yield* invalid$1("Stored route precedence does not match its pattern.", route.pattern);
+	const parameters = parsed.segments.filter((segment) => segment.kind !== "Literal");
+	if (route.params.length !== parameters.length || new Set(route.params.map((field) => field.name)).size !== route.params.length) return yield* invalid$1("Route parameters must describe each dynamic name exactly once.", route.pattern);
+	for (const parameter of parameters) {
+		const field = route.params.find((field) => field.name === parameter.name);
+		if (field === void 0 || (parameter.kind === "CatchAll" ? field.value.type !== "array" : field.value.type === "array")) return yield* invalid$1("Single parameters require scalar values and catch-alls require string arrays.", route.pattern);
+	}
+	if (new Set(route.searchParams.map((field) => field.name)).size !== route.searchParams.length) return yield* invalid$1("Search parameter names must be unique.", route.pattern);
+	return {
+		pattern: parsed,
+		directory
+	};
+});
+const validateRoutePattern = Effect.fn("Routing.validateRoutePattern")(function* (input) {
+	return (yield* compileRoute(input)).pattern;
+});
+const compilePatterns = Effect.fn("Routing.compilePatterns")(function* (routeInput, layoutInput) {
+	const routes = yield* Schema.decodeUnknownEffect(Schema.Array(RouteDefinition).check(Schema.isMaxLength(appDefinitionLimits.routes)))(routeInput).pipe(Effect.mapError(() => invalid$1("Route definitions are invalid or exceed the route limit.")));
+	const layouts = yield* Schema.decodeUnknownEffect(Schema.Array(LayoutDefinition).check(Schema.isMaxLength(appDefinitionLimits.layouts)))(layoutInput).pipe(Effect.mapError(() => invalid$1("Layout definitions are invalid or exceed the layout limit.")));
+	if (new Set(routes.map((route) => route.id)).size !== routes.length) return yield* invalid$1("Route identities must be unique.");
+	if (new Set(layouts.map((layout) => layout.id)).size !== layouts.length) return yield* invalid$1("Layout identities must be unique.");
+	const parsedRoutes = yield* Effect.forEach(routes, (route) => compileRoute(route));
+	const parsedLayouts = yield* Effect.forEach(layouts, (layout) => parsePattern(layout.scope));
+	if (new Set(parsedRoutes.map((route) => structuralKey(route.pattern))).size !== routes.length) return yield* invalid$1("Duplicate or structurally ambiguous route patterns.");
+	if (new Set(parsedLayouts.map(structuralKey)).size !== layouts.length) return yield* invalid$1("Duplicate or structurally ambiguous layout scopes.");
+	const layoutPatterns = layouts.map((layout, index) => ({
+		layout,
+		pattern: parsedLayouts[index]
+	}));
+	const applicable = (pattern) => layoutPatterns.filter((item) => contains(item.pattern, pattern)).sort((a, b) => a.pattern.segments.length - b.pattern.segments.length).map((item) => item.layout);
+	for (const { layout, pattern } of layoutPatterns) {
+		const ancestors = applicable(pattern).filter((candidate) => candidate.id !== layout.id);
+		if (layout.parent !== ancestors.at(-1)?.id) return yield* invalid$1(`Layout '${layout.id}' must name its nearest directory layout as parent.`, layout.scope);
+	}
+	const directories = /* @__PURE__ */ new Map();
+	const addDirectory = Effect.fn("Routing.addDirectory")(function* (pattern) {
+		const key = structuralKey(pattern);
+		const existing = directories.get(key);
+		if (existing !== void 0 && existing.pattern !== pattern.pattern) return yield* invalid$1("Dynamic directory parameter names are structurally ambiguous.", pattern.pattern);
+		directories.set(key, pattern);
+	});
+	yield* addDirectory(makePattern([]));
+	for (const pattern of parsedLayouts) for (let length = 1; length <= pattern.segments.length; length++) yield* addDirectory(makePattern(pattern.segments.slice(0, length)));
+	const compiledRoutes = [];
+	for (const [index, route] of routes.entries()) {
+		const { pattern, directory } = parsedRoutes[index];
+		const branch = applicable(directory);
+		if (route.layouts.length !== branch.length || route.layouts.some((id, index) => id !== branch[index]?.id)) return yield* invalid$1(`Route '${route.id}' must include its complete directory layout branch.`, route.pattern);
+		for (let length = 1; length <= directory.segments.length; length++) yield* addDirectory(makePattern(directory.segments.slice(0, length)));
+		compiledRoutes.push({
+			route,
+			pattern,
+			layouts: branch
+		});
+	}
+	return {
+		routes: compiledRoutes.sort((a, b) => compare(a.pattern, b.pattern)),
+		directories: [...directories.values()].map((pattern) => ({
+			pattern,
+			layouts: applicable(pattern)
+		})).sort((a, b) => compare(a.pattern, b.pattern))
+	};
+});
+const captures = (pattern, segments, directory) => {
+	const values = [];
+	for (const [index, part] of pattern.segments.entries()) {
+		const value = segments[index];
+		if (value === void 0 || value.length === 0) return void 0;
+		if (part.kind === "Literal") {
+			if (part.value !== value) return void 0;
+		} else if (part.kind === "Parameter") values.push([part.name, value]);
+		else {
+			values.push([part.name, segments.slice(index)]);
+			return Object.fromEntries(values);
+		}
+	}
+	if (!directory && segments.length !== pattern.segments.length) return void 0;
+	return Object.fromEntries(values);
+};
+const matchDirectory = (compiled, decodedSegments) => {
+	if (decodedSegments[0] === "_ignotum") return {
+		route: void 0,
+		layouts: [],
+		params: {}
+	};
+	for (const directory of compiled.directories) {
+		const params = captures(directory.pattern, decodedSegments, true);
+		if (params !== void 0) return {
+			route: void 0,
+			layouts: directory.layouts,
+			params
+		};
+	}
+	return {
+		route: void 0,
+		layouts: [],
+		params: {}
+	};
+};
+const matchPattern = (compiled, decodedSegments) => {
+	if (decodedSegments[0] === "_ignotum") return {
+		route: void 0,
+		layouts: [],
+		params: {}
+	};
+	for (const entry of compiled.routes) {
+		const params = captures(entry.pattern, decodedSegments, false);
+		if (params !== void 0) return {
+			route: entry.route,
+			layouts: entry.layouts,
+			params
+		};
+	}
+	return matchDirectory(compiled, decodedSegments);
+};
+//#endregion
+//#region ../shared/dist/routing/url.js
+const UrlIssue = Schema.Struct({
+	source: Schema.Literals(["params", "searchParams"]),
+	field: Schema.optional(Schema.String),
+	message: Schema.String
+});
+const ParsedLocation = Schema.Struct({
+	segments: Schema.Array(Schema.String),
+	pathname: Schema.String,
+	search: Schema.String,
+	hash: Schema.String,
+	canonicalUrl: Schema.String
+});
+const PartialLocation = Schema.Struct({
+	...ParsedLocation.fields,
+	pathComplete: Schema.Boolean
+});
+var InvalidUrl = class extends Schema.TaggedError()("InvalidUrl", {
+	issues: Schema.Array(UrlIssue),
+	partial: Schema.optional(PartialLocation)
+}) {};
+const invalid = (source, message, field, partial) => InvalidUrl.make({
+	issues: [{
+		source,
+		field,
+		message
+	}],
+	partial
+});
+const invalidField = (source, field) => invalid(source, `The URL field '${field}' does not match its declaration.`, field);
+const SafeSegment = Schema.String.check(Schema.isMinLength(1), Schema.isPattern(/^[^/\\\u0000-\u001f\u007f]+$/u), Schema.makeFilter((value) => value !== "." && value !== ".." || "Dot segments are not allowed"));
+const DecimalText = Schema.String.check(Schema.isPattern(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/));
+const InputRecord = Schema.Record(Schema.String, Schema.Unknown);
+const BuildInput = Schema.Struct({
+	params: Schema.optional(Schema.Unknown),
+	searchParams: Schema.optional(Schema.Unknown),
+	hash: Schema.optional(Schema.String.check(Schema.makeFilter((value) => !value.startsWith("#") || "Hash input must omit the leading #")))
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+const decodeComponent = Effect.fn("Routing.decodeComponent")(function* (value, source, field, partial) {
+	return yield* Effect.try({
+		try: () => {
+			return decodeURIComponent(value);
+		},
+		catch: () => invalid(source, "The URL contains malformed escapes or Unicode.", field, partial)
+	});
+});
+const encodeComponent = Effect.fn("Routing.encodeComponent")(function* (value, source, field) {
+	return yield* Effect.try({
+		try: () => encodeURIComponent(value),
+		catch: () => invalid(source, "The URL contains malformed Unicode.", field)
+	});
+});
+const searchEntries = Effect.fn("Routing.searchEntries")(function* (search, partial) {
+	yield* Schema.decodeUnknownEffect(Schema.String)(search).pipe(Effect.mapError(() => invalid("searchParams", "Search parameters must be URL query text.", void 0, partial)));
+	const query = search.startsWith("?") ? search.slice(1) : search;
+	const entries = [];
+	for (const item of query.split("&")) {
+		if (item === "") continue;
+		const equals = item.indexOf("=");
+		const key = equals < 0 ? item : item.slice(0, equals);
+		const value = equals < 0 ? "" : item.slice(equals + 1);
+		const name = yield* decodeComponent(key.replaceAll("+", " "), "searchParams", void 0, partial);
+		entries.push([name, yield* decodeComponent(value.replaceAll("+", " "), "searchParams", name, partial)]);
+	}
+	return entries;
+});
+/** Parse a raw application-root-relative location before a URL implementation normalizes it. */
+const parseLocation = Effect.fn("Routing.parseLocation")(function* (input) {
+	yield* Schema.decodeUnknownEffect(Schema.String)(input).pipe(Effect.mapError(() => invalid("params", "A location must be URL text.")));
+	const fragmentAt = input.indexOf("#");
+	const hash = fragmentAt < 0 ? "" : input.slice(fragmentAt);
+	const beforeHash = fragmentAt < 0 ? input : input.slice(0, fragmentAt);
+	const queryAt = beforeHash.indexOf("?");
+	const search = queryAt < 0 ? "" : beforeHash.slice(queryAt);
+	const rawPathname = queryAt < 0 ? beforeHash : beforeHash.slice(0, queryAt);
+	const pathname = rawPathname.length > 1 && rawPathname.endsWith("/") ? rawPathname.slice(0, -1) : rawPathname;
+	const segments = [];
+	const partial = (pathComplete) => ({
+		segments: [...segments],
+		pathname,
+		search,
+		hash,
+		canonicalUrl: `${pathname}${search}${hash}`,
+		pathComplete
+	});
+	if (!rawPathname.startsWith("/") || rawPathname.startsWith("//")) return yield* invalid("params", "A location must start with exactly one application-root slash.", void 0, partial(false));
+	if (pathname !== "/") for (const raw of pathname.slice(1).split("/")) {
+		const segment = yield* decodeComponent(raw, "params", void 0, partial(false));
+		yield* Schema.decodeEffect(SafeSegment)(segment).pipe(Effect.mapError(() => invalid("params", "Path segments must be nonempty and cannot contain slashes, dot navigation or control characters.", void 0, partial(false))));
+		segments.push(segment);
+	}
+	yield* searchEntries(search, partial(true));
+	yield* decodeComponent(hash.slice(1), "params", void 0, partial(true));
+	return {
+		segments,
+		pathname,
+		search,
+		hash,
+		canonicalUrl: `${pathname}${search}${hash}`
+	};
+});
+const scalarSchema = (descriptor) => {
+	switch (descriptor.type) {
+		case "string": return Schema.String;
+		case "id": return GeneratedId;
+		case "number": return Schema.Finite;
+		case "integer": return Schema.Int;
+		case "boolean": return Schema.Boolean;
+		case "literal": return Schema.Literal(descriptor.value);
+		case "literals": return Schema.Literals(descriptor.values);
+	}
+};
+const scalarText = Effect.fn("Routing.scalarText")(function* (descriptor, value, source, field) {
+	switch (descriptor.type) {
+		case "number":
+		case "integer":
+			yield* Schema.decodeEffect(DecimalText)(value).pipe(Effect.mapError(() => invalidField(source, field)));
+			return yield* Schema.decodeUnknownEffect(scalarSchema(descriptor))(Number(value)).pipe(Effect.mapError(() => invalidField(source, field)));
+		case "boolean": return (yield* Schema.decodeUnknownEffect(Schema.Literals(["true", "false"]))(value).pipe(Effect.mapError(() => invalidField(source, field)))) === "true";
+		case "literal":
+			yield* Schema.decodeEffect(Schema.Literal(String(descriptor.value)))(value).pipe(Effect.mapError(() => invalidField(source, field)));
+			return descriptor.value;
+		case "literals":
+			yield* Schema.decodeEffect(Schema.Literals(descriptor.values.map(String)))(value).pipe(Effect.mapError(() => invalidField(source, field)));
+			return descriptor.values.find((literal) => String(literal) === value);
+		default: return yield* Schema.decodeUnknownEffect(scalarSchema(descriptor))(value).pipe(Effect.mapError(() => invalidField(source, field)));
+	}
+});
+const suppliedValue = Effect.fn("Routing.suppliedValue")(function* (descriptor, input, source, field) {
+	const schema = descriptor.type === "array" ? Schema.Array(scalarSchema(descriptor.value)) : scalarSchema(descriptor);
+	const value = yield* Schema.decodeUnknownEffect(schema)(input).pipe(Effect.mapError(() => invalidField(source, field)));
+	for (const item of Array$1.ensure(value)) yield* encodeComponent(String(item), source, field);
+	return value;
+});
+const validateDefinition = Effect.fn("Routing.validateUrlDefinition")(function* (input) {
+	const route = yield* Schema.decodeUnknownEffect(RouteDefinition)(input).pipe(Effect.mapError(() => invalid("params", "The route's URL declaration is invalid.")));
+	const pattern = yield* validateRoutePattern(route).pipe(Effect.mapError((error) => invalid("params", error.message)));
+	for (const field of route.searchParams) {
+		yield* encodeComponent(field.name, "searchParams", field.name);
+		if (field.value.type === "default") yield* suppliedValue(field.value.value, field.value.default, "searchParams", field.name);
+	}
+	return {
+		route,
+		pattern
+	};
+});
+const inputRecord = Effect.fn("Routing.inputRecord")(function* (input, fields, source) {
+	const values = yield* Schema.decodeUnknownEffect(InputRecord)(input === void 0 ? {} : input).pipe(Effect.mapError(() => invalid(source, `The ${source} input must be an object.`)));
+	for (const name of Object.keys(values)) if (!fields.some((field) => field.name === name)) return yield* invalid(source, `The URL field '${name}' is not declared.`, name);
+	return values;
+});
+const own = (record, field) => Object.hasOwn(record, field) ? record[field] : void 0;
+const pathValue = Effect.fn("Routing.pathValue")(function* (value, name) {
+	const text = String(value);
+	yield* Schema.decodeEffect(SafeSegment)(text).pipe(Effect.mapError(() => invalidField("params", name)));
+	yield* encodeComponent(text, "params", name);
+	return text;
+});
+/** rawParams already contains decoded segments from parseLocation and must not be decoded twice. */
+const decodeRouteInputs = Effect.fn("Routing.decodeRouteInputs")(function* (input, rawParams, search) {
+	const { route } = yield* validateDefinition(input);
+	const raw = yield* inputRecord(rawParams, route.params, "params");
+	const params = [];
+	for (const field of route.params) {
+		const value = own(raw, field.name);
+		if (field.value.type === "array") {
+			const values = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.String).check(Schema.isMinLength(1)))(value).pipe(Effect.mapError(() => invalidField("params", field.name)));
+			params.push([field.name, yield* Effect.forEach(values, (item) => pathValue(item, field.name))]);
+		} else {
+			const text = yield* Schema.decodeUnknownEffect(Schema.String)(value).pipe(Effect.mapError(() => invalidField("params", field.name)));
+			yield* pathValue(text, field.name);
+			params.push([field.name, yield* scalarText(field.value, text, "params", field.name)]);
+		}
+	}
+	const query = yield* searchEntries(search);
+	const searchParams = [];
+	for (const field of route.searchParams) {
+		const values = query.filter(([name]) => name === field.name).map(([, value]) => value);
+		const descriptor = field.value;
+		if (values.length === 0) {
+			if (descriptor.type === "optional") {
+				searchParams.push([field.name, void 0]);
+				continue;
+			}
+			if (descriptor.type === "default") {
+				searchParams.push([field.name, yield* suppliedValue(descriptor.value, descriptor.default, "searchParams", field.name)]);
+				continue;
+			}
+			return yield* invalid("searchParams", `The required URL field '${field.name}' is missing.`, field.name);
+		}
+		const required = descriptor.type === "optional" || descriptor.type === "default" ? descriptor.value : descriptor;
+		if (required.type === "array") searchParams.push([field.name, yield* Effect.forEach(values, (value) => scalarText(required.value, value, "searchParams", field.name))]);
+		else {
+			if (values.length !== 1) return yield* invalid("searchParams", `The scalar URL field '${field.name}' occurs more than once.`, field.name);
+			searchParams.push([field.name, yield* scalarText(required, values[0], "searchParams", field.name)]);
+		}
+	}
+	return {
+		params: Object.fromEntries(params),
+		searchParams: Object.fromEntries(searchParams)
+	};
+});
+const sameValue = (left, right) => Array$1.isArray(left) && Array$1.isArray(right) ? left.length === right.length && left.every((value, index) => value === right[index]) : left === right;
+const buildUrl = Effect.fn("Routing.buildUrl")(function* (input, values = {}) {
+	const { route, pattern } = yield* validateDefinition(input);
+	const navigation = yield* Schema.decodeUnknownEffect(BuildInput)(values).pipe(Effect.mapError(() => invalid("params", "The URL navigation input is invalid.")));
+	const params = yield* inputRecord(navigation.params, route.params, "params");
+	const searchParams = yield* inputRecord(navigation.searchParams, route.searchParams, "searchParams");
+	const segments = [];
+	for (const segment of pattern.segments) {
+		if (segment.kind === "Literal") {
+			segments.push(yield* encodeComponent(segment.value, "params"));
+			continue;
+		}
+		const field = route.params.find((candidate) => candidate.name === segment.name);
+		const value = yield* suppliedValue(field.value, own(params, field.name), "params", field.name);
+		const parts = Array$1.ensure(value);
+		if (parts.length === 0) return yield* invalid("params", "Catch-all parameters must contain at least one segment.", field.name);
+		for (const part of parts) segments.push(yield* encodeComponent(yield* pathValue(part, field.name), "params", field.name));
+	}
+	if (segments[0] === "_ignotum") {
+		const first = pattern.segments[0];
+		return yield* invalid("params", "The /_ignotum path is reserved for the platform.", first?.kind === "Parameter" || first?.kind === "CatchAll" ? first.name : void 0);
+	}
+	const query = new URLSearchParams();
+	for (const field of route.searchParams) {
+		const raw = own(searchParams, field.name);
+		const descriptor = field.value;
+		if (raw === void 0) {
+			if (descriptor.type === "optional" || descriptor.type === "default") continue;
+			return yield* invalid("searchParams", `The required URL field '${field.name}' is missing.`, field.name);
+		}
+		const required = descriptor.type === "optional" || descriptor.type === "default" ? descriptor.value : descriptor;
+		const value = yield* suppliedValue(required, raw, "searchParams", field.name);
+		if (descriptor.type === "default" && sameValue(value, descriptor.default)) continue;
+		const items = Array$1.ensure(value);
+		if (items.length === 0 && descriptor.type !== "optional" && descriptor.type !== "default") return yield* invalid("searchParams", "A required array cannot serialize as an absent search key.", field.name);
+		for (const item of items) query.append(field.name, String(item));
+	}
+	const search = query.toString();
+	const hash = navigation.hash === void 0 || navigation.hash === "" ? "" : `#${yield* encodeComponent(navigation.hash, "params")}`;
+	return `/${segments.join("/")}${search === "" ? "" : `?${search}`}${hash}`;
+});
+//#endregion
+//#region src/client/router.ts
+const RouterContext = createContext(void 0);
+const useRouter = () => {
+	const router = useContext(RouterContext);
+	if (router === void 0) throw new Error("Ignotum routing hooks require a managed client mount.");
+	return router;
+};
+const useRouterSnapshot = (router) => {
+	const [snapshot, setSnapshot] = useState(router.getSnapshot);
+	useLayoutEffect(() => {
+		const update = () => setSnapshot(router.getSnapshot());
+		const unsubscribe = router.subscribe(update);
+		update();
+		return unsubscribe;
+	}, [router]);
+	return snapshot;
+};
+function url(reference, ...args) {
+	return Effect.runSync(buildUrl(getRouteDefinition(reference), args[0]));
+}
+const destinationHref = (reference, input = {}) => Effect.runSync(buildUrl(getRouteDefinition(reference), {
+	params: input.params,
+	searchParams: input.searchParams,
+	hash: input.hash
+}));
+const NavigationInput = Schema.Struct({
+	params: Schema.optional(Schema.Unknown),
+	searchParams: Schema.optional(Schema.Unknown),
+	hash: Schema.optional(Schema.String),
+	replace: Schema.optional(Schema.Boolean),
+	scroll: Schema.optional(Schema.Literals(["auto", "preserve"]))
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+const useNavigate = () => {
+	const router = useRouter();
+	const [navigate] = useState(() => Object.assign((reference, ...args) => {
+		const options = Schema.decodeUnknownSync(NavigationInput)(args[0] ?? {});
+		return router.navigate(destinationHref(reference, options), options);
+	}, {
+		back: router.back,
+		forward: router.forward
+	}));
+	return navigate;
+};
+const useLocation = () => {
+	const snapshot = useRouterSnapshot(useRouter());
+	if (snapshot.location === void 0) throw new Error("The initial Ignotum location has not committed.");
+	return snapshot.location;
+};
+const useNavigation = () => useRouterSnapshot(useRouter()).navigation;
+const useBlocker = ({ when }) => {
+	const router = useRouter();
+	const [id] = useState(() => Symbol("blocker"));
+	useRouterSnapshot(router);
+	useLayoutEffect(() => {
+		router.setBlocker(id, when);
+	}, [
+		router,
+		id,
+		when
+	]);
+	useLayoutEffect(() => () => router.setBlocker(id, false), [router, id]);
+	return router.getBlocker(id);
+};
+const matchReference = (reference, snapshot, end) => {
+	const location = snapshot.location;
+	const outcome = snapshot.branch?.outcome;
+	if (location === void 0 || outcome === void 0) return;
+	const definition = getRouteDefinition(reference);
+	if (end && (outcome._tag !== "Matched" || outcome.route.id !== definition.id)) return;
+	const parsed = Effect.runSync(parseLocation(`${location.pathname}${location.search}`).pipe(Effect.result));
+	if (parsed._tag === "Failure") return;
+	const compiled = Effect.runSync(compilePatterns([{
+		...definition,
+		layouts: []
+	}], []));
+	for (let length = parsed.success.segments.length; length >= 0; length--) {
+		if (length === 0 && parsed.success.segments.length !== 0) break;
+		const match = matchPattern(compiled, parsed.success.segments.slice(0, length));
+		if (match.route !== void 0) {
+			const decoded = Effect.runSync(decodeRouteInputs(definition, match.params, location.search).pipe(Effect.result));
+			if (decoded._tag === "Failure") return;
+			return {
+				...decoded.success,
+				hash: location.hash
+			};
+		}
+		if (end) break;
+	}
+};
+function useMatch(reference, options) {
+	return matchReference(reference, useRouterSnapshot(useRouter()), options?.end ?? true);
+}
+function useRoute(reference) {
+	const router = useRouter();
+	const snapshot = useRouterSnapshot(router);
+	const match = matchReference(reference, snapshot, true);
+	if (match === void 0) throw new Error(`useRoute requires page '${getRouteDefinition(reference).id}' to be active.`);
+	return {
+		...match,
+		setSearchParams: (next, options) => {
+			const latest = matchReference(reference, router.getSnapshot(), true);
+			const location = router.getSnapshot().location;
+			if (latest === void 0 || location === void 0) throw new Error("Cannot update search parameters for an inactive route.");
+			const inputs = Predicate.isFunction(next) ? next(latest.searchParams) : next;
+			const href = destinationHref(reference, {
+				params: latest.params,
+				searchParams: inputs,
+				hash: latest.hash
+			});
+			const destination = new URL(href, router.browser.location.origin);
+			destination.pathname = location.pathname;
+			const declared = new Set(getRouteDefinition(reference).searchParams.map((field) => field.name));
+			for (const [name, value] of new URLSearchParams(location.search)) if (!declared.has(name)) destination.searchParams.append(name, value);
+			return router.navigate(`${destination.pathname}${destination.search}${destination.hash}`, {
+				scroll: "preserve",
+				...options
+			});
+		}
+	};
+}
+const activePath = (current, destination, end) => {
+	const source = Effect.runSync(parseLocation(current).pipe(Effect.result));
+	const target = Effect.runSync(parseLocation(destination).pipe(Effect.result));
+	if (source._tag === "Failure" || target._tag === "Failure") return false;
+	const from = source.success.segments;
+	const to = target.success.segments;
+	if (from.length !== to.length && (end || to.length === 0 || from.length < to.length)) return false;
+	return to.every((segment, index) => from[index] === segment);
+};
+function Anchor(props) {
+	const router = useRouter();
+	const snapshot = useRouterSnapshot(router);
+	const { to, params, searchParams, hash, replace, scroll, preload = "intent", end = true, active = false, class: className, onClick, onMouseEnter, onFocus, ...attributes } = props;
+	const href = destinationHref(to, {
+		params,
+		searchParams,
+		hash
+	});
+	const isActive = active && snapshot.location !== void 0 && activePath(snapshot.location.pathname, href.split(/[?#]/)[0], end);
+	const prepare = () => {
+		if (preload !== "none") router.preload(href).catch(() => {});
+	};
+	return createElement("a", {
+		...attributes,
+		href,
+		class: Predicate.isFunction(className) ? className({ isActive }) : className,
+		"aria-current": isActive ? "page" : attributes["aria-current"],
+		onClick: (event) => {
+			onClick?.(event);
+			const anchor = event.currentTarget;
+			if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || anchor.target !== "" && anchor.target.toLowerCase() !== "_self" || anchor.hasAttribute("download") || anchor.relList.contains("external") || anchor.origin !== router.browser.location.origin || `${anchor.pathname}${anchor.search}${anchor.hash}` !== href) return;
+			event.preventDefault();
+			router.navigate(href, {
+				replace,
+				scroll
+			});
+		},
+		onMouseEnter: (event) => {
+			onMouseEnter?.(event);
+			if (!event.defaultPrevented) prepare();
+		},
+		onFocus: (event) => {
+			onFocus?.(event);
+			if (!event.defaultPrevented) prepare();
+		}
+	});
+}
+function Link(props) {
+	return createElement(Anchor, props);
+}
+function NavLink(props) {
+	return createElement(Anchor, {
+		...props,
+		active: true
+	});
+}
+function Redirect(props) {
+	const router = useRouter();
+	const href = destinationHref(props.to, props);
+	const previous = useRef();
+	const replace = props.replace ?? true;
+	useEffect(() => {
+		const identity = JSON.stringify([
+			href,
+			replace,
+			props.scroll
+		]);
+		if (previous.current === identity) return;
+		previous.current = identity;
+		router.navigate(href, {
+			replace,
+			scroll: props.scroll
+		}, true);
+	}, [
+		router,
+		href,
+		replace,
+		props.scroll
+	]);
+	return null;
+}
+//#endregion
+export { Files as C, BrowserSession as S, matchPattern as _, url as a, syncClientInternals as b, useMatch as c, useRoute as d, useRouterSnapshot as f, matchDirectory as g, compilePatterns as h, RouterContext as i, useNavigate as l, parseLocation as m, NavLink as n, useBlocker as o, decodeRouteInputs as p, Redirect as r, useLocation as s, Link as t, useNavigation as u, SyncClient as v, ClientInfrastructureError as w, syncRuntime as x, mountManagedSync as y };
+
+//# sourceMappingURL=router-BSBI1oN1.js.map