ignotum 0.0.2 → 0.0.4

package/dist/runtime/client.js

@@ -1,8 +1,11 @@
-import { a as decodeTransportValue, i as pending, n as Result$1, o as encodeTransportObject, r as failureFromWire } from "./result-B2W-z2wG.js";
-import { a as Operation, c as ServerMessageJson, i as FunctionAddress, l as SubscriptionId, n as functionPathOf, o as ProtocolErrorCode, r as ClientMessageJson, s as RequestId } from "./api-BXXIZc_Q.js";
-import { Cause, Context, Deferred, Duration, Effect, ErrorReporter, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema } from "effect";
+import { a as InvocationId, c as SubscriptionId, i as IdAlphabet, l as TableId, n as DeploymentId, r as GeneratedId, s as RuntimeRequestNonce, t as AppId } from "./id-D570vudg.js";
+import { g as encodeTransportObject, h as decodeTransportValue, l as failureFromWire, s as Result$1, t as ValueDescriptor, u as pending } from "./descriptor-t6BOEGw9-BTHR-ZMv.js";
+import { a as FunctionAddress, c as ServerMessageJson, d as WireSuccess, f as AppStateRevision, i as DeploymentChangedCloseCode, l as WireFailure, m as InvocationKey, n as functionPathOf, o as Operation, p as DeploymentGeneration, r as ClientMessageJson, s as ProtocolErrorCode, u as WireResult } from "./api-DtX8qPrq.js";
+import { Array, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema, String } from "effect";
 import { useCallback, useContext, useDebugValue, useDebugValue as useDebugValue$1, useEffect, useEffect as useEffect$1, useErrorBoundary, useId, 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 { customAlphabet } from "nanoid";
 import { Component, Fragment, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray } from "preact";
 //#region src/client/errors.ts
 /** @effect-diagnostics globalConsole:skip-file */
@@ -28,19 +31,12 @@ var ServerProtocolError = class extends Schema.TaggedError()("ServerProtocolErro
 	message: Schema.String,
 	operation: Schema.optional(Operation)
 }) {};
