ignotum 0.0.13 → 0.0.15

package/dist/runtime/client.js

@@ -1,335 +1,11 @@
-import { A as RuntimeFileMetadata, B as makeFileValue, D as encodeTransportObject, E as decodeTransportValue, F as fileIdOf, G as IdAlphabet, H as AppId, I as fileLimits, J as SessionEpoch, K as InvocationId, L as fileMimeTypes, N as fileFormats, P as fileGrantUrlOf, R as grantFileValue, U as DeploymentId, W as GeneratedId, X as TableId, Y as SubscriptionId, _ as Result$2, a as SessionResponse, b as inspectResult, d as sessionPath, f as sessionRequestsPath, i as SessionRequest, j as RuntimeFileOccurrence, k as FileId, l as developmentSelectionKey, m as upgrade, n as SessionOutcome, o as SessionState, p as initial, q as RuntimeRequestNonce, r as SessionRedirect, t as DevelopmentSelection, x as pending, y as failureFromWire, z as isFileValue } from "./id-Bt9XWRGL.js";
-import { a as ErrorCode, c as ServerMessageJson, d as WireSuccess, f as AppStateRevision, i as DeploymentCloseCode, l as WireFailure, m as InvocationKey, n as functionPathOf, o as FunctionAddress, p as DeploymentGeneration, r as ClientMessageJson, s as Operation, u as WireResult } from "./api-CAgKDij7.js";
-import { s as PaginationPageSize, t as ValueDescriptor } from "./descriptor-Cyo9FP9n-C0SRVXNW.js";
-import { Array as Array$1, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Option, Predicate, Schedule, Schema, Semaphore, String } from "effect";
-import { customAlphabet } from "nanoid";
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { D as encodeTransportObject, _ as Result$2, b as inspectResult, x as pending } from "./id--1m0NuUL.js";
+import { C as Files, S as BrowserSession, a as url, b as syncClientInternals, c as useMatch, d as useRoute, l as useNavigate, n as NavLink, o as useBlocker, r as Redirect, s as useLocation, t as Link, u as useNavigation, v as SyncClient, w as ClientInfrastructureError, x as syncRuntime } from "./router-BSBI1oN1.js";
+import { functionPathOf } from "./internal/api.js";
+import { n as PaginationPageSize } from "./pagination-D3qd6s9N.js";
+import { t as Image } from "./image-Djtjy4Z8.js";
+import { Effect, Schema } from "effect";
 import { useCallback, useCallback as useCallback$1, useContext, useDebugValue, useDebugValue as useDebugValue$1, useEffect, useEffect as useEffect$1, useErrorBoundary, useId as useElementId, useImperativeHandle, useLayoutEffect, useMemo, useMemo as useMemo$1, useReducer, useRef, useState, useState as useState$1 } from "preact/hooks";
-import * as Socket from "effect/unstable/socket/Socket";
-import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
 import { Component, Fragment, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray } from "preact";
