@kestack/web-platform 0.0.0-stage → 0.0.0

package/dist/app/gate/react.js

@@ -0,0 +1,107 @@
+import { createContext, useContext, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/app/gate/react.tsx
+const CHECKING = { kind: "checking" };
+/**
+* A Gate as React sees it, on any platform: `SignedIn` and `SignedOut`
+* around any part of the app, from the whole of it to one button;
+* `useGate` anywhere; `useAccounts` and `useSession` inside `SignedIn`. Nothing runs until one of them first renders.
+*/
+const gateReact = (gate) => {
+	const OpenContext = createContext(void 0);
+	const useView = () => useSyncExternalStore(gate.subscribe, gate.view, () => CHECKING);
+	const useOpen = () => {
+		const open = useContext(OpenContext);
+		if (open === void 0) throw new Error("useSession and useAccounts must be inside SignedIn");
+		return open;
+	};
+	/**
+	* Renders `children` while an account is open, `fallback` otherwise (a
+	* node, or one per view). Everything inside remounts on an Account
+	* Switch, so wrap as little as the part that needs an account.
+	*/
+	function SignedIn(props) {
+		const view = useView();
+		if (view.kind !== "open") {
+			const { fallback } = props;
+			return typeof fallback === "function" ? fallback(view) : fallback ?? null;
+		}
+		return /* @__PURE__ */ jsx(OpenContext, {
+			value: view,
+			children: props.children
+		}, view.account.user.id);
+	}
+	/** Renders `children` only while nobody is signed in. */
+	function SignedOut(props) {
+		return useView().kind === "signedOut" ? props.children : null;
+	}
+	const dismissNotice = () => void gate.takeNotice();
+	const answer = (choice) => gate.namedSignIn.answer(choice);
+	/**
+	* The Gate, anywhere: what it shows, the Backend it runs on and changing
+	* it, whether the device is online, the oldest Gate Notice, the Named
+	* Sign-In's question, and what can be done before anyone is open.
+	*/
+	const useGate = () => ({
+		view: useView(),
+		/** The Backend running; null until it has started. */
+		backend: useSyncExternalStore(gate.subscribe, gate.backend, () => null),
+		/** Chooses a Backend and runs on it at once. */
+		setBackend: gate.setBackend,
+		/** Whether the device is online. */
+		online: useSyncExternalStore(gate.onOnlineChange, gate.online, () => true),
+		/** The oldest Gate Notice not yet dismissed. */
+		notice: useSyncExternalStore(gate.subscribe, gate.notice, () => null),
+		dismissNotice,
+		/** Asks the Backend again who is signed in. */
+		checkAgain: gate.checkAgain,
+		/** Tries again to open an account that would not open. */
+		retry: gate.retry,
+		/** Signs an account in, the first or one more. */
+		signIn: gate.addAccount,
+		/** An Account Switch, as from an Account Lost, where nobody is open. */
+		switchTo: gate.switchTo,
+		/** Signs the Active Account out, or forgets a lost one; false when the
+		* Backend can't be reached. */
+		signOut: gate.signOut,
+		/** Whether the device Backend is asking who signs in, and the answer: a
+		* choice, or null to sign nobody in. */
+		namedSignIn: {
+			asking: useSyncExternalStore(gate.namedSignIn.subscribe, gate.namedSignIn.isAsking, () => false),
+			answer
+		}
+	});
+	/**
+	* The Signed-in Accounts, and what is done with them; only inside
+	* `SignedIn`.
+	*/
+	const useAccounts = () => {
+		const open = useOpen();
+		return {
+			/** The open account. */
+			current: open.account,
+			/** Every Signed-in Account. */
+			all: open.accounts,
+			/** Signs one more account in, who becomes the Active Account. */
+			add: gate.addAccount,
+			/** An Account Switch, at once. */
+			switchTo: gate.switchTo,
+			/** False when the Backend can't be reached. */
+			signOut: gate.signOut,
+			/** False when the Backend can't be reached. */
+			signOutEveryone: gate.signOutEveryone
+		};
+	};
+	return {
+		SignedIn,
+		SignedOut,
+		useGate,
+		useAccounts,
+		/** The open Account's Session; only inside `SignedIn`. */
+		useSession: () => useOpen().session
+	};
+};
+//#endregion
+export { gateReact };
+
+//# sourceMappingURL=react.js.map

package/dist/app/gate/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../../../src/app/gate/react.tsx"],"sourcesContent":["import {\n  createContext,\n  type ReactNode,\n  useContext,\n  useSyncExternalStore,\n} from 'react';\nimport type { NamedChoice } from '@kestack/auth-toolkit/client';\nimport type { GateView } from './domain/index.ts';\nimport type { Gate } from './gate.ts';\n\ntype Open<S> = Extract<GateView<S>, { kind: 'open' }>;\ntype NotOpen<S> = Exclude<GateView<S>, { kind: 'open' }>;\n\nconst CHECKING = { kind: 'checking' } as const;\n\n/**\n * A Gate as React sees it, on any platform: `SignedIn` and `SignedOut`\n * around any part of the app, from the whole of it to one button;\n * `useGate` anywhere; `useAccounts` and `useSession` inside `SignedIn`. Nothing runs until one of them first renders.\n */\nexport const gateReact = <S,>(gate: Gate<S>) => {\n  const OpenContext = createContext<Open<S> | undefined>(undefined);\n\n  // What the Gate shows now; checking until it runs.\n  const useView = (): GateView<S> =>\n    useSyncExternalStore(gate.subscribe, gate.view, () => CHECKING);\n\n  const useOpen = () => {\n    const open = useContext(OpenContext);\n    if (open === undefined)\n      throw new Error('useSession and useAccounts must be inside SignedIn');\n    return open;\n  };\n\n  /**\n   * Renders `children` while an account is open, `fallback` otherwise (a\n   * node, or one per view). Everything inside remounts on an Account\n   * Switch, so wrap as little as the part that needs an account.\n   */\n  function SignedIn(props: {\n    readonly children: ReactNode;\n    readonly fallback?: ReactNode | ((view: NotOpen<S>) => ReactNode);\n  }) {\n    const view = useView();\n    if (view.kind !== 'open') {\n      const { fallback } = props;\n      return typeof fallback === 'function'\n        ? fallback(view as NotOpen<S>)\n        : (fallback ?? null);\n    }\n    return (\n      <OpenContext key={view.account.user.id} value={view}>\n        {props.children}\n      </OpenContext>\n    );\n  }\n\n  /** Renders `children` only while nobody is signed in. */\n  function SignedOut(props: { readonly children: ReactNode }) {\n    return useView().kind === 'signedOut' ? props.children : null;\n  }\n\n  const dismissNotice = () => void gate.takeNotice();\n  const answer = (choice: NamedChoice | null) =>\n    gate.namedSignIn.answer(choice);\n\n  /**\n   * The Gate, anywhere: what it shows, the Backend it runs on and changing\n   * it, whether the device is online, the oldest Gate Notice, the Named\n   * Sign-In's question, and what can be done before anyone is open.\n   */\n  const useGate = () => ({\n    view: useView(),\n    /** The Backend running; null until it has started. */\n    backend: useSyncExternalStore(gate.subscribe, gate.backend, () => null),\n    /** Chooses a Backend and runs on it at once. */\n    setBackend: gate.setBackend,\n    /** Whether the device is online. */\n    online: useSyncExternalStore(gate.onOnlineChange, gate.online, () => true),\n    /** The oldest Gate Notice not yet dismissed. */\n    notice: useSyncExternalStore(gate.subscribe, gate.notice, () => null),\n    dismissNotice,\n    /** Asks the Backend again who is signed in. */\n    checkAgain: gate.checkAgain,\n    /** Tries again to open an account that would not open. */\n    retry: gate.retry,\n    /** Signs an account in, the first or one more. */\n    signIn: gate.addAccount,\n    /** An Account Switch, as from an Account Lost, where nobody is open. */\n    switchTo: gate.switchTo,\n    /** Signs the Active Account out, or forgets a lost one; false when the\n     * Backend can't be reached. */\n    signOut: gate.signOut,\n    /** Whether the device Backend is asking who signs in, and the answer: a\n     * choice, or null to sign nobody in. */\n    namedSignIn: {\n      asking: useSyncExternalStore(\n        gate.namedSignIn.subscribe,\n        gate.namedSignIn.isAsking,\n        () => false,\n      ),\n      answer,\n    },\n  });\n\n  /**\n   * The Signed-in Accounts, and what is done with them; only inside\n   * `SignedIn`.\n   */\n  const useAccounts = () => {\n    const open = useOpen();\n    return {\n      /** The open account. */\n      current: open.account,\n      /** Every Signed-in Account. */\n      all: open.accounts,\n      /** Signs one more account in, who becomes the Active Account. */\n      add: gate.addAccount,\n      /** An Account Switch, at once. */\n      switchTo: gate.switchTo,\n      /** False when the Backend can't be reached. */\n      signOut: gate.signOut,\n      /** False when the Backend can't be reached. */\n      signOutEveryone: gate.signOutEveryone,\n    };\n  };\n\n  return {\n    SignedIn,\n    SignedOut,\n    useGate,\n    useAccounts,\n    /** The open Account's Session; only inside `SignedIn`. */\n    useSession: (): S => useOpen().session,\n  };\n};\n\n/** A Gate's React side, as `gateReact` makes it. */\nexport type GateReact<S> = ReturnType<typeof gateReact<S>>;\n"],"mappings":";;;AAaA,MAAM,WAAW,EAAE,MAAM,WAAW;;;;;;AAOpC,MAAa,aAAiB,SAAkB;CAC9C,MAAM,cAAc,cAAmC,KAAA,CAAS;CAGhE,MAAM,gBACJ,qBAAqB,KAAK,WAAW,KAAK,YAAY,QAAQ;CAEhE,MAAM,gBAAgB;EACpB,MAAM,OAAO,WAAW,WAAW;EACnC,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,MAAM,oDAAoD;EACtE,OAAO;CACT;;;;;;CAOA,SAAS,SAAS,OAGf;EACD,MAAM,OAAO,QAAQ;EACrB,IAAI,KAAK,SAAS,QAAQ;GACxB,MAAM,EAAE,aAAa;GACrB,OAAO,OAAO,aAAa,aACvB,SAAS,IAAkB,IAC1B,YAAY;EACnB;EACA,OACE,oBAAC,aAAD;GAAwC,OAAO;GAC5C,UAAA,MAAM;EACI,GAFK,KAAK,QAAQ,KAAK,EAEvB;CAEjB;;CAGA,SAAS,UAAU,OAAyC;EAC1D,OAAO,QAAQ,CAAC,CAAC,SAAS,cAAc,MAAM,WAAW;CAC3D;CAEA,MAAM,sBAAsB,KAAK,KAAK,WAAW;CACjD,MAAM,UAAU,WACd,KAAK,YAAY,OAAO,MAAM;;;;;;CAOhC,MAAM,iBAAiB;EACrB,MAAM,QAAQ;;EAEd,SAAS,qBAAqB,KAAK,WAAW,KAAK,eAAe,IAAI;;EAEtE,YAAY,KAAK;;EAEjB,QAAQ,qBAAqB,KAAK,gBAAgB,KAAK,cAAc,IAAI;;EAEzE,QAAQ,qBAAqB,KAAK,WAAW,KAAK,cAAc,IAAI;EACpE;;EAEA,YAAY,KAAK;;EAEjB,OAAO,KAAK;;EAEZ,QAAQ,KAAK;;EAEb,UAAU,KAAK;;;EAGf,SAAS,KAAK;;;EAGd,aAAa;GACX,QAAQ,qBACN,KAAK,YAAY,WACjB,KAAK,YAAY,gBACX,KACR;GACA;EACF;CACF;;;;;CAMA,MAAM,oBAAoB;EACxB,MAAM,OAAO,QAAQ;EACrB,OAAO;;GAEL,SAAS,KAAK;;GAEd,KAAK,KAAK;;GAEV,KAAK,KAAK;;GAEV,UAAU,KAAK;;GAEf,SAAS,KAAK;;GAEd,iBAAiB,KAAK;EACxB;CACF;CAEA,OAAO;EACL;EACA;EACA;EACA;;EAEA,kBAAqB,QAAQ,CAAC,CAAC;CACjC;AACF"}

package/dist/app/host/host.d.ts

@@ -0,0 +1,90 @@
+import { Layer, Schema } from "effect";
+import { SignIn } from "@kestack/auth-toolkit/client";
+import { SyncStore } from "@kestack/std-toolkit/sync";
+import { Broadcaster } from "@kestack/std-toolkit/core";
+import { StdTableService, TableDefinition } from "@kestack/std-toolkit/db";
+//#region src/app/host/host.d.ts
+/** Where an app's Backend runs, and its Users sign in: in the cloud, or on
+ * this device, in the app itself. */
+export declare const Backend: Schema.Literals<readonly ["cloud", "device"]>;
+export type Backend = typeof Backend.Type;
+/** The Backend `name` names, by its name or its former one (`remote`,
+ * `local`); null for anything else. */
+export declare const backendNamed: (name: string | null | undefined) => Backend | null;
+/** A table as a Host needs it to keep it. */
+export type TableSource<Name extends string> = Pick<TableDefinition<Name>, 'logicalName' | 'primary' | 'localSecondaryIndexes' | 'globalSecondaryIndexes'>;
+/** What one tab tells the device's other tabs: look again. `quiet` are
+ * accounts it signed out itself, so they are not reported lost there. */
+export type TabMessage = {
+  readonly quiet: ReadonlyArray<string>;
+};
+/** Where a Host keeps things: a table adapter and a Sync adapter for the
+ * same place, such as IndexedDB in a browser or SQLite on a phone. */
+export interface Storage {
+  /** One table, kept in one of this device's databases, by name. */
+  readonly table: <Name extends string>(table: TableSource<Name>, database: string) => Layer.Layer<StdTableService<Name>>;
+  /** What hears every write to one of this device's databases, by name:
+   * everyone writing to it here, such as every tab on one IndexedDB
+   * database, so a handler's change reaches every subscription. */
+  readonly broadcaster: (database: string) => Layer.Layer<Broadcaster>;
+  /** The Sync adapter here, where what a Std Sync keeps outlives the app so
+   * it opens offline, and every Std Sync kept on this device, by name. */
+  readonly sync: SyncStore & {
+    readonly list: () => Promise<ReadonlyArray<{
+      readonly name: string;
+    }>>;
+    readonly remove: (name: string) => Promise<void>;
+  };
+}
+/**
+ * One Broadcaster per database for as long as the app runs, made by `make`
+ * the first time a database is asked for and then given as it is, so every
+ * runtime that writes to the database shares it.
+ */
+export declare const keptBroadcasters: (make: (database: string) => Layer.Layer<Broadcaster>) => Storage['broadcaster'];
+/**
+ * Everything an app needs of where it runs: its Storage, its cloud address
+ * and Sign-in, its lifecycle, and its other tabs if it has any. The browser
+ * gives one (`webHost`) and tests give one in memory. An app never meets it.
+ */
+export interface Host {
+  readonly storage: Storage;
+  /** The cloud Backend: where its APIs answer, and, for an app with auth,
+   * how a user signs in to it and the sign-in service's own page for
+   * managing accounts. */
+  readonly cloud: {
+    /** What an API's path is resolved against. */
+    readonly url: string;
+    readonly signIn?: Layer.Layer<SignIn>;
+    readonly manageAccounts?: () => Promise<void>;
+  };
+  /** When the app is online and in view. */
+  readonly lifecycle: {
+    readonly online: () => boolean;
+    /** Calls `changed` whenever the network comes or goes. */
+    readonly onOnlineChange: (changed: () => void) => () => void;
+    /** Calls `shown` whenever the app comes back into view. */
+    readonly onForeground: (shown: () => void) => () => void;
+    /** The Backend the launch asked for, if any, as `?backend=device` does
+     * on the web. Asked once, at start. */
+    readonly launchBackend: () => Backend | null;
+  };
+  /** The device's other tabs, where there can be more than one. */
+  readonly tabs?: {
+    readonly announce: (message: TabMessage) => void;
+    readonly listen: (heard: (message: TabMessage) => void) => () => void;
+  };
+}
+/**
+ * A Host kept in memory, with no network events and no other tabs: for
+ * tests, and for running an app where nothing outlives the process. Its
+ * cloud Sign-in signs nobody in unless `signIn` is given.
+ */
+export declare const memoryHost: (options?: {
+  readonly online?: () => boolean;
+  readonly signIn?: Layer.Layer<SignIn>;
+  readonly url?: string;
+  readonly launchBackend?: Backend | null;
+}) => Host;
+//#endregion
+//# sourceMappingURL=host.d.ts.map

package/dist/app/host/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","names":[],"sources":["../../../src/app/host/host.ts"],"mappings":";;;;;;;;qBAYa,SAAO,OAAA;YACR,iBAAiB,QAAQ;;;qBAUxB,eAAY,oCAEtB;;YAQS,YAAY,uBAAuB,KAC7C,gBAAgB;;;YAMN;WAAwB,OAAO;;;;iBAI1B;;WAEN,QAAQ,qBACf,OAAO,YAAY,OACnB,qBACG,MAAM,MAAM,gBAAgB;;;;WAIxB,cAAc,qBAAqB,MAAM,MAAM;;;WAG/C,MAAM;aACJ,YAAY,QAAQ;eAAyB;;aAC7C,SAAS,iBAAiB;;;;;;;;qBAS1B,mBAAgB,OACpB,qBAAqB,MAAM,MAAM,iBACvC;;;;;;iBAqBc;WACN,SAAS;;;;WAIT;;aAEE;aACA,SAAS,MAAM,MAAM;aACrB,uBAAuB;;;WAGzB;aACE;;aAEA,iBAAiB;;aAEjB,eAAe;;;aAGf,qBAAqB;;;WAGvB;aACE,WAAW,SAAS;aACpB,SAAS,QAAQ,SAAS;;;;;;;;qBAS1B,aAAU;WAEV;WACA,SAAS,MAAM,MAAM;WACrB;WACA,gBAAgB;MAE1B"}

package/dist/app/host/host.js

@@ -0,0 +1,75 @@
+import { Effect, Layer, Schema, Scope } from "effect";
+import { signIn } from "@kestack/auth-toolkit/client";
+import { Sync } from "@kestack/std-toolkit/sync";
+import { defaultBroadcaster } from "@kestack/std-toolkit/core";
+import { Memory } from "@kestack/std-toolkit/db/memory";
+//#region src/app/host/host.ts
+/** Where an app's Backend runs, and its Users sign in: in the cloud, or on
+* this device, in the app itself. */
+const Backend = Schema.Literals(["cloud", "device"]);
+const FORMER = {
+	remote: "cloud",
+	local: "device"
+};
+/** The Backend `name` names, by its name or its former one (`remote`,
+* `local`); null for anything else. */
+const backendNamed = (name) => name === "cloud" || name === "device" ? name : name == null ? null : FORMER[name] ?? null;
+/**
+* One Broadcaster per database for as long as the app runs, made by `make`
+* the first time a database is asked for and then given as it is, so every
+* runtime that writes to the database shares it.
+*/
+const keptBroadcasters = (make) => {
+	const kept = /* @__PURE__ */ new Map();
+	return (database) => {
+		let layer = kept.get(database);
+		if (layer === void 0) {
+			layer = Layer.succeedContext(Effect.runSync(Layer.buildWithScope(make(database), Scope.makeUnsafe())));
+			kept.set(database, layer);
+		}
+		return layer;
+	};
+};
+/**
+* A Host kept in memory, with no network events and no other tabs: for
+* tests, and for running an app where nothing outlives the process. Its
+* cloud Sign-in signs nobody in unless `signIn` is given.
+*/
+const memoryHost = (options = {}) => {
+	const tables = /* @__PURE__ */ new Map();
+	const table = (source, database) => {
+		const key = `${database}/${source.logicalName}`;
+		let kept = tables.get(key);
+		if (kept === void 0) {
+			kept = Memory.make(source).layer;
+			tables.set(key, kept);
+		}
+		return kept;
+	};
+	return {
+		storage: {
+			table,
+			broadcaster: keptBroadcasters(() => defaultBroadcaster),
+			sync: {
+				...Sync.memory(),
+				list: async () => [],
+				remove: async () => {}
+			}
+		},
+		cloud: {
+			url: options.url ?? "http://localhost",
+			signIn: options.signIn ?? signIn.named({ choose: Effect.succeed(null) }),
+			manageAccounts: async () => {}
+		},
+		lifecycle: {
+			online: options.online ?? (() => true),
+			onOnlineChange: () => () => {},
+			onForeground: () => () => {},
+			launchBackend: () => options.launchBackend ?? null
+		}
+	};
+};
+//#endregion
+export { Backend, backendNamed, keptBroadcasters, memoryHost };
+
+//# sourceMappingURL=host.js.map

package/dist/app/host/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":[],"sources":["../../../src/app/host/host.ts"],"sourcesContent":["import { Effect, Layer, Schema, Scope } from 'effect';\nimport { type SignIn, signIn } from '@kestack/auth-toolkit/client';\nimport {\n  type Broadcaster,\n  defaultBroadcaster,\n} from '@kestack/std-toolkit/core';\nimport type { StdTableService, TableDefinition } from '@kestack/std-toolkit/db';\nimport { Memory } from '@kestack/std-toolkit/db/memory';\nimport { Sync, type SyncStore } from '@kestack/std-toolkit/sync';\n\n/** Where an app's Backend runs, and its Users sign in: in the cloud, or on\n * this device, in the app itself. */\nexport const Backend = Schema.Literals(['cloud', 'device']);\nexport type Backend = typeof Backend.Type;\n\n// What the Backends were called before, as a device may still keep them.\nconst FORMER: Readonly<Record<string, Backend>> = {\n  remote: 'cloud',\n  local: 'device',\n};\n\n/** The Backend `name` names, by its name or its former one (`remote`,\n * `local`); null for anything else. */\nexport const backendNamed = (\n  name: string | null | undefined,\n): Backend | null =>\n  name === 'cloud' || name === 'device'\n    ? name\n    : name == null\n      ? null\n      : (FORMER[name] ?? null);\n\n/** A table as a Host needs it to keep it. */\nexport type TableSource<Name extends string> = Pick<\n  TableDefinition<Name>,\n  'logicalName' | 'primary' | 'localSecondaryIndexes' | 'globalSecondaryIndexes'\n>;\n\n/** What one tab tells the device's other tabs: look again. `quiet` are\n * accounts it signed out itself, so they are not reported lost there. */\nexport type TabMessage = { readonly quiet: ReadonlyArray<string> };\n\n/** Where a Host keeps things: a table adapter and a Sync adapter for the\n * same place, such as IndexedDB in a browser or SQLite on a phone. */\nexport interface Storage {\n  /** One table, kept in one of this device's databases, by name. */\n  readonly table: <Name extends string>(\n    table: TableSource<Name>,\n    database: string,\n  ) => Layer.Layer<StdTableService<Name>>;\n  /** What hears every write to one of this device's databases, by name:\n   * everyone writing to it here, such as every tab on one IndexedDB\n   * database, so a handler's change reaches every subscription. */\n  readonly broadcaster: (database: string) => Layer.Layer<Broadcaster>;\n  /** The Sync adapter here, where what a Std Sync keeps outlives the app so\n   * it opens offline, and every Std Sync kept on this device, by name. */\n  readonly sync: SyncStore & {\n    readonly list: () => Promise<ReadonlyArray<{ readonly name: string }>>;\n    readonly remove: (name: string) => Promise<void>;\n  };\n}\n\n/**\n * One Broadcaster per database for as long as the app runs, made by `make`\n * the first time a database is asked for and then given as it is, so every\n * runtime that writes to the database shares it.\n */\nexport const keptBroadcasters = (\n  make: (database: string) => Layer.Layer<Broadcaster>,\n): Storage['broadcaster'] => {\n  const kept = new Map<string, Layer.Layer<Broadcaster>>();\n  return (database) => {\n    let layer = kept.get(database);\n    if (layer === undefined) {\n      layer = Layer.succeedContext(\n        Effect.runSync(\n          Layer.buildWithScope(make(database), Scope.makeUnsafe()),\n        ),\n      );\n      kept.set(database, layer);\n    }\n    return layer;\n  };\n};\n\n/**\n * Everything an app needs of where it runs: its Storage, its cloud address\n * and Sign-in, its lifecycle, and its other tabs if it has any. The browser\n * gives one (`webHost`) and tests give one in memory. An app never meets it.\n */\nexport interface Host {\n  readonly storage: Storage;\n  /** The cloud Backend: where its APIs answer, and, for an app with auth,\n   * how a user signs in to it and the sign-in service's own page for\n   * managing accounts. */\n  readonly cloud: {\n    /** What an API's path is resolved against. */\n    readonly url: string;\n    readonly signIn?: Layer.Layer<SignIn>;\n    readonly manageAccounts?: () => Promise<void>;\n  };\n  /** When the app is online and in view. */\n  readonly lifecycle: {\n    readonly online: () => boolean;\n    /** Calls `changed` whenever the network comes or goes. */\n    readonly onOnlineChange: (changed: () => void) => () => void;\n    /** Calls `shown` whenever the app comes back into view. */\n    readonly onForeground: (shown: () => void) => () => void;\n    /** The Backend the launch asked for, if any, as `?backend=device` does\n     * on the web. Asked once, at start. */\n    readonly launchBackend: () => Backend | null;\n  };\n  /** The device's other tabs, where there can be more than one. */\n  readonly tabs?: {\n    readonly announce: (message: TabMessage) => void;\n    readonly listen: (heard: (message: TabMessage) => void) => () => void;\n  };\n}\n\n/**\n * A Host kept in memory, with no network events and no other tabs: for\n * tests, and for running an app where nothing outlives the process. Its\n * cloud Sign-in signs nobody in unless `signIn` is given.\n */\nexport const memoryHost = (\n  options: {\n    readonly online?: () => boolean;\n    readonly signIn?: Layer.Layer<SignIn>;\n    readonly url?: string;\n    readonly launchBackend?: Backend | null;\n  } = {},\n): Host => {\n  // One table per database and name, as a real device keeps it.\n  const tables = new Map<string, Layer.Layer<never>>();\n  const table = <Name extends string>(\n    source: TableSource<Name>,\n    database: string,\n  ): Layer.Layer<StdTableService<Name>> => {\n    const key = `${database}/${source.logicalName}`;\n    let kept = tables.get(key);\n    if (kept === undefined) {\n      kept = Memory.make(source as TableDefinition<Name>).layer as never;\n      tables.set(key, kept);\n    }\n    return kept as Layer.Layer<StdTableService<Name>>;\n  };\n  return {\n    storage: {\n      table,\n      broadcaster: keptBroadcasters(() => defaultBroadcaster),\n      // Nothing outlives the process, so there is nothing to list.\n      sync: { ...Sync.memory(), list: async () => [], remove: async () => {} },\n    },\n    cloud: {\n      url: options.url ?? 'http://localhost',\n      signIn: options.signIn ?? signIn.named({ choose: Effect.succeed(null) }),\n      manageAccounts: async () => {},\n    },\n    lifecycle: {\n      online: options.online ?? (() => true),\n      onOnlineChange: () => () => {},\n      onForeground: () => () => {},\n      launchBackend: () => options.launchBackend ?? null,\n    },\n  };\n};\n"],"mappings":";;;;;;;;AAYA,MAAa,UAAU,OAAO,SAAS,CAAC,SAAS,QAAQ,CAAC;AAI1D,MAAM,SAA4C;CAChD,QAAQ;CACR,OAAO;AACT;;;AAIA,MAAa,gBACX,SAEA,SAAS,WAAW,SAAS,WACzB,OACA,QAAQ,OACN,OACC,OAAO,SAAS;;;;;;AAqCzB,MAAa,oBACX,SAC2B;CAC3B,MAAM,uBAAO,IAAI,IAAsC;CACvD,QAAQ,aAAa;EACnB,IAAI,QAAQ,KAAK,IAAI,QAAQ;EAC7B,IAAI,UAAU,KAAA,GAAW;GACvB,QAAQ,MAAM,eACZ,OAAO,QACL,MAAM,eAAe,KAAK,QAAQ,GAAG,MAAM,WAAW,CAAC,CACzD,CACF;GACA,KAAK,IAAI,UAAU,KAAK;EAC1B;EACA,OAAO;CACT;AACF;;;;;;AAyCA,MAAa,cACX,UAKI,CAAC,MACI;CAET,MAAM,yBAAS,IAAI,IAAgC;CACnD,MAAM,SACJ,QACA,aACuC;EACvC,MAAM,MAAM,GAAG,SAAS,GAAG,OAAO;EAClC,IAAI,OAAO,OAAO,IAAI,GAAG;EACzB,IAAI,SAAS,KAAA,GAAW;GACtB,OAAO,OAAO,KAAK,MAA+B,CAAC,CAAC;GACpD,OAAO,IAAI,KAAK,IAAI;EACtB;EACA,OAAO;CACT;CACA,OAAO;EACL,SAAS;GACP;GACA,aAAa,uBAAuB,kBAAkB;GAEtD,MAAM;IAAE,GAAG,KAAK,OAAO;IAAG,MAAM,YAAY,CAAC;IAAG,QAAQ,YAAY,CAAC;GAAE;EACzE;EACA,OAAO;GACL,KAAK,QAAQ,OAAO;GACpB,QAAQ,QAAQ,UAAU,OAAO,MAAM,EAAE,QAAQ,OAAO,QAAQ,IAAI,EAAE,CAAC;GACvE,gBAAgB,YAAY,CAAC;EAC/B;EACA,WAAW;GACT,QAAQ,QAAQ,iBAAiB;GACjC,4BAA4B,CAAC;GAC7B,0BAA0B,CAAC;GAC3B,qBAAqB,QAAQ,iBAAiB;EAChD;CACF;AACF"}

package/dist/app/host/index.d.ts

@@ -0,0 +1,2 @@
+import { Backend, Host, Storage, TabMessage, TableSource, backendNamed, keptBroadcasters, memoryHost } from "./host.js";
+export { Backend, type Host, type Storage, type TabMessage, type TableSource, backendNamed, keptBroadcasters, memoryHost };

package/dist/app/host/index.js

@@ -0,0 +1,2 @@
+import { Backend, backendNamed, keptBroadcasters, memoryHost } from "./host.js";
+export { Backend, backendNamed, keptBroadcasters, memoryHost };

package/dist/app/index.d.ts

@@ -0,0 +1,4 @@
+import { GateNotice, GateView } from "./gate/domain/types.js";
+import "./gate/index.js";
+import { RootOptions, WebAppConfig, WebAuth, WebAuthApp, WebPublicApp, createApp } from "./app.js";
+export { type GateNotice, type GateView, type RootOptions, type WebAppConfig, type WebAuth, type WebAuthApp, type WebPublicApp, createApp };

package/dist/app/index.js

@@ -0,0 +1,2 @@
+import { createApp } from "./app.js";
+export { createApp };

package/dist/app/session/define.d.ts

@@ -0,0 +1,60 @@
+import { ApiClients, Apis } from "../apis/apis.js";
+import "../apis/index.js";
+import { SessionStatus } from "./status.js";
+import { StdSync } from "./open.js";
+import { useOpenedStatus } from "./react.js";
+import { Context, Effect, Schema, Scope, SubscriptionRef } from "effect";
+import { Account } from "@kestack/auth-toolkit/client";
+//#region src/app/session/define.d.ts
+/** What the Web Platform gives a Session to be built from: the app's APIs
+ * signed as the Account, the user's Std Sync, the Account, and the Session
+ * Status. */
+export interface SessionContext<A extends Apis> {
+  /** Whose Session it is. */
+  readonly account: Account;
+  /** Every API, each call signed with the Account's token. A call still on
+   * its way when the Session closes is interrupted. */
+  readonly apis: ApiClients<A>;
+  /** A Std Sync named for the user, kept where the Backend keeps it: on the
+   * device for the cloud Backend, in memory for the device Backend. Make
+   * its collections; it is disposed with the Session. */
+  readonly sync: StdSync;
+  /** Whether the Account has been confirmed since the Session opened. */
+  readonly status: SubscriptionRef.SubscriptionRef<SessionStatus>;
+}
+declare const SessionClosed_base: Schema.Class<SessionClosed, Schema.Struct<{
+  readonly _tag: Schema.tag<"SessionClosed">;
+}>, import("effect/Cause").YieldableError>;
+/** A Session was closed, by an Account Switch, a sign-out or a change of
+ * Backend, while something of it still ran. */
+export declare class SessionClosed extends SessionClosed_base {}
+/** Who is open, for Effect code: `yield* session.Service`. */
+export interface SessionOf<S> {
+  readonly '@kestack/web-platform/Session': S;
+}
+/** Runs an Effect in the open Session, with its Service provided. Rejects
+ * with its failure, or with SessionClosed if the Session closed first. */
+export type Run<S> = <X, E>(effect: Effect.Effect<X, E, SessionOf<S>>) => Promise<X>;
+/**
+ * An app's Session, written once over its APIs: what one Account keeps
+ * while it is active. Give it to `createApp` as `auth.session`; everything
+ * else comes out of it. `Service` reaches it from Effect code, and `use`,
+ * `useRun`, `useStatus` and `useApi` from any screen under `SignedIn`.
+ */
+export declare const defineSession: <A extends Apis, S>(apis: A, open: (context: SessionContext<A>) => Effect.Effect<S, never, Scope.Scope>) => {
+  apis: A;
+  open: (context: SessionContext<A>) => Effect.Effect<S, never, Scope.Scope>;
+  Service: Context.Service<SessionOf<S>, S>;
+  /** The open Session's value. */
+  use: () => S;
+  /** Runs an Effect in the open Session. */
+  useRun: () => Run<S>;
+  /** Whether the open Account has been confirmed, live. */
+  useStatus: typeof useOpenedStatus;
+  /** One API's client, signed as the open Account. */
+  useApi: <K extends keyof A & string>(name: K) => ApiClients<A>[K];
+};
+/** A Session, as `defineSession` makes it. */
+export type SessionDef<A extends Apis, S> = ReturnType<typeof defineSession<A, S>>;
+//#endregion
+//# sourceMappingURL=define.d.ts.map

package/dist/app/session/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","names":[],"sources":["../../../src/app/session/define.ts"],"mappings":";;;;;;;;;;;iBAWiB,eAAe,UAAU;;WAE/B,SAAS;;;WAGT,MAAM,WAAW;;;;WAIjB,MAAM;;WAEN,QAAQ,gBAAgB,gBAAgB;;;;;;;qBAKtC,sBAAsB;;iBAKlB,UAAU;WAChB,iCAAiC;;;;YAKhC,IAAI,MAAM,GAAG,GACvB,QAAQ,OAAO,OAAO,GAAG,GAAG,UAAU,QACnC,QAAQ;;;;;;;qBAQA,gBAAiB,UAAU,MAAM,GAAC,MACvC,GAAC,OACA,SAAS,eAAe,OAAO,OAAO,OAAO,UAAU,MAAM;;EAApD,OAAA,SAAA,eAAe,OAAO,OAAO,OAAO,UAAU,MAAM;;;EAUzD,WAAA;;EAEG,cAAA,IAAI;;;;EAIP,SAAA,gBAAgB,YAAU,MAAQ,MAAI,WAAW,GAAG;;;YAMrD,WAAW,UAAU,MAAM,KAAK,kBACnC,cAAc,GAAG"}

package/dist/app/session/define.js

@@ -0,0 +1,31 @@
+import { useOpened, useOpenedStatus } from "./react.js";
+import { Context, Schema } from "effect";
+//#region src/app/session/define.ts
+/** A Session was closed, by an Account Switch, a sign-out or a change of
+* Backend, while something of it still ran. */
+var SessionClosed = class extends Schema.Error("@kestack/web-platform/SessionClosed")({ _tag: Schema.tag("SessionClosed") }) {};
+/**
+* An app's Session, written once over its APIs: what one Account keeps
+* while it is active. Give it to `createApp` as `auth.session`; everything
+* else comes out of it. `Service` reaches it from Effect code, and `use`,
+* `useRun`, `useStatus` and `useApi` from any screen under `SignedIn`.
+*/
+const defineSession = (apis, open) => {
+	return {
+		apis,
+		open,
+		Service: Context.Service("@kestack/web-platform/Session"),
+		/** The open Session's value. */
+		use: () => useOpened().value,
+		/** Runs an Effect in the open Session. */
+		useRun: () => useOpened().run,
+		/** Whether the open Account has been confirmed, live. */
+		useStatus: useOpenedStatus,
+		/** One API's client, signed as the open Account. */
+		useApi: (name) => useOpened().apis[name]
+	};
+};
+//#endregion
+export { SessionClosed, defineSession };
+
+//# sourceMappingURL=define.js.map

package/dist/app/session/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","names":[],"sources":["../../../src/app/session/define.ts"],"sourcesContent":["import { Context, type Effect, Schema, type Scope } from 'effect';\nimport type { SubscriptionRef } from 'effect';\nimport type { Account } from '@kestack/auth-toolkit/client';\nimport type { ApiClients, Apis } from '../apis/index.ts';\nimport type { StdSync } from './open.ts';\nimport { useOpened, useOpenedStatus } from './react.tsx';\nimport type { SessionStatus } from './status.ts';\n\n/** What the Web Platform gives a Session to be built from: the app's APIs\n * signed as the Account, the user's Std Sync, the Account, and the Session\n * Status. */\nexport interface SessionContext<A extends Apis> {\n  /** Whose Session it is. */\n  readonly account: Account;\n  /** Every API, each call signed with the Account's token. A call still on\n   * its way when the Session closes is interrupted. */\n  readonly apis: ApiClients<A>;\n  /** A Std Sync named for the user, kept where the Backend keeps it: on the\n   * device for the cloud Backend, in memory for the device Backend. Make\n   * its collections; it is disposed with the Session. */\n  readonly sync: StdSync;\n  /** Whether the Account has been confirmed since the Session opened. */\n  readonly status: SubscriptionRef.SubscriptionRef<SessionStatus>;\n}\n\n/** A Session was closed, by an Account Switch, a sign-out or a change of\n * Backend, while something of it still ran. */\nexport class SessionClosed extends Schema.Error<SessionClosed>(\n  '@kestack/web-platform/SessionClosed',\n)({ _tag: Schema.tag('SessionClosed') }) {}\n\n/** Who is open, for Effect code: `yield* session.Service`. */\nexport interface SessionOf<S> {\n  readonly '@kestack/web-platform/Session': S;\n}\n\n/** Runs an Effect in the open Session, with its Service provided. Rejects\n * with its failure, or with SessionClosed if the Session closed first. */\nexport type Run<S> = <X, E>(\n  effect: Effect.Effect<X, E, SessionOf<S>>,\n) => Promise<X>;\n\n/**\n * An app's Session, written once over its APIs: what one Account keeps\n * while it is active. Give it to `createApp` as `auth.session`; everything\n * else comes out of it. `Service` reaches it from Effect code, and `use`,\n * `useRun`, `useStatus` and `useApi` from any screen under `SignedIn`.\n */\nexport const defineSession = <A extends Apis, S>(\n  apis: A,\n  open: (context: SessionContext<A>) => Effect.Effect<S, never, Scope.Scope>,\n) => {\n  const Service = Context.Service<SessionOf<S>, S>(\n    '@kestack/web-platform/Session',\n  );\n  return {\n    apis,\n    open,\n    Service,\n    /** The open Session's value. */\n    use: (): S => useOpened().value as S,\n    /** Runs an Effect in the open Session. */\n    useRun: (): Run<S> => useOpened().run as Run<S>,\n    /** Whether the open Account has been confirmed, live. */\n    useStatus: useOpenedStatus,\n    /** One API's client, signed as the open Account. */\n    useApi: <K extends keyof A & string>(name: K): ApiClients<A>[K] =>\n      useOpened().apis[name] as ApiClients<A>[K],\n  };\n};\n\n/** A Session, as `defineSession` makes it. */\nexport type SessionDef<A extends Apis, S> = ReturnType<\n  typeof defineSession<A, S>\n>;\n"],"mappings":";;;;;AA2BA,IAAa,gBAAb,cAAmC,OAAO,MACxC,qCACF,CAAC,CAAC,EAAE,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC,CAAC,CAAC,CAAC;;;;;;;AAmB1C,MAAa,iBACX,MACA,SACG;CAIH,OAAO;EACL;EACA;EACA,SANc,QAAQ,QACtB,+BAKM;;EAEN,WAAc,UAAU,CAAC,CAAC;;EAE1B,cAAsB,UAAU,CAAC,CAAC;;EAElC,WAAW;;EAEX,SAAqC,SACnC,UAAU,CAAC,CAAC,KAAK;CACrB;AACF"}

package/dist/app/session/index.d.ts

@@ -0,0 +1,6 @@
+import { SessionStatus, StatusCell, makeStatus } from "./status.js";
+import { Opened, StdSync, openSession } from "./open.js";
+import { OpenSessionProvider, useOpened, useOpenedOrNone, useOpenedStatus } from "./react.js";
+import { Run, SessionClosed, SessionContext, SessionDef, SessionOf, defineSession } from "./define.js";
+import { keepSyncs, syncName } from "./keeper.js";
+export { OpenSessionProvider, type Opened, type Run, SessionClosed, type SessionContext, type SessionDef, type SessionOf, type SessionStatus, type StatusCell, type StdSync, defineSession, keepSyncs, makeStatus, openSession, syncName, useOpened, useOpenedOrNone, useOpenedStatus };

package/dist/app/session/index.js

@@ -0,0 +1,6 @@
+import { OpenSessionProvider, useOpened, useOpenedOrNone, useOpenedStatus } from "./react.js";
+import { SessionClosed, defineSession } from "./define.js";
+import { keepSyncs, syncName } from "./keeper.js";
+import { openSession } from "./open.js";
+import { makeStatus } from "./status.js";
+export { OpenSessionProvider, SessionClosed, defineSession, keepSyncs, makeStatus, openSession, syncName, useOpened, useOpenedOrNone, useOpenedStatus };

package/dist/app/session/keeper.d.ts

@@ -0,0 +1,17 @@
+//#region src/app/session/keeper.d.ts
+/** The name of one user's Std Sync on this device, which `createApp` gives
+ * their Session, so what it keeps is deleted once they sign out. */
+export declare const syncName: (userId: string) => string;
+/**
+ * Keeps the Std Sync of every user still signed in, deletes every other
+ * user's, and says which it deleted. Only names `syncName` makes are
+ * touched; whatever else the device keeps under Std Sync is left alone.
+ */
+export declare const keepSyncs: (userIds: ReadonlyArray<string>, sync: {
+  readonly list: () => Promise<ReadonlyArray<{
+    readonly name: string;
+  }>>;
+  readonly remove: (name: string) => Promise<void>;
+}) => Promise<string[]>;
+//#endregion
+//# sourceMappingURL=keeper.d.ts.map

package/dist/app/session/keeper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keeper.d.ts","names":[],"sources":["../../../src/app/session/keeper.ts"],"mappings":";;;qBAaa,WAAQ;;;;;;qBAOR,YAAS,SACX,uBAAqB;WAEnB,YAAY,QAAQ;aAAyB;;WAC7C,SAAS,iBAAiB;MACpC"}

package/dist/app/session/keeper.js

@@ -0,0 +1,21 @@
+//#region src/app/session/keeper.ts
+const PREFIX = "user-";
+const normalize = (name) => name.normalize("NFD").replace(/\p{M}+/gu, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+/** The name of one user's Std Sync on this device, which `createApp` gives
+* their Session, so what it keeps is deleted once they sign out. */
+const syncName = (userId) => normalize(`${PREFIX}${userId}`);
+/**
+* Keeps the Std Sync of every user still signed in, deletes every other
+* user's, and says which it deleted. Only names `syncName` makes are
+* touched; whatever else the device keeps under Std Sync is left alone.
+*/
+const keepSyncs = async (userIds, sync) => {
+	const kept = new Set(userIds.map(syncName));
+	const gone = (await sync.list()).map(({ name }) => name).filter((name) => name.startsWith(PREFIX) && !kept.has(name));
+	await Promise.all(gone.map((name) => sync.remove(name)));
+	return gone;
+};
+//#endregion
+export { keepSyncs, syncName };
+
+//# sourceMappingURL=keeper.js.map

package/dist/app/session/keeper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keeper.js","names":[],"sources":["../../../src/app/session/keeper.ts"],"sourcesContent":["const PREFIX = 'user-';\n\n// Std Sync keeps a name lowercase, with a dash for anything else.\nconst normalize = (name: string) =>\n  name\n    .normalize('NFD')\n    .replace(/\\p{M}+/gu, '')\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-+|-+$/g, '');\n\n/** The name of one user's Std Sync on this device, which `createApp` gives\n * their Session, so what it keeps is deleted once they sign out. */\nexport const syncName = (userId: string) => normalize(`${PREFIX}${userId}`);\n\n/**\n * Keeps the Std Sync of every user still signed in, deletes every other\n * user's, and says which it deleted. Only names `syncName` makes are\n * touched; whatever else the device keeps under Std Sync is left alone.\n */\nexport const keepSyncs = async (\n  userIds: ReadonlyArray<string>,\n  sync: {\n    readonly list: () => Promise<ReadonlyArray<{ readonly name: string }>>;\n    readonly remove: (name: string) => Promise<void>;\n  },\n) => {\n  const kept = new Set(userIds.map(syncName));\n  const gone = (await sync.list())\n    .map(({ name }) => name)\n    .filter((name) => name.startsWith(PREFIX) && !kept.has(name));\n  await Promise.all(gone.map((name) => sync.remove(name)));\n  return gone;\n};\n"],"mappings":";AAAA,MAAM,SAAS;AAGf,MAAM,aAAa,SACjB,KACG,UAAU,KAAK,CAAC,CAChB,QAAQ,YAAY,EAAE,CAAC,CACvB,YAAY,CAAC,CACb,QAAQ,eAAe,GAAG,CAAC,CAC3B,QAAQ,YAAY,EAAE;;;AAI3B,MAAa,YAAY,WAAmB,UAAU,GAAG,SAAS,QAAQ;;;;;;AAO1E,MAAa,YAAY,OACvB,SACA,SAIG;CACH,MAAM,OAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC;CAC1C,MAAM,QAAQ,MAAM,KAAK,KAAK,EAAA,CAC3B,KAAK,EAAE,WAAW,IAAI,CAAC,CACvB,QAAQ,SAAS,KAAK,WAAW,MAAM,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC;CAC9D,MAAM,QAAQ,IAAI,KAAK,KAAK,SAAS,KAAK,OAAO,IAAI,CAAC,CAAC;CACvD,OAAO;AACT"}

package/dist/app/session/open.d.ts

@@ -0,0 +1,44 @@
+import { Apis } from "../apis/apis.js";
+import "../apis/index.js";
+import { StatusCell } from "./status.js";
+import { SessionContext } from "./define.js";
+import { Context, Effect, Layer, Scope } from "effect";
+import { Account } from "@kestack/auth-toolkit/client";
+import { EffectRuntime, SyncStore } from "@kestack/std-toolkit/sync";
+import { RpcClient } from "effect/rpc";
+//#region src/app/session/open.d.ts
+declare const makeSync: (name: string, runtime: EffectRuntime<never>, store: SyncStore) => {
+  name: string;
+  collection: <S extends import("@kestack/std-toolkit/eschema").AnyEntityESchema>(schema: S, collectionConfig?: import("@kestack/std-toolkit/sync").CollectionConfig<S, never> | undefined) => import("@kestack/std-toolkit/sync").SyncedCollection<S["Type"]>;
+  dispose: () => Promise<void>;
+};
+/** One Account's Std Sync, named for its user. */
+export type StdSync = ReturnType<typeof makeSync>;
+/** An open Session as the Web Platform holds it: the app's value, the APIs
+ * signed as the Account, how to run an Effect in it, and its status. */
+export interface Opened<S> {
+  readonly value: S;
+  readonly apis: Readonly<Record<string, unknown>>;
+  readonly run: (effect: Effect.Effect<unknown, unknown, never>) => Promise<unknown>;
+  readonly status: StatusCell;
+}
+/**
+ * Opens one Account's Session: a runtime holding every API's client, each
+ * over its own protocol and signed with `token`, the user's Std Sync on
+ * `store`, and then the app's own Session on them. Ends, in order: the
+ * app's Session, the Std Sync once its writes on their way have landed,
+ * every call still in flight (interrupted), the runtime.
+ */
+export declare const openSession: <A extends Apis, S>(options: {
+  readonly apis: A;
+  readonly protocols: { readonly [K in keyof A]: Layer.Layer<RpcClient.Protocol>; };
+  readonly store: SyncStore;
+  readonly account: Account;
+  readonly token: Effect.Effect<string>;
+  readonly status: StatusCell;
+  readonly open: (context: SessionContext<A>) => Effect.Effect<S, never, Scope.Scope>;
+  /** The Session's Service, provided to everything `run` runs. */
+  readonly service: Context.Key<unknown, S>;
+}) => Effect.Effect<Opened<S>, never, Scope.Scope>;
+//#endregion
+//# sourceMappingURL=open.d.ts.map

package/dist/app/session/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","names":[],"sources":["../../../src/app/session/open.ts"],"mappings":";;;;;;;;;cA2BM,WAAQ,cACA,SACH,sBAAoB,OACtB;;;;;;YAIG,UAAU,kBAAkB;;;iBAIvB,OAAO;WACb,OAAO;WACP,MAAM,SAAS;WACf,MACP,QAAQ,OAAO,oCACZ;WACI,QAAQ;;;;;;;;;qBAoCN,cAAe,UAAU,MAAM,GAAC;WAClC,MAAM;WACN,uBACG,WAAW,IAAI,MAAM,MAAM,UAAU;WAExC,OAAO;WACP,SAAS;WACT,OAAO,OAAO;WACd,QAAQ;WACR,OACP,SAAS,eAAe,OACrB,OAAO,OAAO,UAAU,MAAM;;WAE1B,SAAS,QAAQ,aAAa;MACrC,OAAO,OAAO,OAAO,WAAW,MAAM"}

package/dist/app/session/open.js

@@ -0,0 +1,70 @@
+import { SessionClosed } from "./define.js";
+import { syncName } from "./keeper.js";
+import { Cause, Context, Deferred, Effect, Exit, Layer, ManagedRuntime, Option, Stream } from "effect";
+import { createStdSync } from "@kestack/std-toolkit/sync";
+import { Rpc } from "@kestack/rpc-toolkit/rpc";
+import { RpcClient } from "effect/rpc";
+import { Authz } from "@kestack/auth-toolkit/guard";
+//#region src/app/session/open.ts
+const makeSync = (name, runtime, store) => createStdSync({
+	name,
+	runtime,
+	store
+});
+const droppedOn = (connection) => Option.match(connection, {
+	onNone: () => Effect.never,
+	onSome: ({ connectionStatus }) => connectionStatus.pipe(Stream.dropWhile((status) => status !== "connected"), Stream.filter((status) => status !== "connected"), Stream.runHead, Effect.asVoid)
+});
+/**
+* Opens one Account's Session: a runtime holding every API's client, each
+* over its own protocol and signed with `token`, the user's Std Sync on
+* `store`, and then the app's own Session on them. Ends, in order: the
+* app's Session, the Std Sync once its writes on their way have landed,
+* every call still in flight (interrupted), the runtime.
+*/
+const openSession = (options) => Effect.gen(function* () {
+	const { apis, account } = options;
+	const names = Object.keys(apis);
+	const keys = new Map(names.map((name) => [name, Context.Service(`@kestack/web-platform/ApiClient/${name}`)]));
+	const bearer = Authz.bearer(options.token);
+	const layers = names.map((name) => Layer.effect(keys.get(name), Effect.all({
+		client: RpcClient.make(apis[name].group),
+		connection: Effect.serviceOption(Rpc.websocket.connection)
+	})).pipe(Layer.provide([options.protocols[name], bearer])));
+	const runtime = ManagedRuntime.make(layers.length === 0 ? Layer.empty : Layer.mergeAll(...layers));
+	yield* Effect.addFinalizer(() => Effect.promise(() => runtime.dispose()));
+	const raw = yield* Effect.promise(() => runtime.runPromise(Effect.forEach(names, (name) => Effect.gen(function* () {
+		return yield* keys.get(name);
+	}))));
+	const closed = yield* Deferred.make();
+	yield* Effect.addFinalizer(() => Deferred.succeed(closed, void 0));
+	const cut = (call) => Effect.raceFirst(call, Effect.andThen(Deferred.await(closed), Effect.interrupt));
+	const signed = ({ client, connection }) => Object.fromEntries(Object.entries(client).map(([tag, call]) => [tag, typeof call !== "function" ? call : (...args) => {
+		const made = call(...args);
+		return Effect.isEffect(made) ? cut(made) : Stream.isStream(made) ? Stream.interruptWhen(made, Effect.raceFirst(Deferred.await(closed), droppedOn(connection))) : made;
+	}]));
+	const clients = Object.fromEntries(names.map((name, index) => [name, signed(raw[index])]));
+	const sync = makeSync(syncName(account.user.id), runtime, options.store);
+	yield* Effect.addFinalizer(() => Effect.tryPromise(() => sync.dispose()).pipe(Effect.catch((error) => Effect.logWarning("[sync]", error))));
+	const value = yield* options.open({
+		account,
+		apis: clients,
+		sync,
+		status: options.status.ref
+	});
+	const run = (effect) => Deferred.isDoneUnsafe(closed) ? Promise.reject(new SessionClosed()) : runtime.runPromiseExit(cut(Effect.provideService(effect, options.service, value))).then((exit) => {
+		if (Exit.isSuccess(exit)) return exit.value;
+		if (Cause.hasInterruptsOnly(exit.cause)) throw new SessionClosed();
+		throw Cause.squash(exit.cause);
+	});
+	return {
+		value,
+		apis: clients,
+		run,
+		status: options.status
+	};
+});
+//#endregion
+export { openSession };
+
+//# sourceMappingURL=open.js.map