-var MutationOutcomeUnknown = class extends Schema.TaggedError()("MutationOutcomeUnknown", {
-	cause: Schema.optional(Schema.Defect()),
-	function: FunctionAddress,
-	id: RequestId,
-	message: Schema.String
-}) {};
 const ClientInfrastructureError = Schema.Union([
 	ConnectionUnavailable,
 	InvalidClientMessage,
 	InvalidMutationArguments,
 	InvalidServerMessage,
-	ServerProtocolError,
-	MutationOutcomeUnknown
+	ServerProtocolError
 ]);
 const browserErrorReporter = ErrorReporter.make(({ attributes, error }) => {
 	globalThis.console.error("Ignotum infrastructure error", error, attributes);
@@ -58,15 +54,239 @@ var QuerySkipToken = class {
 const skip = Object.freeze(new QuerySkipToken());
 const Query = { skip };
 const isQuerySkip = (value) => value === skip;
-const syncPath = `/_ignotum/sync`;
 //#endregion
-//#region src/client/sync.ts
-const canonicalJson = (value) => {
-	if (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return JSON.stringify(value);
-	if (globalThis.Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-	return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`).join(",")}}`;
+//#region ../contracts/dist/json.js
+const encodeScalar = (value) => Schema.decodeSync(Schema.String)(JSON.stringify(value));
+const encodeCanonicalJson = (value) => {
+	if (value === null || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return encodeScalar(value);
+	if (Predicate.isObject(value)) return `{${Array.map(Array.sort(String.Order)(Object.keys(value)), (key) => {
+		const field = Schema.decodeUnknownSync(Schema.Json)(value[key]);
+		return `${encodeScalar(key)}:${encodeCanonicalJson(field)}`;
+	}).join(",")}}`;
+	return `[${Schema.decodeUnknownSync(Schema.Array(Schema.Json))(value).map(encodeCanonicalJson).join(",")}]`;
+};
+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 DependencyKey = Schema.Union([TableDependency, DocumentDependency]);
+const DependencySet = Schema.Array(DependencyKey);
+const InvalidationSet = Schema.Array(DependencyKey);
+const RuntimeQueryResult = Schema.Struct({
+	type: Schema.Literal("Query"),
+	result: WireResult,
+	dependencies: DependencySet,
+	observedRevision: AppStateRevision
+});
+const RuntimeMutationSuccess = Schema.Struct({
+	type: Schema.Literal("Mutation"),
+	result: WireSuccess,
+	invalidations: InvalidationSet,
+	committedRevision: AppStateRevision
+});
+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
 };
-const queryKey = (functionAddress, args) => `${functionAddress}:${canonicalJson(args)}`;
+const QueryInvocation = Schema.Struct({
+	...InvocationBase,
+	type: Schema.Literal("Query")
+});
+const MutationInvocation = Schema.Struct({
+	...InvocationBase,
+	type: Schema.Literal("Mutation"),
+	invocationId: InvocationId
+});
+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([
+	"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 ../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 ../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 Sha256 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)).pipe(Schema.brand("ignotum/deployment/Sha256"));
+const ArtifactKind = Schema.Literals([
+	"ClientAsset",
+	"ClientShell",
+	"FunctionBundle",
+	"ServerManifest",
+	"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)
+});
+Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	files: Schema.Array(ArtifactFile)
+});
+const SchemaSnapshotField = Schema.Struct({
+	name: Schema.String,
+	value: ValueDescriptor
+});
+const SchemaSnapshotTable = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(SchemaSnapshotField)
+});
+Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	tables: Schema.Array(SchemaSnapshotTable)
+});
+const ServerFunctionArtifact = Schema.Struct({
+	address: FunctionAddress,
+	kind: FunctionKind,
+	bundle: ArtifactReference,
+	sourceMap: ArtifactReference
+});
+Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	schema: ArtifactReference,
+	functions: Schema.Array(ServerFunctionArtifact)
+});
+ArtifactPath.make("inventory.json");
+ArtifactPath.make("client/_shell.html");
+ArtifactPath.make("server/manifest.json");
+ArtifactPath.make("server/schema.json");
+//#endregion
+//#region ../contracts/dist/runtime/transport.js
+const runtimeInvocationPath = "/v1/invoke";
+const runtimeRevisionPath = "/v1/revision";
+const appSyncPath = "/_ignotum/v1/sync";
+const RuntimeRequestPath = Schema.Literals([runtimeInvocationPath, runtimeRevisionPath]);
+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
+});
+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,
@@ -91,9 +311,10 @@ const makeQueryCache = (allocateId, sendLifecycleMessage) => {
 					function: functionAddress,
 					generation: 0,
 					listeners: /* @__PURE__ */ new Set(),
+					revision: void 0,
 					references: 0,
 					result: pending(),
-					subscriptionId: allocateId()
+					subscriptionId: yield* allocateId
 				};
 				queries.set(key, created);
 				queryKeysById.set(created.subscriptionId, key);
@@ -134,20 +355,31 @@ const makeQueryCache = (allocateId, sendLifecycleMessage) => {
 			entry.result = error;
 			for (const listener of entry.listeners) listener();
 		},
