ignotum 0.0.12 → 0.0.13

package/dist/runtime/client.js

@@ -1,9 +1,10 @@
-import { C as RuntimeRequestNonce, T as TableId, _ as AppId, a as RuntimeFileMetadata, b as IdAlphabet, c as fileFormats, d as fileLimits, f as fileMimeTypes, h as makeFileValue, l as fileGrantUrlOf, m as isFileValue, o as RuntimeFileOccurrence, p as grantFileValue, r as FileId, u as fileIdOf, v as DeploymentId, w as SubscriptionId, x as InvocationId, y as GeneratedId } from "./file-C1abuMgd.js";
-import { S as encodeTransportObject, c as initial, f as Result$2, g as pending, h as inspectResult, l as upgrade, m as failureFromWire, s as PaginationPageSize, t as ValueDescriptor, x as decodeTransportValue } from "./descriptor-XzDX2JDw-j3O6YHgW.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-DzcR7spt.js";
-import { Array as Array$1, Cause, Context, Deferred, Duration, Effect, ErrorReporter, Fiber, HashMap, Layer, ManagedRuntime, Predicate, Schedule, Schema, String } from "effect";
+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 { useCallback, useCallback as useCallback$1, 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 { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+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";
@@ -119,6 +120,177 @@ const encodeJson = (value) => {
 };
 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", {
@@ -198,7 +370,9 @@ const IndexPointInvalidation = Schema.Struct({
 	index: IndexIdentity,
 	key: EncodedIndexKey
 });
+const IdDependency = Schema.Struct({ type: Schema.Literal("Id") });
 const ReadDependency = Schema.Union([
+	IdDependency,
 	TableDependency,
 	DocumentDependency,
 	IndexRangeDependency
@@ -263,7 +437,8 @@ const InvocationBase = {
 	generation: DeploymentGeneration,
 	invocationKey: InvocationKey,
 	function: FunctionAddress,
-	args: Schema.Json
+	args: Schema.Json,
+	identity: Schema.optional(SessionState)
 };
 const QueryInvocation = Schema.Struct({
 	...InvocationBase,
@@ -286,6 +461,7 @@ var RuntimeDeploymentUnavailable = class extends Schema.TaggedError()("RuntimeDe
 	message: Schema.String
 }) {};
 const RuntimeInvocationRejectionCode = Schema.Literals([
+	"SessionExpired",
 	"FunctionUnavailable",
 	"InvalidArguments",
 	"InvocationIdConflict",
@@ -554,55 +730,67 @@ const subscribeMessage = (entry) => ({
 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: 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
-					});
-				})
-			};
-		}),
+		observe,
 		setResult: (id, result, revision) => {
 			const entry = queriesById.get(id);
 			if (entry === void 0) return;
@@ -644,10 +832,12 @@ const socketUrl = () => {
 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."
@@ -661,17 +851,47 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 			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 = HashMap.getUnsafe(invocations, id);
+			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);
@@ -680,12 +900,14 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 					return;
 				}
 				case "Preparation": {
-					const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+					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": {
-					const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+					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);
@@ -694,6 +916,7 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 					return;
 				}
 				case "Error": {
+					if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
 					const error = message.operation === void 0 ? ServerError.make({
 						code: message.code,
 						message: message.message
@@ -722,7 +945,8 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 		});
 		const connect = Effect.scoped(Effect.gen(function* () {
 			if (reloadRequested) return yield* Effect.never;
-			const socket = yield* Socket.makeWebSocket(socketUrl(), { closeCodeIsError: (code) => {
+			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;
 			} });
@@ -736,6 +960,22 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 					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;
@@ -761,9 +1001,14 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 				});
 				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* 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."
@@ -774,6 +1019,7 @@ 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 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,
@@ -806,6 +1052,7 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 				files: preparedArguments.fileIds
 			};
 			invocations = HashMap.set(invocations, invocationId, {
+				sessionEpoch: admittedSession.sessionEpoch,
 				deferred,
 				function: functionAddress,
 				message,
@@ -867,7 +1114,7 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 						concurrency: 3,
 						discard: true
 					});
-					const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+					const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, invocationId));
 					if (pendingInvocation === void 0) return yield* Deferred.await(deferred);
 					invocations = HashMap.set(invocations, invocationId, {
 						...pendingInvocation,
@@ -889,7 +1136,7 @@ var SyncClient = class SyncClient extends Context.Service()("ignotum/client/sync
 		});
 	})).pipe(Layer.provide(Layer.merge(Socket.layerWebSocketConstructorGlobal, BrowserCrypto.layer)));
 };
-const syncRuntime = ManagedRuntime.make(SyncClient.layer.pipe(Layer.provideMerge(clientErrorReporterLayer), Layer.provideMerge(IdGenerator.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
@@ -1135,6 +1382,38 @@ const useMutation = (reference) => useMemo$1(() => {
 	};
 	return mutate;
 }, [reference]);
+function useId() {
+	const [state, setState] = useState$1({ status: "pending" });
+	useEffect$1(() => {
+		let active = true;
+		let unsubscribe;
+		syncRuntime.runPromise(BrowserSession).then((session) => {
+			if (!active) return;
+			const update = () => setState(session.snapshot());
+			unsubscribe = session.subscribe(update);
+			update();
+		});
+		return () => {
+			active = false;
+			unsubscribe?.();
+		};
+	}, []);
+	const actions = useMemo$1(() => ({
+		signIn: (options) => syncRuntime.runPromise(Effect.gen(function* () {
+			return yield* (yield* BrowserSession).start("signIn", options?.profile ?? [], options?.returnTo);
+		})),
+		requestProfile: (fields, options) => syncRuntime.runPromise(Effect.gen(function* () {
+			return yield* (yield* BrowserSession).start("requestProfile", fields, options?.returnTo);
+		})),
+		signOut: () => syncRuntime.runPromise(Effect.gen(function* () {
+			return yield* (yield* BrowserSession).signOut;
+		}))
+	}), []);
+	return {
+		...state,
+		...actions
+	};
+}
 //#endregion
 //#region src/client/app.ts
 const app = (definition) => {
@@ -1145,6 +1424,6 @@ const app = (definition) => {
 //#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, useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useMutation, usePaginatedQuery, useQuery, useReducer, useRef, useState };
+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 };
 
 //# sourceMappingURL=client.js.map