ignotum 0.0.11 → 0.0.13

package/src/cli/environment.ts

@@ -0,0 +1,133 @@
+import { Array, ConfigProvider, Effect, FileSystem, Path, Schema } from "effect";
+
+import {
+  decodeDefinedEnvironment,
+  emptyEnv,
+  type DefinedEnv,
+  type EnvironmentType,
+} from "@ignotum/contracts/schema";
+
+export class EnvironmentConfigurationInvalid extends Schema.TaggedError<EnvironmentConfigurationInvalid>()(
+  "EnvironmentConfigurationInvalid",
+  {
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export interface LoadedEnvironment<Environment extends DefinedEnv = DefinedEnv> {
+  readonly definition: Environment;
+  readonly raw: Readonly<Record<string, string>>;
+  readonly value: Readonly<EnvironmentType<Environment>>;
+}
+
+export interface RawEnvironment {
+  readonly path: string;
+  readonly raw: Readonly<Record<string, string>>;
+}
+
+const collectKeys = Effect.fn("Environment.collectKeys")(function* (
+  provider: ConfigProvider.ConfigProvider,
+  providerPath: ConfigProvider.Path = [],
+  nameParts: ReadonlyArray<string> = [],
+): Effect.fn.Return<ReadonlyArray<string>, ConfigProvider.SourceError, never> {
+  const node = yield* provider.load(providerPath);
+  if (node === undefined) return [];
+  const own = node._tag === "Value" || node.value !== undefined ? [nameParts.join("_")] : [];
+  if (node._tag === "Value") return own;
+  if (node._tag === "Array") {
+    const children = yield* Effect.forEach(Array.range(0, node.length - 1), (index) =>
+      collectKeys(provider, [...providerPath, index], [...nameParts, index.toString()]),
+    );
+    return [...own, ...Array.flatten(children)];
+  }
+  const children = yield* Effect.forEach(Array.fromIterable(node.keys), (key) =>
+    collectKeys(provider, [...providerPath, key], [...nameParts, key]),
+  );
+  return [...own, ...Array.flatten(children)];
+});
+
+const nodeValue = (node: ConfigProvider.Node | undefined): string | undefined =>
+  node?._tag === "Value" ? node.value : node?.value;
+
+export const readEnvironmentRaw = Effect.fn("Environment.readRaw")(function* (
+  appDirectory: string,
+  hasDefinition: boolean,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const environmentPath = path.join(appDirectory, ".env.ignotum");
+  const exists = yield* fileSystem.exists(environmentPath);
+  if (!hasDefinition && exists) {
+    return yield* EnvironmentConfigurationInvalid.make({
+      message: ".env.ignotum exists but server/env.ts does not define its variables.",
+      path: environmentPath,
+    });
+  }
+  if (!hasDefinition) {
+    return { path: environmentPath, raw: {} } satisfies RawEnvironment;
+  }
+  if (!exists) {
+    return yield* EnvironmentConfigurationInvalid.make({
+      message: "server/env.ts requires a project-root .env.ignotum file.",
+      path: environmentPath,
+    });
+  }
+
+  const provider = yield* ConfigProvider.fromDotEnv({
+    path: environmentPath,
+    preserveEmptyStrings: true,
+  }).pipe(
+    Effect.mapError(() =>
+      EnvironmentConfigurationInvalid.make({
+        message: "Ignotum could not read the project environment file.",
+        path: environmentPath,
+      }),
+    ),
+  );
+  const keys = yield* collectKeys(provider).pipe(
+    Effect.mapError(() =>
+      EnvironmentConfigurationInvalid.make({
+        message: "Ignotum could not inspect the project environment file.",
+        path: environmentPath,
+      }),
+    ),
+  );
+  const entries = yield* Effect.forEach(keys, (key) =>
+    provider.load([key]).pipe(
+      Effect.map((node) => [key, nodeValue(node)] as const),
+      Effect.mapError(() =>
+        EnvironmentConfigurationInvalid.make({
+          message: `Ignotum could not read environment variable '${key}'.`,
+          path: environmentPath,
+        }),
+      ),
+    ),
+  );
+  const raw = Object.fromEntries(
+    entries.flatMap(([key, value]) => (value === undefined ? [] : [[key, value] as const])),
+  );
+  return { path: environmentPath, raw } satisfies RawEnvironment;
+});
+
+export const loadEnvironment = Effect.fn("Environment.load")(function* (
+  appDirectory: string,
+  definition: DefinedEnv,
+  hasDefinition: boolean,
+) {
+  const loaded = yield* readEnvironmentRaw(appDirectory, hasDefinition);
+  if (!hasDefinition) {
+    return {
+      definition: emptyEnv,
+      raw: {},
+      value: Object.freeze({}),
+    } satisfies LoadedEnvironment<typeof emptyEnv>;
+  }
+  const raw = loaded.raw;
+  const value = yield* decodeDefinedEnvironment(definition, raw).pipe(
+    Effect.mapError((error) =>
+      EnvironmentConfigurationInvalid.make({ message: error.message, path: loaded.path }),
+    ),
+  );
+  return { definition, raw, value } satisfies LoadedEnvironment;
+});

package/src/client/files.ts

@@ -12,7 +12,7 @@ import {
   type FileValue,
 } from "@ignotum/contracts/schema/file";
 import { IdGenerator } from "@ignotum/shared/id";
-import { Effect, Predicate } from "effect";
+import { Effect, Predicate, Schema } from "effect";
 
 export const Files = {
   url: (file: FileValue): string => {
@@ -27,13 +27,19 @@ export const Files = {
 const formatByMime: Partial<Record<string, FileFormat>> = {};
 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 = (
   // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This is the recursive parser for generated mutation arguments and native File values.
   value: unknown,
-  files: Array<File>,
+  files: Set<File>,
 ): void => {
   if (value instanceof File) {
-    files.push(value);
+    files.add(value);
     return;
   }
   if (isFileValue(value) || Predicate.isDate(value)) return;
@@ -42,7 +48,9 @@ const collectNativeFiles = (
     return;
   }
   if (!Predicate.isObject(value)) return;
-  for (const child of Object.values(value)) collectNativeFiles(child, files);
+  for (const child of Object.values(Schema.decodeSync(MutationObject)(value))) {
+    collectNativeFiles(child, files);
+  }
 };
 
 const replaceNativeFiles = (
@@ -72,36 +80,42 @@ export const prepareMutationArguments = Effect.fn("SyncClient.prepareMutationArg
   input: unknown,
 ) {
   const ids = yield* IdGenerator;
-  const native: File[] = [];
-  collectNativeFiles(input, native);
-  const unique = new Set(native);
-  if (unique.size > fileLimits.filesPerMutation) {
-    throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
-  }
-  const totalBytes = [...unique].reduce((total, file) => total + file.size, 0);
-  if (totalBytes > fileLimits.mutationBytes) {
-    throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
-  }
+  const unique = yield* Effect.try(() => {
+    const files = new Set<File>();
+    collectNativeFiles(input, files);
+    if (files.size > fileLimits.filesPerMutation) {
+      throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
+    }
+    const totalBytes = [...files].reduce((total, file) => total + file.size, 0);
+    if (totalBytes > fileLimits.mutationBytes) {
+      throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
+    }
+    return files;
+  });
   const replacements = new Map<File, FileValue>();
   const nativeFiles = new Map<FileId, File>();
   for (const file of unique) {
-    const format = formatByMime[file.type.toLowerCase()];
-    if (format === undefined) {
-      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.`);
-    }
+    const format = yield* Effect.try(() => {
+      const format = formatByMime[file.type.toLowerCase()];
+      if (format === undefined) {
+        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);
   }
-  const value = replaceNativeFiles(input, replacements);
+  const value =
+    unique.size === 0 ? input : yield* Effect.try(() => replaceNativeFiles(input, replacements));
   return {
     value,
     nativeFiles,
@@ -121,6 +135,8 @@ export const applyFileGrants = (
   grants: ReadonlyArray<FileGrant>,
   // oxlint-disable-next-line anti-slop/no-unknown-returns -- The traversal preserves the decoded query result shape while attaching private symbols.
 ): unknown => {
+  if (grants.length === 0) return value;
+
   const byId = new Map<FileId, string>();
   for (const grant of grants) {
     if (byId.has(grant.id)) throw new Error("A query file grant ID is duplicated.");

package/src/client/hooks.ts

@@ -1,3 +1,5 @@
+import { BrowserSession, type IdState } from "./id.js";
+import type { ProfileField } from "@ignotum/contracts/id";
 import { Effect, Schema } from "effect";
 import { useCallback, useDebugValue, useEffect, useMemo, useState } from "preact/hooks";
 
@@ -12,6 +14,8 @@ import {
 import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
 import { ClientInfrastructureError } from "./errors.js";
 import { isQuerySkip, type QuerySkip } from "./query.js";
+// oxlint-disable-next-line anti-slop-effect/no-service-constructor-imports -- Each mounted pagination hook owns and releases its page observers.
+import { makePageObservers } from "./page-observers.js";
 import { SyncClient, syncClientInternals, syncRuntime } from "./sync.js";
 
 // @effect-diagnostics-next-line missingPipeableSignature:off React hooks are not pipeable functions.
@@ -158,6 +162,18 @@ export function usePaginatedQuery<Args extends object, Item, Failure extends Err
     readonly result: QueryResult<PaginatedQueryValue<Item>, Failure> | ClientInfrastructureError;
   }>(() => ({ identity, result: pending() }));
   const loadMore = useCallback(() => setRequestedPages((count) => count + 1), []);
+  const pages = useMemo(
+    () =>
+      makePageObservers(
+        () => setRefresh((version) => version + 1),
+        (release) => {
+          syncRuntime.runFork(release);
+        },
+      ),
+    [identity, pageSize],
+  );
+
+  useEffect(() => () => pages.release(), [pages]);
 
   useDebugValue({ args: input, function: functionPath, result: state.result });
 
@@ -170,12 +186,11 @@ export function usePaginatedQuery<Args extends object, Item, Failure extends Err
     if (skipped) return;
 
     let active = true;
-    const releases: Array<() => void> = [];
+    const usedPages = new Set<string>();
 
     void syncRuntime
       .runPromise(
         Effect.gen(function* () {
-          const client = yield* SyncClient;
           const items: Item[] = [];
           let cursor: PaginationOptions["cursor"] = null;
 
@@ -184,18 +199,9 @@ export function usePaginatedQuery<Args extends object, Item, Failure extends Err
               ...input,
               pagination: { cursor, pageSize },
             });
-            const observer = yield* client.observe(functionPath, pageArgs);
-            if (!active) {
-              yield* observer.release;
-              return;
-            }
-            const releaseSubscription = observer.subscribe(() => {
-              if (active) setRefresh((version) => version + 1);
-            });
-            releases.push(() => {
-              releaseSubscription();
-              syncRuntime.runFork(observer.release);
-            });
+            usedPages.add(syncClientInternals.queryIdentity(functionPath, pageArgs));
+            const observer = yield* pages.observe(functionPath, pageArgs);
+            if (!active || observer === undefined) return;
 
             const snapshot = observer.getSnapshot();
             if (Schema.is(ClientInfrastructureError)(snapshot)) {
@@ -240,7 +246,13 @@ export function usePaginatedQuery<Args extends object, Item, Failure extends Err
             identity,
             result: RuntimeResult.succeed({ items, loadMore, status: "CanLoadMore" }),
           });
-        }),
+        }).pipe(
+          Effect.ensuring(
+            Effect.sync(() => {
+              if (active) pages.retain(usedPages);
+            }),
+          ),
+        ),
       )
       .catch((error) => {
         if (active && Schema.is(ClientInfrastructureError)(error)) {
@@ -250,9 +262,8 @@ export function usePaginatedQuery<Args extends object, Item, Failure extends Err
 
     return () => {
       active = false;
-      for (const release of releases) release();
     };
-  }, [functionPath, identity, loadMore, pageSize, refresh, requestedPages, skipped]);
+  }, [functionPath, identity, loadMore, pageSize, pages, refresh, requestedPages, skipped]);
 
   if (skipped || state.identity !== identity) return pending();
   const result = state.result;
@@ -288,3 +299,69 @@ export const useMutation = <Args extends object | void, Success, Failure extends
     // both call shapes normalize omitted arguments to the empty JSON object.
     return mutate as Mutation<Args, Success, Failure>;
   }, [reference]);
+
+export type IdOptions = {
+  readonly profile?: ReadonlyArray<ProfileField>;
+  readonly returnTo?: string;
+};
+export type IdResult = IdState & {
+  readonly signIn: (options?: IdOptions) => Promise<void>;
+  readonly requestProfile: (
+    fields: ReadonlyArray<ProfileField>,
+    options?: { readonly returnTo?: string },
+  ) => Promise<void>;
+  readonly signOut: () => Promise<void>;
+};
+
+export function useId(): IdResult {
+  const [state, setState] = useState<IdState>({ status: "pending" });
+  useEffect(() => {
+    let active = true;
+    let unsubscribe: (() => void) | undefined;
+    void 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(
+    () => ({
+      signIn: (options?: IdOptions) =>
+        syncRuntime.runPromise(
+          Effect.gen(function* () {
+            return yield* (yield* BrowserSession).start(
+              "signIn",
+              options?.profile ?? [],
+              options?.returnTo,
+            );
+          }),
+        ),
+      requestProfile: (
+        fields: ReadonlyArray<ProfileField>,
+        options?: { readonly returnTo?: string },
+      ) =>
+        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 };
+}

package/src/client/id.ts

@@ -0,0 +1,259 @@
+import { Context, Effect, Layer, Option, Schema, Semaphore } from "effect";
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse,
+} from "effect/unstable/http";
+import {
+  DevelopmentSelection,
+  developmentSelectionKey,
+  SessionOutcome,
+  SessionRedirect,
+  SessionRequest,
+  SessionResponse,
+  sessionPath,
+  sessionRequestsPath,
+  type ProfileField,
+  type SessionState,
+  type User,
+} from "@ignotum/contracts/id";
+import { IdGenerator } from "@ignotum/shared/id";
+import { SessionEpoch } from "@ignotum/contracts/runtime/id";
+
+export class IdRequestError extends Schema.TaggedError<IdRequestError>()("IdRequestError", {
+  message: Schema.String,
+}) {}
+
+export type IdState =
+  | { readonly status: "pending"; readonly outcome?: SessionOutcome }
+  | { readonly status: "error"; readonly error: string; readonly outcome?: SessionOutcome }
+  | { readonly status: "signedOut"; readonly outcome?: SessionOutcome }
+  | { readonly status: "signedIn"; readonly user: User; readonly outcome?: SessionOutcome };
+
+const outcomeKey = "ignotum.id.outcome";
+const selectionJson = Schema.fromJsonString(DevelopmentSelection);
+
+export class BrowserSession extends Context.Service<
+  BrowserSession,
+  {
+    readonly snapshot: () => IdState;
+    readonly current: () => SessionState | undefined;
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly bootstrap: Effect.Effect<SessionState, IdRequestError>;
+    readonly accept: (session: SessionState, serverTime: number) => void;
+    readonly suspend: (error?: string) => void;
+    readonly socketParameters: () => string;
+    readonly start: (
+      intent: "signIn" | "requestProfile",
+      profile: ReadonlyArray<ProfileField>,
+      returnTo?: string,
+    ) => Effect.Effect<void, IdRequestError>;
+    readonly signOut: Effect.Effect<void, IdRequestError>;
+  }
+>()("ignotum/client/id/BrowserSession") {
+  static readonly 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 = new Set<() => void>();
+      let state: IdState = { status: "pending" };
+      let current: SessionState | undefined;
+      let generation = 0;
+      let deadline = Infinity;
+      let development = false;
+      let selection: DevelopmentSelection | undefined;
+      let expiry: ReturnType<typeof setTimeout> | undefined;
+      const notify = () => {
+        for (const listener of listeners) listener();
+      };
+      const suspend = (error?: string) => {
+        generation += 1;
+        deadline = Infinity;
+        if (expiry !== undefined) clearTimeout(expiry);
+        current = undefined;
+        state =
+          error === undefined
+            ? { status: "pending", outcome: state.outcome }
+            : { status: "error", error, outcome: state.outcome };
+        notify();
+      };
+      const accept = (session: SessionState, serverTime: number) => {
+        generation += 1;
+        if (expiry !== undefined) 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 < 2_147_483_647) expiry = setTimeout(() => suspend(), delay);
+        notify();
+      };
+      const checkExpiry = () => {
+        if (current !== undefined && performance.now() >= deadline) suspend();
+      };
+      globalThis.addEventListener?.("focus", checkExpiry);
+      globalThis.document?.addEventListener("visibilitychange", checkExpiry);
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          if (expiry !== undefined) 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 === undefined) 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 === undefined) {
+              const saved = globalThis.sessionStorage.getItem(developmentSelectionKey);
+              const decoded =
+                saved === null
+                  ? Option.none<DevelopmentSelection>()
+                  : Schema.decodeOption(selectionJson)(saved);
+              selection = Option.getOrElse(decoded, () => ({
+                formatVersion: 1 as const,
+                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 !== undefined) return current;
+              return yield* IdRequestError.make({
+                message: "Your ID session changed while loading.",
+              });
+            }
+            readOutcome();
+            if (session.outcome !== undefined) 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: "signIn" | "requestProfile",
+        profile: ReadonlyArray<ProfileField>,
+        returnTo?: string,
+      ) {
+        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));
+}