-		setResult: (id, result) => {
+		setResult: (id, result, revision) => {
 			const key = queryKeysById.get(id);
 			const entry = key === void 0 ? void 0 : queries.get(key);
 			if (entry === void 0) return;
+			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) => Effect.succeed(wire.type === "Success" ? Result$1.succeed(wire.value === void 0 ? void 0 : decodeTransportValue(wire.value, wire.dates ?? [])) : failureFromWire(wire.error, wire.dates)));
+const shouldReloadForCloseCode = (code) => code === DeploymentChangedCloseCode;
+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
+	resultFromWire,
+	handshakesMatch,
+	shouldReloadForCloseCode
 };
 const socketUrl = () => {
 	const url = new URL(syncPath, globalThis.location.href);
@@ -156,8 +388,10 @@ const socketUrl = () => {
 };
 var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync/SyncClient") {
 	static layer = Layer.effect(SyncClient, Effect.gen(function* () {
-		let nextOperationId = 0;
-		let mutations = HashMap.empty();
+		const ids = yield* IdGenerator;
+		let invocations = HashMap.empty();
+		let rememberedHandshake;
+		let reloadRequested = false;
 		let writer;
 		const encode = (message) => Schema.encodeEffect(ClientMessageJson)(message).pipe(Effect.mapError((cause) => InvalidClientMessage.make({
 			cause,
@@ -168,31 +402,27 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 			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(() => SubscriptionId.make(nextOperationId++), (message) => writer === void 0 ? Effect.void : send(message).pipe(Effect.catchTags({
+		const queryCache = makeQueryCache(ids.generate(SubscriptionId), (message) => writer === void 0 ? Effect.void : send(message).pipe(Effect.catchTags({
 			ConnectionUnavailable: reportClientError,
 			InvalidClientMessage: reportClientError
 		})));
-		const rejectMutation = (requestId, error) => {
-			const pendingMutation = HashMap.getUnsafe(mutations, requestId);
-			if (pendingMutation === void 0) return Effect.void;
-			mutations = HashMap.remove(mutations, requestId);
-			return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingMutation.deferred, error)), Effect.asVoid);
+		const rejectInvocation = (id, error) => {
+			const pendingInvocation = HashMap.getUnsafe(invocations, id);
+			if (pendingInvocation === void 0) return Effect.void;
+			invocations = HashMap.remove(invocations, id);
+			return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)), Effect.asVoid);
 		};
-		const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (text) {
-			const message = yield* Schema.decodeEffect(ServerMessageJson)(text).pipe(Effect.mapError((cause) => InvalidServerMessage.make({
-				cause,
-				message: "The server returned an invalid sync message."
-			})));
+		const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (message) {
 			switch (message.type) {
-				case "QuerySnapshot":
+				case "Snapshot":
 					if (queryCache.getById(message.id) === void 0) return;
-					yield* resultFromWire(message.result).pipe(Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result))));
+					yield* resultFromWire(message.result).pipe(Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result, message.revision))));
 					return;
-				case "MutationResult": {
-					const pendingMutation = HashMap.getUnsafe(mutations, message.id);
-					if (pendingMutation === void 0) return;
-					mutations = HashMap.remove(mutations, message.id);
-					yield* resultFromWire(message.result).pipe(Effect.flatMap((result) => Deferred.succeed(pendingMutation.deferred, result)));
+				case "Result": {
+					const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+					if (pendingInvocation === void 0) return;
+					invocations = HashMap.remove(invocations, message.id);
+					yield* resultFromWire(message.result).pipe(Effect.flatMap((result) => Deferred.succeed(pendingInvocation.deferred, result)));
 					return;
 				}
 				case "ProtocolError": {
@@ -204,8 +434,8 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 						message: message.message,
 						operation: message.operation
 					});
-					if (message.operation?.type === "Mutate") yield* rejectMutation(message.operation.id, error);
-					else if (message.operation?.type === "Query") {
+					if (message.operation?.type === "Invocation") yield* rejectInvocation(message.operation.id, error);
+					else if (message.operation?.type === "Subscription") {
 						queryCache.setError(message.operation.id, error);
 						yield* reportClientError(error);
 					} else yield* reportClientError(error);
@@ -213,27 +443,59 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 				}
 			}
 		});
-		const disconnect = Effect.gen(function* () {
+		const requestReload = () => {
+			if (reloadRequested) return;
+			reloadRequested = true;
+			writer = void 0;
+			globalThis.location.reload();
+		};
+		const disconnect = Effect.sync(() => {
 			writer = void 0;
-			const current = mutations;
-			mutations = HashMap.empty();
-			yield* Effect.forEach(HashMap.entries(current), ([id, pendingMutation]) => {
-				const error = MutationOutcomeUnknown.make({
-					function: pendingMutation.function,
-					id,
-					message: "The connection closed before the mutation outcome was known."
-				});
-				return reportClientError(error).pipe(Effect.andThen(Deferred.fail(pendingMutation.deferred, error)));
-			});
 		});
 		const connect = Effect.scoped(Effect.gen(function* () {
-			const socket = yield* Socket.makeWebSocket(socketUrl(), { closeCodeIsError: () => false });
+			if (reloadRequested) return yield* Effect.never;
+			const socket = yield* Socket.makeWebSocket(socketUrl(), { closeCodeIsError: (code) => {
+				if (shouldReloadForCloseCode(code)) requestReload();
+				return false;
+			} });
 			const write = yield* socket.writer;
-			const onOpen = Effect.gen(function* () {
+			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;
+				rememberedHandshake = handshake;
+				handshakeAccepted = true;
 				writer = write;
-				yield* Effect.forEach(queryCache.entries(), (entry) => sendWith(write, subscribeMessage(entry)));
-			}).pipe(Effect.tapError(reportClientError), Effect.ignore);
-			yield* socket.runString(handleMessage, { onOpen });
+				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 === "DeploymentChanged") {
+					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 run = yield* socket.runString(handleText).pipe(Effect.forkChild);
+			yield* Effect.raceFirst(Deferred.await(handshakeReceived).pipe(Effect.timeout("10 seconds")), Fiber.join(run));
+			yield* Fiber.join(run);
 		})).pipe(Effect.mapError((cause) => Schema.is(ClientInfrastructureError)(cause) ? cause : ConnectionUnavailable.make({
 			cause,
 			message: "The sync connection was lost."
@@ -244,37 +506,33 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 			return yield* queryCache.observe(functionAddress, args);
 		});
 		const mutate = Effect.fn("SyncClient.mutate")(function* (functionAddress, args) {
-			const requestId = RequestId.make(nextOperationId++);
+			const invocationId = yield* ids.generate(InvocationId);
 			const deferred = yield* Deferred.make();
-			mutations = HashMap.set(mutations, requestId, {
-				deferred,
-				function: functionAddress
-			});
 			const message = {
-				type: "Mutate",
-				id: requestId,
+				type: "Invoke",
+				id: invocationId,
+				kind: "Mutation",
 				function: functionAddress,
 				args
 			};
-			yield* Effect.gen(function* () {
-				const mutationWriter = writer;
-				if (mutationWriter === void 0) return yield* ConnectionUnavailable.make({ message: "The sync connection is not ready." });
-				return yield* sendWith(mutationWriter, message).pipe(Effect.mapError((error) => Schema.is(InvalidClientMessage)(error) ? error : MutationOutcomeUnknown.make({
-					cause: error,
-					function: functionAddress,
-					id: requestId,
-					message: "The connection failed while sending the mutation."
-				})));
-			}).pipe(Effect.tapError(reportClientError), Effect.tapError(() => Effect.sync(() => mutations = HashMap.remove(mutations, requestId))));
+			invocations = HashMap.set(invocations, invocationId, {
+				deferred,
+				function: functionAddress,
+				message
+			});
+			if (writer !== void 0) yield* sendWith(writer, message).pipe(Effect.catchTags({
+				ConnectionUnavailable: reportClientError,
+				InvalidClientMessage: (error) => rejectInvocation(invocationId, error)
+			}));
 			return yield* Deferred.await(deferred);
 		});
 		return SyncClient.of({
 			mutate,
 			observe
 		});
-	})).pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal));
+	})).pipe(Layer.provide(Layer.merge(Socket.layerWebSocketConstructorGlobal, BrowserCrypto.layer)));
 };
-const syncRuntime = ManagedRuntime.make(SyncClient.layer.pipe(Layer.provideMerge(clientErrorReporterLayer)));
+const syncRuntime = ManagedRuntime.make(SyncClient.layer.pipe(Layer.provideMerge(clientErrorReporterLayer), Layer.provideMerge(IdGenerator.layer)));
 const hot = import.meta.hot;
 if (hot !== void 0) hot.dispose(() => void syncRuntime.dispose());
 //#endregion
@@ -356,9 +614,15 @@ const useMutation = (reference) => useMemo$1(() => {
 	return mutate;
 }, [reference]);
 //#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$1.match };
 //#endregion
-export { Component, Fragment, Query, Result, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, useQuery, useReducer, useRef, useState };
+export { Component, Fragment, Query, Result, app, cloneElement, createContext, createElement, createRef, h, isValidElement, toChildArray, useCallback, useContext, useDebugValue, useEffect, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, useQuery, useReducer, useRef, useState };
 
 //# sourceMappingURL=client.js.map