-//#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;
-};
-//#endregion
-//#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.Order).map(([key, field]) => `${JSON.stringify(key)}:${encodeJson(field)}`).join(",")}}`;
-};
-const encodeCanonicalJson = (value) => encodeJson(Schema.decodeSync(Schema.Json)(value));
-//#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 = () => {
-			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);
-			}
-		};
-		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 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 InvalidClientMessage = class extends Schema.TaggedError()("InvalidClientMessage", {
-	cause: Schema.Defect(),
-	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: ErrorCode,
-	message: Schema.String,
-	operation: Schema.optional(Operation)
-}) {};
-const ClientInfrastructureError = Schema.Union([
-	ConnectionUnavailable,
-	InvalidClientMessage,
-	InvalidMutationArguments,
-	InvalidServerMessage,
-	ServerError
-]);
-const browserErrorReporter = ErrorReporter.make(({ attributes, error }) => {
-	globalThis.console.error("Ignotum infrastructure error", error, attributes);
-});
-const clientErrorReporterLayer = ErrorReporter.layer([browserErrorReporter]);
-const reportClientError = Effect.fn("ClientErrorReporter.report")(function* (error) {
-	yield* ErrorReporter.report(Cause.fail(error));
-});
-//#endregion
 //#region src/client/query.ts
 const QuerySkipTypeId = Symbol.for("ignotum/client/QuerySkip");
 var QuerySkipToken = class {
@@ -339,807 +15,6 @@ const skip = Object.freeze(new QuerySkipToken());
 const Query = { skip };
 const isQuerySkip = (value) => value === skip;
 //#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,
-	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
-});
-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 InvocationBase = {
-	appId: AppId,
-	deploymentId: DeploymentId,
-	generation: DeploymentGeneration,
-	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,
-	files: Schema.optional(Schema.Array(RuntimeFileOccurrence))
-});
-Schema.Union([QueryInvocation, MutationInvocation]);
-Schema.Struct({
-	appId: AppId,
-	expectedRevision: AppStateRevision
-});
-Schema.Struct({ currentRevision: AppStateRevision });
-var RuntimeDeploymentUnavailable = class extends Schema.TaggedError()("RuntimeDeploymentUnavailable", {
-	deploymentId: DeploymentId,
-	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([
-	RuntimeDeploymentUnavailable,
-	RuntimeInvocationRejected,
-	RuntimeInvocationUnavailable
-]);
-//#endregion
-//#region ../contracts/dist/runtime/functions.js
-const FunctionKind = Schema.Literals(["Mutation", "Query"]);
-Schema.TaggedError()("UnknownFunction", {
-	function: FunctionAddress,
-	message: Schema.String
-});
-Schema.TaggedError()("WrongFunctionKind", {
-	actual: FunctionKind,
-	expected: FunctionKind,
-	function: FunctionAddress,
-	message: Schema.String
-});
-Schema.TaggedError()("InvalidArguments", {
-	function: FunctionAddress,
-	message: Schema.String
-});
-Schema.TaggedError()("FunctionUnavailable", {
-	cause: Schema.Defect(),
-	function: FunctionAddress,
-	message: Schema.String
-});
-//#endregion
-//#region ../contracts/dist/deployment.js
-const ArtifactPath = Schema.String.check(Schema.isPattern(/^(?!\/)(?![A-Za-z]:\/)(?!.*(?:^|\/)\.\.(?:\/|$))(?!.*(?:^|\/)\.(?:\/|$))(?!.*\/\/)[^\\\0]+$/)).pipe(Schema.brand("ignotum/deployment/ArtifactPath"));
-const ClientPath = Schema.String.check(Schema.isPattern(/^\/(?!_ignotum(?:\/|$))(?:(?:[A-Za-z0-9._~-]+\/)*[A-Za-z0-9._~-]+\/?)?$/)).pipe(Schema.brand("ignotum/deployment/ClientPath"));
-const Sha256 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)).pipe(Schema.brand("ignotum/deployment/Sha256"));
-const ArtifactKind = Schema.Literals([
-	"ClientAsset",
-	"ClientDocument",
-	"ClientManifest",
-	"ClientPublicFile",
-	"ClientShell",
-	"FunctionBundle",
-	"ServerManifest",
-	"ServerEnvironment",
-	"SourceMap",
-	"SchemaSnapshot"
-]);
-const ArtifactReference = Schema.Struct({
-	path: ArtifactPath,
-	size: Schema.Natural,
-	sha256: Sha256
-});
-const ArtifactFile = Schema.Struct({
-	path: ArtifactPath,
-	size: Schema.Natural,
-	sha256: Sha256,
-	kind: ArtifactKind,
-	contentType: Schema.String,
-	contentEncoding: Schema.optional(Schema.String)
-});
-const ClientRoute = Schema.Struct({
-	pathname: ClientPath,
-	artifact: ArtifactReference
-});
-const DeploymentInventoryV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	files: Schema.Array(ArtifactFile)
-});
-const DeploymentInventoryV2 = Schema.Struct({
-	formatVersion: Schema.Literal(2),
-	files: Schema.Array(ArtifactFile)
-});
-upgrade(initial(DeploymentInventoryV1), DeploymentInventoryV2, (inventory) => ({
-	formatVersion: 2,
-	files: inventory.files
-}));
-const ClientManifestV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	shell: ArtifactReference,
-	routes: Schema.Array(ClientRoute)
-});
-initial(ClientManifestV1);
-const ClientRoutingRoute = Schema.Struct({
-	pathname: ClientPath,
-	artifact: ArtifactPath
-});
-const ClientRoutingV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	shell: ArtifactPath,
-	routes: Schema.Array(ClientRoutingRoute)
-});
-initial(ClientRoutingV1);
-const SchemaSnapshotField = Schema.Struct({
-	name: Schema.String,
-	value: ValueDescriptor
-});
-const EnvironmentArtifactV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	nonce: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)),
-	values: Schema.Record(Schema.String, Schema.String)
-});
-initial(EnvironmentArtifactV1);
-const ServerEnvironmentArtifact = Schema.Struct({
-	artifact: ArtifactReference,
-	fields: Schema.Array(SchemaSnapshotField)
-});
-const SchemaSnapshotIndex = Schema.Struct({
-	name: Schema.String,
-	fields: Schema.Array(Schema.String)
-});
-const SchemaSnapshotTableV1 = Schema.Struct({
-	name: Schema.String,
-	fields: Schema.Array(SchemaSnapshotField)
-});
-const SchemaSnapshotV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	tables: Schema.Array(SchemaSnapshotTableV1)
-});
-const SchemaSnapshotTable = Schema.Struct({
-	name: Schema.String,
-	fields: Schema.Array(SchemaSnapshotField),
-	indexes: Schema.Array(SchemaSnapshotIndex)
-});
-const SchemaSnapshotV2 = Schema.Struct({
-	formatVersion: Schema.Literal(2),
-	tables: Schema.Array(SchemaSnapshotTable)
-});
-upgrade(initial(SchemaSnapshotV1), SchemaSnapshotV2, (snapshot) => ({
-	formatVersion: 2,
-	tables: snapshot.tables.map((table) => ({
-		...table,
-		indexes: []
-	}))
-}));
-const ServerFunctionArtifactV1 = Schema.Struct({
-	address: FunctionAddress,
-	kind: FunctionKind,
-	bundle: ArtifactReference,
-	sourceMap: ArtifactReference
-});
-const ServerFunctionArtifact = Schema.Struct({
-	address: FunctionAddress,
-	kind: FunctionKind,
-	args: Schema.optional(ValueDescriptor),
-	returns: Schema.optional(ValueDescriptor),
-	errors: Schema.optional(ValueDescriptor),
-	bundle: ArtifactReference,
-	sourceMap: ArtifactReference
-});
-const ServerBuildManifestV1 = Schema.Struct({
-	formatVersion: Schema.Literal(1),
-	schema: ArtifactReference,
-	functions: Schema.Array(ServerFunctionArtifactV1)
-});
-const ServerBuildManifestV2 = Schema.Struct({
-	formatVersion: Schema.Literal(2),
-	schema: ArtifactReference,
-	functions: Schema.Array(ServerFunctionArtifact)
-});
-const ServerBuildManifestThroughV2 = upgrade(initial(ServerBuildManifestV1), ServerBuildManifestV2, (manifest) => ({
-	formatVersion: 2,
-	schema: manifest.schema,
-	functions: manifest.functions
-}));
-const ServerBuildManifestV3 = Schema.Struct({
-	formatVersion: Schema.Literal(3),
-	schema: ArtifactReference,
-	environment: Schema.optional(ServerEnvironmentArtifact),
-	functions: Schema.Array(ServerFunctionArtifact)
-});
-upgrade(ServerBuildManifestThroughV2, ServerBuildManifestV3, (manifest) => ({
-	formatVersion: 3,
-	schema: manifest.schema,
-	functions: manifest.functions
-}));
-ArtifactPath.make("inventory.json");
-ArtifactPath.make("client/manifest.json");
-ArtifactPath.make("client/shell.html");
-`${ArtifactPath.make("client/assets")}`;
-`${ArtifactPath.make("client/routes")}`;
-ArtifactPath.make("server/manifest.json");
-ArtifactPath.make("server/schema.json");
-ArtifactPath.make("server/environment.json");
-//#endregion
-//#region ../contracts/dist/runtime/transport.js
-const runtimeInvocationPath = "/v1/invoke";
-const runtimeRevisionPath = "/v1/revision";
-const runtimeIndexPreparePath = "/v1/indexes/prepare";
-const runtimeIndexCommitPath = "/v1/indexes/commit";
-const runtimeFileEffectsPath = "/v1/files/effects";
-const runtimeFileEffectsAcknowledgePath = "/v1/files/effects/acknowledge";
-const appSyncPath = `/_ignotum/v1/sync`;
-const RuntimeRequestPath = Schema.Literals([
-	runtimeInvocationPath,
-	runtimeRevisionPath,
-	runtimeIndexPreparePath,
-	runtimeIndexCommitPath,
-	runtimeFileEffectsPath,
-	runtimeFileEffectsAcknowledgePath
-]);
-const RuntimeRequestTimestamp = Schema.FiniteFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ignotum/runtime/RequestTimestamp"));
-const RuntimeRequestSignature = Sha256.pipe(Schema.brand("ignotum/runtime/RequestSignature"));
-Schema.Struct({
-	appId: AppId,
-	deploymentId: Schema.optional(DeploymentId),
-	nonce: RuntimeRequestNonce,
-	timestamp: RuntimeRequestTimestamp,
-	signature: RuntimeRequestSignature
-});
-Schema.Struct({
-	method: Schema.Literal("POST"),
-	path: RuntimeRequestPath,
-	timestamp: RuntimeRequestTimestamp,
-	nonce: RuntimeRequestNonce,
-	appId: AppId,
-	deploymentId: Schema.optional(DeploymentId),
-	bodySha256: Sha256
-});
-Schema.Struct({
-	appId: AppId,
-	deploymentId: DeploymentId
-});
-Schema.Struct({ completed: Schema.Literal(true) });
-const RuntimeErrorCode = Schema.Literals([
-	"InvalidRequest",
-	"InvalidSignature",
-	"RequestExpired",
-	"RequestReplay",
-	"InvocationRejected",
-	"RuntimeUnavailable"
-]);
-Schema.Struct({
-	code: RuntimeErrorCode,
-	message: Schema.String,
-	rejectionCode: Schema.optional(RuntimeInvocationRejectionCode)
-});
-//#endregion
-//#region src/internal/http-paths.ts
-const syncPath = appSyncPath;
-//#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 resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire, files = []) => Effect.try({
-	try: () => wire.type === "Success" ? Result$2.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."
-	})
-}));
-const shouldReloadForCloseCode = (code) => code === DeploymentCloseCode;
-const handshakesMatch = (first, next) => first.appId === next.appId && first.deploymentId === next.deploymentId && first.generation === next.generation;
-const handshakeDecision = (remembered, acceptedOnConnection, next) => {
-	if (remembered !== void 0 && !handshakesMatch(remembered, next)) return "Reload";
-	return acceptedOnConnection ? "Ignore" : "Accept";
-};
-const syncClientInternals = {
-	makeQueryCache,
-	handshakeDecision,
-	queryIdentity: queryKey,
-	resultFromWire,
-	handshakesMatch,
-	shouldReloadForCloseCode
-};
-const socketUrl = () => {
-	const url = new URL(syncPath, globalThis.location.href);
-	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-	return url.href;
-};
-var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync/SyncClient") {
-	static layer = Layer.effect(SyncClient, Effect.gen(function* () {
-		const ids = yield* IdGenerator;
-		const session = yield* BrowserSession;
-		let invocations = HashMap.empty();
-		let rememberedHandshake;
-		let reloadRequested = false;
-		let writer;
-		let sessionSuspended;
-		const encode = (message) => Schema.encodeEffect(ClientMessageJson)(message).pipe(Effect.mapError((cause) => InvalidClientMessage.make({
-			cause,
-			message: "Could not encode an Ignotum sync message."
-		})));
-		const sendWith = (write, message) => encode(message).pipe(Effect.flatMap(write), Effect.mapError((cause) => Schema.is(InvalidClientMessage)(cause) ? cause : ConnectionUnavailable.make({
-			cause,
-			message: "The sync connection was lost."
-		})));
-		const send = (message) => writer === void 0 ? Effect.fail(ConnectionUnavailable.make({ message: "The sync connection is not ready." })) : sendWith(writer, message);
-		const queryCache = makeQueryCache(ids.generate(SubscriptionId), (message) => writer === void 0 ? Effect.void : send(message).pipe(Effect.catchTags({
-			ConnectionUnavailable: reportClientError,
-			InvalidClientMessage: reportClientError
-		})));
-		const unsubscribeSession = session.subscribe(() => {
-			if (session.current() === void 0) {
-				queryCache.invalidatePrivate();
-				writer = void 0;
-				if (sessionSuspended !== void 0) Deferred.doneUnsafe(sessionSuspended, Effect.void);
-			}
-		});
-		yield* Effect.addFinalizer(() => Effect.sync(unsubscribeSession));
-		const rejectInvocation = (id, error) => {
-			const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, id));
-			if (pendingInvocation === void 0) return Effect.void;
-			invocations = HashMap.remove(invocations, id);
-			return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingInvocation.prepared, error)), Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)), Effect.asVoid);
-		};
-		const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (message) {
-			switch (message.type) {
-				case "Session":
-					if (message.event === "Updated") {
-						const previous = session.current();
-						if (previous !== void 0 && previous.sessionEpoch !== message.session.sessionEpoch) return;
-						if (previous?.viewRevision !== message.session.viewRevision) queryCache.invalidatePrivate();
-						session.accept(message.session, message.serverTime);
-					} else {
-						if (rememberedHandshake?.session?.sessionEpoch !== message.sessionEpoch) return;
-						session.suspend(message.event === "Unavailable" ? "Your ID session is temporarily unavailable." : void 0);
-						if (message.event !== "Unavailable") yield* Effect.forEach(HashMap.keys(invocations), (id) => rejectInvocation(id, ServerError.make({
-							code: "SessionChanged",
-							message: "The session changed. This operation may already have completed."
-						})));
-					}
-					return;
-				case "Invalidate":
-					if (message.sessionEpoch === session.current()?.sessionEpoch) queryCache.invalidate(message.ids);
-					return;
-				case "Snapshot": {
-					const current = session.current();
-					if (current === void 0 || message.identity?.sessionEpoch !== current.sessionEpoch) return;
-					if (message.identity.dependsOnId && message.identity.viewRevision !== current.viewRevision) return;
-					const entry = queryCache.getById(message.id);
-					if (entry === void 0) return;
-					entry.dependsOnId = message.identity.dependsOnId;
-					if (entry.revision !== void 0 && message.revision < entry.revision) return;
-					yield* resultFromWire(message.result, message.files ?? []).pipe(Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result, message.revision))), Effect.catchTags({ InvalidServerMessage: (error) => {
-						queryCache.setResult(message.id, error, message.revision);
-						return reportClientError(error);
-					} }));
-					return;
-				}
-				case "Preparation": {
-					if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
-					const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, message.id));
-					if (pendingInvocation !== void 0) yield* Deferred.succeed(pendingInvocation.prepared, message.uploads);
-					return;
-				}
-				case "Result": {
-					if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
-					const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, message.id));
-					if (pendingInvocation === void 0) return;
-					yield* resultFromWire(message.result).pipe(Effect.flatMap((result) => {
-						invocations = HashMap.remove(invocations, message.id);
-						return Deferred.succeed(pendingInvocation.deferred, result);
-					}), Effect.catchTags({ InvalidServerMessage: (error) => rejectInvocation(message.id, error) }));
-					return;
-				}
-				case "Error": {
-					if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
-					const error = message.operation === void 0 ? ServerError.make({
-						code: message.code,
-						message: message.message
-					}) : ServerError.make({
-						code: message.code,
-						message: message.message,
-						operation: message.operation
-					});
-					if (message.operation?.type === "Invocation") yield* rejectInvocation(message.operation.id, error);
-					else if (message.operation?.type === "Subscription") {
-						queryCache.setResult(message.operation.id, error);
-						yield* reportClientError(error);
-					} else yield* reportClientError(error);
-					return;
-				}
-			}
-		});
-		const requestReload = () => {
-			if (reloadRequested) return;
-			reloadRequested = true;
-			writer = void 0;
-			globalThis.location.reload();
-		};
-		const disconnect = Effect.sync(() => {
-			writer = void 0;
-		});
-		const connect = Effect.scoped(Effect.gen(function* () {
-			if (reloadRequested) return yield* Effect.never;
-			yield* session.bootstrap.pipe(Effect.mapError((error) => ConnectionUnavailable.make({ message: error.message })));
-			const socket = yield* Socket.makeWebSocket(`${socketUrl()}${session.socketParameters()}`, { closeCodeIsError: (code) => {
-				if (shouldReloadForCloseCode(code)) requestReload();
-				return false;
-			} });
-			const write = yield* socket.writer;
-			const handshakeReceived = yield* Deferred.make();
-			let handshakeAccepted = false;
-			const acceptHandshake = Effect.fn("SyncClient.acceptHandshake")(function* (handshake) {
-				const decision = handshakeDecision(rememberedHandshake, handshakeAccepted, handshake);
-				if (decision === "Reload") {
-					requestReload();
-					return;
-				}
-				if (decision === "Ignore") return;
-				if (handshake.session === void 0 || handshake.serverTime === void 0) {
-					requestReload();
-					return;
-				}
-				if (rememberedHandshake?.session !== void 0 && rememberedHandshake.session.sessionEpoch !== handshake.session.sessionEpoch) {
-					queryCache.invalidatePrivate();
-					yield* Effect.forEach(HashMap.keys(invocations), (id) => rejectInvocation(id, ServerError.make({
-						code: "SessionChanged",
-						message: "The session changed. This operation may already have completed."
-					})));
-				} else if (rememberedHandshake?.session?.viewRevision !== handshake.session.viewRevision) queryCache.invalidatePrivate();
-				yield* Effect.forEach(HashMap.entries(invocations), ([id, pending]) => pending.sessionEpoch === handshake.session.sessionEpoch ? Effect.void : rejectInvocation(id, ServerError.make({
-					code: "SessionChanged",
-					message: "The session changed. This operation may already have completed."
-				})));
-				session.accept(handshake.session, handshake.serverTime);
-				rememberedHandshake = handshake;
-				handshakeAccepted = true;
-				writer = write;
-				yield* Deferred.succeed(handshakeReceived, void 0);
-				yield* Effect.gen(function* () {
-					yield* Effect.forEach(queryCache.entries(), (entry) => sendWith(write, subscribeMessage(entry)));
-					yield* Effect.forEach(HashMap.values(invocations), (pendingInvocation) => sendWith(write, pendingInvocation.message));
-				}).pipe(Effect.tapError(reportClientError), Effect.ignore);
-			});
-			const handleText = Effect.fn("SyncClient.handleText")(function* (text) {
-				const message = yield* Schema.decodeEffect(ServerMessageJson)(text).pipe(Effect.mapError((cause) => InvalidServerMessage.make({
-					cause,
-					message: "The server returned an invalid sync message."
-				})));
-				if (message.type === "Handshake") return yield* acceptHandshake(message);
-				if (message.type === "Deployment") {
-					requestReload();
-					return;
-				}
-				if (!handshakeAccepted) return yield* InvalidServerMessage.make({
-					cause: /* @__PURE__ */ new Error("The server sent a sync message before the handshake."),
-					message: "The server returned a sync message before the handshake."
-				});
-				return yield* handleMessage(message);
-			});
-			const suspended = yield* Deferred.make();
-			sessionSuspended = suspended;
-			yield* Effect.addFinalizer(() => Effect.sync(() => {
-				if (sessionSuspended === suspended) sessionSuspended = void 0;
-			}));
-			const run = yield* socket.runString(handleText).pipe(Effect.forkChild);
-			yield* Effect.raceFirst(Deferred.await(handshakeReceived).pipe(Effect.timeout("10 seconds")), Fiber.join(run));
-			yield* Effect.raceFirst(Fiber.join(run), Deferred.await(suspended));
-		})).pipe(Effect.mapError((cause) => Schema.is(ClientInfrastructureError)(cause) ? cause : ConnectionUnavailable.make({
-			cause,
-			message: "The sync connection was lost."
-		})), Effect.ensuring(disconnect));
-		const reconnectSchedule = Schedule.exponential("250 millis").pipe(Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.seconds(5)))), Schedule.jittered);
-		yield* connect.pipe(Effect.andThen(Effect.fail(ConnectionUnavailable.make({ message: "The sync connection closed; reconnecting." }))), Effect.tapError(reportClientError), Effect.retry(reconnectSchedule), Effect.forkScoped);
-		const observe = Effect.fn("SyncClient.observe")(function* (functionAddress, args) {
-			return yield* queryCache.observe(functionAddress, args);
-		});
-		const mutate = Effect.fn("SyncClient.mutate")(function* (functionAddress, args) {
-			const admittedSession = session.current() ?? rememberedHandshake?.session ?? (yield* session.bootstrap.pipe(Effect.mapError((error) => ConnectionUnavailable.make({ message: error.message }))));
-			const invocationId = yield* ids.generate(InvocationId);
-			const preparedArguments = yield* prepareMutationArguments(args).pipe(Effect.provideService(IdGenerator, ids), Effect.mapError((cause) => InvalidMutationArguments.make({
-				cause,
-				function: functionAddress,
-				message: `Mutation arguments for ${functionAddress} contain an unsupported file or value.`
-			})), Effect.tapError(reportClientError));
-			const jsonArgs = yield* Effect.try({
-				try: () => encodeTransportObject(preparedArguments.value),
-				catch: (cause) => InvalidMutationArguments.make({
-					cause,
-					function: functionAddress,
-					message: `Mutation arguments for ${functionAddress} contain an unsupported value.`
-				})
-			}).pipe(Effect.tapError(reportClientError));
-			const deferred = yield* Deferred.make();
-			const prepared = yield* Deferred.make();
-			const invokeMessage = {
-				type: "Invoke",
-				id: invocationId,
-				kind: "Mutation",
-				function: functionAddress,
-				args: jsonArgs
-			};
-			const message = preparedArguments.fileIds.length === 0 ? invokeMessage : {
-				type: "Prepare",
-				id: invocationId,
-				kind: "Mutation",
-				function: functionAddress,
-				args: jsonArgs,
-				files: preparedArguments.fileIds
-			};
-			invocations = HashMap.set(invocations, invocationId, {
-				sessionEpoch: admittedSession.sessionEpoch,
-				deferred,
-				function: functionAddress,
-				message,
-				prepared
-			});
-			return yield* Effect.gen(function* () {
-				if (writer !== void 0) yield* sendWith(writer, message).pipe(Effect.catchTags({
-					ConnectionUnavailable: reportClientError,
-					InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
-				}));
-				if (message.type === "Prepare") {
-					const uploads = yield* Deferred.await(prepared);
-					const expected = new Set(message.files);
-					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 = preparedArguments.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
-					});
-					const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, invocationId));
-					if (pendingInvocation === void 0) return yield* Deferred.await(deferred);
-					invocations = HashMap.set(invocations, invocationId, {
-						...pendingInvocation,
-						message: invokeMessage
-					});
-					if (writer !== void 0) yield* sendWith(writer, invokeMessage).pipe(Effect.catchTags({
-						ConnectionUnavailable: reportClientError,
-						InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
-					}));
-				}
-				return yield* Deferred.await(deferred);
-			}).pipe(Effect.tapError(() => Effect.sync(() => {
-				invocations = HashMap.remove(invocations, invocationId);
-			})));
-		});
-		return SyncClient.of({
-			mutate,
-			observe
-		});
-	})).pipe(Layer.provide(Layer.merge(Socket.layerWebSocketConstructorGlobal, BrowserCrypto.layer)));
-};
-const syncRuntime = ManagedRuntime.make(SyncClient.layer.pipe(Layer.provideMerge(BrowserSession.layer), Layer.provideMerge(clientErrorReporterLayer), Layer.provideMerge(IdGenerator.layer)));
-const hot = import.meta.hot;
-if (hot !== void 0) hot.dispose(() => void syncRuntime.dispose());
-//#endregion
 //#region src/client/page-observers.ts
 const makePageObservers = (onChange, releaseObserver) => {
 	const pages = /* @__PURE__ */ new Map();
@@ -1415,15 +290,9 @@ function useId() {
 	};
 }
 //#endregion
-//#region src/client/app.ts
-const app = (definition) => {
-	if (definition.title.trim().length === 0) throw new Error("The app title must contain a non-whitespace character.");
-	return definition;
-};
-//#endregion
 //#region src/client/index.ts
 const Result = { match: Result$2.match };
 //#endregion
-export { Component, Files, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useElementId, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
+export { Component, Files, Fragment, Image, Link, NavLink, Query, Redirect, Result, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, url, useBlocker, useCallback, useContext, useDebugValue, useEffect, useElementId, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useLocation, useMatch, useMemo, useMutation, useNavigate, useNavigation, usePaginatedQuery, useQuery, useReducer, useRef, useRoute, useState };
 
 //# sourceMappingURL=client.js.map