@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/app/gate/domain/machine.js

@@ -0,0 +1,383 @@
+import { Device, Sessions, Switching } from "./services.js";
+import { check } from "./check.js";
+import { Effect, Schema, Stream } from "effect";
+import { SignIn } from "@kestack/auth-toolkit/client";
+import { fromEffect, fromEffectEventStream, setupEffect } from "@xstate/effect";
+//#region src/app/gate/domain/machine.ts
+const GateContextSchema = Schema.declare((value) => typeof value === "object" && value !== null && "accounts" in value);
+const events = {
+	/** The app or the network came back, or another tab changed something:
+	* ask who is signed in. */
+	CHECK: Schema.Struct({}),
+	/** An Account Switch to another Signed-in Account. */
+	SWITCH: Schema.Struct({ userId: Schema.String }),
+	/** Sign the Active Account out of this device. */
+	SIGN_OUT: Schema.Struct({}),
+	/** Sign every account out of this device. */
+	SIGN_OUT_EVERYONE: Schema.Struct({}),
+	/** Try again to open an account that would not open. */
+	RETRY: Schema.Struct({}),
+	/** The invoked Session is open. */
+	SESSION_OPENED: Schema.Struct({ session: Schema.Unknown })
+};
+const session = fromEffectEventStream(({ input }) => Stream.unwrap(Effect.gen(function* () {
+	const opened = yield* (yield* Sessions).open(input);
+	return Stream.concat(Stream.make({
+		type: "SESSION_OPENED",
+		session: opened
+	}), Stream.never);
+})));
+const remembered = fromEffect(() => Effect.gen(function* () {
+	return yield* (yield* Device).remembered;
+}));
+const checking = fromEffect(() => check(null));
+const tokenOf = (account) => Effect.gen(function* () {
+	if (account.token !== null) return account.token;
+	return (yield* (yield* SignIn).list).find(({ user }) => user.id === account.user.id)?.token ?? null;
+});
+const verifying = fromEffect(({ input }) => Effect.gen(function* () {
+	if (input.fresh) return null;
+	if (input.pending) {
+		const token = yield* Effect.result(tokenOf(input.account));
+		if (token._tag === "Failure") return null;
+		if (token.success !== null) {
+			const switching = yield* Switching;
+			yield* switching.switchTo(token.success);
+			yield* switching.announce();
+		}
+	}
+	return yield* check(input.account.user);
+}));
+const forgetting = fromEffect(({ input }) => Effect.gen(function* () {
+	const device = yield* Device;
+	const remembered = yield* device.remembered;
+	yield* device.remember({
+		...remembered,
+		lost: null
+	});
+	yield* (yield* Switching).announce([input.id]);
+}));
+const signingOut = fromEffect(({ input }) => Effect.gen(function* () {
+	const signIn = yield* SignIn;
+	if (input.account === null) yield* signIn.signOutAll;
+	else {
+		const token = yield* tokenOf(input.account);
+		if (token !== null) yield* signIn.signOut(token);
+	}
+	yield* (yield* Switching).announce(input.quiet);
+}));
+const RECHECK = 6e4;
+/** What a check means for the machine, from wherever it ran. */
+const settle = (checked, context) => {
+	const current = context.account;
+	const { accounts, chosen, lost } = checked;
+	const base = {
+		...context,
+		accounts,
+		session: null,
+		unreachable: false,
+		pending: false,
+		failures: 0,
+		lost
+	};
+	if (lost !== null) return {
+		target: "#gate.accountLost",
+		context: {
+			...base,
+			account: null,
+			fresh: false
+		}
+	};
+	if (chosen === null) return {
+		target: "#gate.signedOut",
+		context: {
+			...base,
+			account: null,
+			fresh: false
+		}
+	};
+	if (current !== null && chosen.user.id === current.user.id) return null;
+	return {
+		target: "#gate.open",
+		reenter: true,
+		context: {
+			...base,
+			account: chosen,
+			fresh: true
+		}
+	};
+};
+const leaving = {
+	SWITCH: ({ context, event }) => {
+		const to = context.accounts.find(({ user }) => user.id === event.userId);
+		if (to === void 0 || to.user.id === context.account?.user.id) return;
+		return {
+			target: "#gate.open",
+			reenter: true,
+			context: {
+				...context,
+				account: to,
+				session: null,
+				pending: true,
+				fresh: false,
+				failures: 0
+			}
+		};
+	},
+	SIGN_OUT: ({ context }) => ({
+		target: "#gate.signingOut",
+		context: {
+			...context,
+			session: null
+		}
+	}),
+	SIGN_OUT_EVERYONE: ({ context }) => ({
+		target: "#gate.signingOut",
+		context: {
+			...context,
+			account: null,
+			session: null
+		}
+	})
+};
+const initialContext = () => ({
+	accounts: [],
+	account: null,
+	session: null,
+	unreachable: false,
+	pending: false,
+	fresh: false,
+	failures: 0,
+	lost: null
+});
+/**
+* The Gate's lifecycle on one Backend. An account the device remembers opens
+* first and is confirmed behind it (Open First); with nobody remembered it
+* finds who is signed in. It holds the Active Account's Session
+* open until an Account Switch, a sign-out, or the account turning out to
+* be signed out (Account Lost). Leaving `open` ends the Session, so
+* nothing of one account outlives its state.
+*/
+const gateMachine = setupEffect({
+	schemas: {
+		context: GateContextSchema,
+		events
+	},
+	actors: {
+		session,
+		remembered,
+		checking,
+		verifying,
+		signingOut,
+		forgetting
+	}
+}).createMachine({
+	id: "gate",
+	context: initialContext,
+	initial: "starting",
+	states: {
+		starting: { invoke: {
+			src: "remembered",
+			onDone: ({ context, event }) => {
+				const { accounts, lost } = event.output;
+				if (lost !== null) return {
+					target: "accountLost",
+					context: {
+						...context,
+						accounts,
+						lost
+					}
+				};
+				const account = accounts.find(({ active }) => active) ?? accounts[0] ?? null;
+				if (account === null) return { target: "checking" };
+				return {
+					target: "open",
+					context: {
+						...context,
+						accounts,
+						account
+					}
+				};
+			},
+			onError: { target: "checking" }
+		} },
+		checking: { invoke: {
+			src: "checking",
+			onDone: ({ context, event }) => settle(event.output, context) ?? void 0,
+			onError: ({ context }) => ({
+				target: "signedOut",
+				context: {
+					...context,
+					unreachable: true
+				}
+			})
+		} },
+		signedOut: { on: { CHECK: { target: "checking" } } },
+		signingOut: { invoke: {
+			src: "signingOut",
+			input: ({ context }) => context.account === null ? {
+				account: null,
+				quiet: context.accounts.map(({ user }) => user.id)
+			} : {
+				account: context.account,
+				quiet: [context.account.user.id]
+			},
+			onDone: ({ context }) => ({
+				target: "checking",
+				context: {
+					...context,
+					account: null
+				}
+			}),
+			onError: { target: "checking" }
+		} },
+		accountLost: {
+			initial: "verifying",
+			on: {
+				SWITCH: ({ context, event }) => {
+					const to = context.accounts.find(({ user }) => user.id === event.userId);
+					if (to === void 0) return;
+					return {
+						target: "forgetting",
+						context: {
+							...context,
+							account: to,
+							pending: true,
+							fresh: false
+						}
+					};
+				},
+				SIGN_OUT: ({ context }) => ({
+					target: "forgetting",
+					context: {
+						...context,
+						account: null
+					}
+				})
+			},
+			states: {
+				idle: { on: { CHECK: { target: "verifying" } } },
+				verifying: { invoke: {
+					src: "checking",
+					onDone: ({ context, event }) => {
+						const checked = event.output;
+						if (checked.lost !== null) return {
+							target: "idle",
+							context: {
+								...context,
+								accounts: checked.accounts
+							}
+						};
+						return settle(checked, context) ?? { target: "idle" };
+					},
+					onError: { target: "idle" }
+				} }
+			}
+		},
+		forgetting: { invoke: {
+			src: "forgetting",
+			input: ({ context }) => context.lost,
+			onDone: ({ context }) => ({
+				target: context.account === null ? "checking" : "open",
+				context: {
+					...context,
+					lost: null
+				}
+			}),
+			onError: ({ context }) => ({
+				target: context.account === null ? "checking" : "open",
+				context: {
+					...context,
+					lost: null
+				}
+			})
+		} },
+		unopenable: { on: {
+			RETRY: ({ context }) => ({
+				target: "open",
+				context: {
+					...context,
+					failures: 0
+				}
+			}),
+			SIGN_OUT: { target: "signingOut" }
+		} },
+		open: {
+			invoke: {
+				src: "session",
+				input: ({ context }) => context.account,
+				onError: ({ context }) => context.failures + 1 >= 2 ? {
+					target: "unopenable",
+					context: {
+						...context,
+						session: null,
+						failures: 0
+					}
+				} : {
+					target: "#gate.open",
+					reenter: true,
+					context: {
+						...context,
+						session: null,
+						failures: context.failures + 1
+					}
+				}
+			},
+			on: leaving,
+			initial: "opening",
+			states: {
+				opening: { on: { SESSION_OPENED: ({ context, event }) => ({
+					target: "ready",
+					context: {
+						...context,
+						session: event.session
+					}
+				}) } },
+				ready: {
+					initial: "verifying",
+					states: {
+						idle: {
+							after: { [RECHECK]: { target: "verifying" } },
+							on: { CHECK: { target: "verifying" } }
+						},
+						verifying: { invoke: {
+							src: "verifying",
+							input: ({ context }) => ({
+								account: context.account,
+								pending: context.pending,
+								fresh: context.fresh
+							}),
+							onDone: ({ context, event }) => {
+								const checked = event.output;
+								if (checked === null || !checked.answered) return {
+									target: "idle",
+									context: {
+										...context,
+										fresh: false
+									}
+								};
+								const moved = settle(checked, context);
+								if (moved !== null) return moved;
+								return {
+									target: "idle",
+									context: {
+										...context,
+										fresh: false,
+										pending: false,
+										accounts: checked.accounts,
+										account: checked.chosen
+									}
+								};
+							},
+							onError: { target: "idle" }
+						} }
+					}
+				}
+			}
+		}
+	}
+});
+//#endregion
+export { gateMachine };
+
+//# sourceMappingURL=machine.js.map

package/dist/app/gate/domain/machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.js","names":[],"sources":["../../../../src/app/gate/domain/machine.ts"],"sourcesContent":["import { Effect, Schema, Stream } from 'effect';\nimport { fromEffect, fromEffectEventStream, setupEffect } from '@xstate/effect';\nimport { SignIn } from '@kestack/auth-toolkit/client';\nimport { type Checked, check } from './check.ts';\nimport { Device, type Remembered, Sessions, Switching } from './services.ts';\nimport type { Held, User } from './types.ts';\n\n/** Everything the Gate knows about who is signed in, and the open Session. */\nexport type GateContext = {\n  /** Every Signed-in Account on this device. */\n  readonly accounts: ReadonlyArray<Held>;\n  /** Whose Session is open, or opening. */\n  readonly account: Held | null;\n  /** What the open Session gave, from when it is ready until it\n   * ends. */\n  readonly session: unknown;\n  /** Whether the last check failed with nobody to open without it. */\n  readonly unreachable: boolean;\n  /** Whether the browser-wide Account Switch to `account` is still owed. */\n  readonly pending: boolean;\n  /** Whether `accounts` were just checked, so the open needs no check. */\n  readonly fresh: boolean;\n  /** How many times in a row `account` failed to open. */\n  readonly failures: number;\n  /** The account found lost, until the User signs in to it again or opens\n   * another. */\n  readonly lost: User | null;\n};\n\n// The context holds a live Session, so it is typed, not parsed.\nconst GateContextSchema = Schema.declare(\n  (value: unknown): value is GateContext =>\n    typeof value === 'object' && value !== null && 'accounts' in value,\n);\n\nconst events = {\n  /** The app or the network came back, or another tab changed something:\n   * ask who is signed in. */\n  CHECK: Schema.Struct({}),\n  /** An Account Switch to another Signed-in Account. */\n  SWITCH: Schema.Struct({ userId: Schema.String }),\n  /** Sign the Active Account out of this device. */\n  SIGN_OUT: Schema.Struct({}),\n  /** Sign every account out of this device. */\n  SIGN_OUT_EVERYONE: Schema.Struct({}),\n  /** Try again to open an account that would not open. */\n  RETRY: Schema.Struct({}),\n  /** The invoked Session is open. */\n  SESSION_OPENED: Schema.Struct({ session: Schema.Unknown }),\n};\n\n// Holds one account's Session while the machine stays in the state\n// that invokes it: opened on entry, announced with SESSION_OPENED, ended on\n// exit.\nconst session = fromEffectEventStream(({ input }: { input: Held }) =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const opened = yield* (yield* Sessions).open(input);\n      return Stream.concat(\n        Stream.make({ type: 'SESSION_OPENED' as const, session: opened }),\n        Stream.never,\n      );\n    }),\n  ),\n);\n\nconst remembered = fromEffect(() =>\n  Effect.gen(function* () {\n    return yield* (yield* Device).remembered;\n  }),\n);\n\n// Asks who is signed in, nobody being open.\nconst checking = fromEffect(() => check(null));\n\ntype Verify = {\n  readonly account: Held;\n  readonly pending: boolean;\n  readonly fresh: boolean;\n};\n\n// The token of a Remembered Account, which holds none until the Backend\n// answers: asked of the Backend, null once it no longer names the account.\nconst tokenOf = (account: Held) =>\n  Effect.gen(function* () {\n    if (account.token !== null) return account.token;\n    const accounts = yield* (yield* SignIn).list;\n    return (\n      accounts.find(({ user }) => user.id === account.user.id)?.token ?? null\n    );\n  });\n\n// Confirms the open account behind the screen: first the Account Switch\n// still owed, then who is signed in. Null when the accounts were just\n// checked, or when the switch is still owed and the Backend is out of\n// reach, so no answer from before the switch can undo it.\nconst verifying = fromEffect(({ input }: { input: Verify }) =>\n  Effect.gen(function* () {\n    if (input.fresh) return null;\n    if (input.pending) {\n      const token = yield* Effect.result(tokenOf(input.account));\n      if (token._tag === 'Failure') return null;\n      if (token.success !== null) {\n        const switching = yield* Switching;\n        yield* switching.switchTo(token.success);\n        yield* switching.announce();\n      }\n    }\n    return yield* check(input.account.user);\n  }),\n);\n\n// Forgets the lost account, so the check after it deletes its Copy, and\n// tells the other tabs it is no Account Lost there.\nconst forgetting = fromEffect(({ input }: { input: User }) =>\n  Effect.gen(function* () {\n    const device = yield* Device;\n    const remembered = yield* device.remembered;\n    yield* device.remember({ ...remembered, lost: null });\n    yield* (yield* Switching).announce([input.id]);\n  }),\n);\n\ntype SignOut = {\n  readonly account: Held | null;\n  readonly quiet: ReadonlyArray<string>;\n};\n\n// Signs one account out, or every account given none; an account still\n// only remembered is signed out by the token the Backend names it with. The\n// check after it deletes what the device kept for them and opens whoever is\n// left.\nconst signingOut = fromEffect(({ input }: { input: SignOut }) =>\n  Effect.gen(function* () {\n    const signIn = yield* SignIn;\n    if (input.account === null) yield* signIn.signOutAll;\n    else {\n      const token = yield* tokenOf(input.account);\n      if (token !== null) yield* signIn.signOut(token);\n    }\n    yield* (yield* Switching).announce(input.quiet);\n  }),\n);\n\n// How often an open account is confirmed, besides when asked.\nconst RECHECK = 60_000;\n\n/** What a check means for the machine, from wherever it ran. */\nconst settle = (checked: Checked, context: GateContext) => {\n  const current = context.account;\n  const { accounts, chosen, lost } = checked;\n  const base = {\n    ...context,\n    accounts,\n    session: null,\n    unreachable: false,\n    pending: false,\n    failures: 0,\n    lost,\n  };\n  if (lost !== null) {\n    return {\n      target: '#gate.accountLost',\n      context: { ...base, account: null, fresh: false },\n    };\n  }\n  if (chosen === null) {\n    return {\n      target: '#gate.signedOut',\n      context: { ...base, account: null, fresh: false },\n    };\n  }\n  if (current !== null && chosen.user.id === current.user.id) return null;\n  return {\n    target: '#gate.open',\n    reenter: true,\n    context: { ...base, account: chosen, fresh: true },\n  };\n};\n\n// Leaving the open account: another account, or nobody.\ntype Leave = { readonly context: GateContext };\n\nconst leaving = {\n  SWITCH: ({\n    context,\n    event,\n  }: Leave & { readonly event: { readonly userId: string } }) => {\n    const to = context.accounts.find(({ user }) => user.id === event.userId);\n    if (to === undefined || to.user.id === context.account?.user.id) return;\n    return {\n      target: '#gate.open',\n      reenter: true,\n      context: {\n        ...context,\n        account: to,\n        session: null,\n        pending: true,\n        fresh: false,\n        failures: 0,\n      },\n    };\n  },\n  SIGN_OUT: ({ context }: Leave) => ({\n    target: '#gate.signingOut',\n    context: { ...context, session: null },\n  }),\n  SIGN_OUT_EVERYONE: ({ context }: Leave) => ({\n    target: '#gate.signingOut',\n    context: { ...context, account: null, session: null },\n  }),\n};\n\nconst initialContext = (): GateContext => ({\n  accounts: [],\n  account: null,\n  session: null,\n  unreachable: false,\n  pending: false,\n  fresh: false,\n  failures: 0,\n  lost: null,\n});\n\n/**\n * The Gate's lifecycle on one Backend. An account the device remembers opens\n * first and is confirmed behind it (Open First); with nobody remembered it\n * finds who is signed in. It holds the Active Account's Session\n * open until an Account Switch, a sign-out, or the account turning out to\n * be signed out (Account Lost). Leaving `open` ends the Session, so\n * nothing of one account outlives its state.\n */\nexport const gateMachine = setupEffect({\n  schemas: { context: GateContextSchema, events },\n  actors: {\n    session,\n    remembered,\n    checking,\n    verifying,\n    signingOut,\n    forgetting,\n  },\n}).createMachine({\n  id: 'gate',\n  context: initialContext,\n  initial: 'starting',\n  states: {\n    starting: {\n      invoke: {\n        src: 'remembered',\n        onDone: ({ context, event }) => {\n          const { accounts, lost } = event.output as Remembered;\n          if (lost !== null)\n            return {\n              target: 'accountLost',\n              context: { ...context, accounts, lost },\n            };\n          const account =\n            accounts.find(({ active }) => active) ?? accounts[0] ?? null;\n          if (account === null) return { target: 'checking' };\n          return { target: 'open', context: { ...context, accounts, account } };\n        },\n        onError: { target: 'checking' },\n      },\n    },\n    checking: {\n      invoke: {\n        src: 'checking',\n        onDone: ({ context, event }) =>\n          settle(event.output as Checked, context) ?? undefined,\n        onError: ({ context }) => ({\n          target: 'signedOut',\n          context: { ...context, unreachable: true },\n        }),\n      },\n    },\n    signedOut: {\n      on: { CHECK: { target: 'checking' } },\n    },\n    signingOut: {\n      invoke: {\n        src: 'signingOut',\n        input: ({ context }): SignOut =>\n          context.account === null\n            ? {\n                account: null,\n                quiet: context.accounts.map(({ user }) => user.id),\n              }\n            : {\n                account: context.account,\n                quiet: [context.account.user.id],\n              },\n        onDone: ({ context }) => ({\n          target: 'checking',\n          context: { ...context, account: null },\n        }),\n        onError: { target: 'checking' },\n      },\n    },\n    accountLost: {\n      initial: 'verifying',\n      on: {\n        SWITCH: ({ context, event }) => {\n          const to = context.accounts.find(\n            ({ user }) => user.id === event.userId,\n          );\n          if (to === undefined) return;\n          return {\n            target: 'forgetting',\n            context: { ...context, account: to, pending: true, fresh: false },\n          };\n        },\n        // Nobody is left to switch to: forget the lost account.\n        SIGN_OUT: ({ context }) => ({\n          target: 'forgetting',\n          context: { ...context, account: null },\n        }),\n      },\n      states: {\n        idle: { on: { CHECK: { target: 'verifying' } } },\n        // Whether the User signed in to the lost account again, or someone\n        // new signed in.\n        verifying: {\n          invoke: {\n            src: 'checking',\n            onDone: ({ context, event }) => {\n              const checked = event.output as Checked;\n              if (checked.lost !== null)\n                return {\n                  target: 'idle',\n                  context: { ...context, accounts: checked.accounts },\n                };\n              return settle(checked, context) ?? { target: 'idle' };\n            },\n            onError: { target: 'idle' },\n          },\n        },\n      },\n    },\n    forgetting: {\n      invoke: {\n        src: 'forgetting',\n        input: ({ context }) => context.lost as User,\n        onDone: ({ context }) => ({\n          target: context.account === null ? 'checking' : 'open',\n          context: { ...context, lost: null },\n        }),\n        onError: ({ context }) => ({\n          target: context.account === null ? 'checking' : 'open',\n          context: { ...context, lost: null },\n        }),\n      },\n    },\n    unopenable: {\n      on: {\n        RETRY: ({ context }) => ({\n          target: 'open',\n          context: { ...context, failures: 0 },\n        }),\n        SIGN_OUT: { target: 'signingOut' },\n      },\n    },\n    open: {\n      invoke: {\n        src: 'session',\n        input: ({ context }) => context.account as Held,\n        onError: ({ context }) =>\n          context.failures + 1 >= 2\n            ? {\n                target: 'unopenable',\n                context: { ...context, session: null, failures: 0 },\n              }\n            : {\n                target: '#gate.open',\n                reenter: true,\n                context: {\n                  ...context,\n                  session: null,\n                  failures: context.failures + 1,\n                },\n              },\n      },\n      on: leaving,\n      initial: 'opening',\n      states: {\n        opening: {\n          on: {\n            SESSION_OPENED: ({ context, event }) => ({\n              target: 'ready',\n              context: { ...context, session: event.session },\n            }),\n          },\n        },\n        ready: {\n          initial: 'verifying',\n          states: {\n            idle: {\n              after: { [RECHECK]: { target: 'verifying' } },\n              on: { CHECK: { target: 'verifying' } },\n            },\n            verifying: {\n              invoke: {\n                src: 'verifying',\n                input: ({ context }): Verify => ({\n                  account: context.account as Held,\n                  pending: context.pending,\n                  fresh: context.fresh,\n                }),\n                onDone: ({ context, event }) => {\n                  const checked = event.output as Checked | null;\n                  // Just checked, or the Backend was not reached: nothing\n                  // new.\n                  if (checked === null || !checked.answered)\n                    return {\n                      target: 'idle',\n                      context: { ...context, fresh: false },\n                    };\n                  const moved = settle(checked, context);\n                  if (moved !== null) return moved;\n                  return {\n                    target: 'idle',\n                    context: {\n                      ...context,\n                      fresh: false,\n                      pending: false,\n                      accounts: checked.accounts,\n                      account: checked.chosen,\n                    },\n                  };\n                },\n                onError: { target: 'idle' },\n              },\n            },\n          },\n        },\n      },\n    },\n  },\n});\n"],"mappings":"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"}

package/dist/app/gate/domain/services.d.ts

@@ -0,0 +1,37 @@
+import { Held, User } from "./types.js";
+import { Context, Effect, Scope } from "effect";
+//#region src/app/gate/domain/services.d.ts
+/** What the device remembers about one Backend: its Remembered Accounts,
+ * with no tokens, and the account found lost, if one is. */
+export type Remembered = {
+  readonly accounts: ReadonlyArray<Held>;
+  readonly lost: User | null;
+};
+declare const Device_base: Context.ServiceClass<Device, "@kestack/auth-toolkit/gate/Device", {
+  readonly remembered: Effect.Effect<Remembered>;
+  readonly remember: (remembered: Remembered) => Effect.Effect<void>;
+  /** Whether this device signed `userId` out itself, in this tab or
+   * another; asking forgets it. */
+  readonly signedOutHere: (userId: string) => Effect.Effect<boolean>;
+  /** Keeps what the device holds for these accounts and deletes the
+   * rest. */
+  readonly keep: (userIds: ReadonlyArray<string>) => Effect.Effect<void>;
+}>;
+/** What this device keeps for one Backend. */
+export declare class Device extends Device_base {}
+declare const Sessions_base: Context.ServiceClass<Sessions, "@kestack/auth-toolkit/gate/Sessions", {
+  readonly open: (account: Held) => Effect.Effect<unknown, never, Scope.Scope>;
+}>;
+/** Opens Sessions; each ends with its scope. */
+export declare class Sessions extends Sessions_base {}
+declare const Switching_base: Context.ServiceClass<Switching, "@kestack/auth-toolkit/gate/Switching", {
+  readonly switchTo: (token: string) => Effect.Effect<void, unknown>;
+  /** Tells the other tabs to look again; `quiet` are accounts this tab
+   * signed out, so they are not reported lost there. */
+  readonly announce: (quiet?: ReadonlyArray<string>) => Effect.Effect<void>;
+}>;
+/** The browser-wide Account Switch, one at a time, the last one asked for
+ * winning; and telling the device's other tabs what changed. */
+export declare class Switching extends Switching_base {}
+//#endregion
+//# sourceMappingURL=services.d.ts.map

package/dist/app/gate/domain/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","names":[],"sources":["../../../../src/app/gate/domain/services.ts"],"mappings":";;;;;YAKY;WACD,UAAU,cAAc;WACxB,MAAM;;;WAOQ,YAAA,OAAO,OAAO;WAChB,WAAC,YAAY,eAAe,OAAO;;;WAG9B,gBAAC,mBAAmB,OAAO;;;WAGpC,OAAC,SAAS,0BAA0B,OAAO;;;qBAVjD,eAAe;;WAkBT,OACb,SAAS,SACN,OAAO,uBAAuB,MAAM;;;qBALhC,iBAAiB;;WAcP,WAAC,kBAAkB,OAAO;;;WAG1B,WAAC,QAAQ,0BAA0B,OAAO;;;;qBANpD,kBAAkB"}

package/dist/app/gate/domain/services.js

@@ -0,0 +1,13 @@
+import { Context } from "effect";
+//#region src/app/gate/domain/services.ts
+/** What this device keeps for one Backend. */
+var Device = class extends Context.Service()("@kestack/auth-toolkit/gate/Device") {};
+/** Opens Sessions; each ends with its scope. */
+var Sessions = class extends Context.Service()("@kestack/auth-toolkit/gate/Sessions") {};
+/** The browser-wide Account Switch, one at a time, the last one asked for
+* winning; and telling the device's other tabs what changed. */
+var Switching = class extends Context.Service()("@kestack/auth-toolkit/gate/Switching") {};
+//#endregion
+export { Device, Sessions, Switching };
+
+//# sourceMappingURL=services.js.map

package/dist/app/gate/domain/services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.js","names":[],"sources":["../../../../src/app/gate/domain/services.ts"],"sourcesContent":["import { Context, type Effect, type Scope } from 'effect';\nimport type { Held, User } from './types.ts';\n\n/** What the device remembers about one Backend: its Remembered Accounts,\n * with no tokens, and the account found lost, if one is. */\nexport type Remembered = {\n  readonly accounts: ReadonlyArray<Held>;\n  readonly lost: User | null;\n};\n\n/** What this device keeps for one Backend. */\nexport class Device extends Context.Service<\n  Device,\n  {\n    readonly remembered: Effect.Effect<Remembered>;\n    readonly remember: (remembered: Remembered) => Effect.Effect<void>;\n    /** Whether this device signed `userId` out itself, in this tab or\n     * another; asking forgets it. */\n    readonly signedOutHere: (userId: string) => Effect.Effect<boolean>;\n    /** Keeps what the device holds for these accounts and deletes the\n     * rest. */\n    readonly keep: (userIds: ReadonlyArray<string>) => Effect.Effect<void>;\n  }\n>()('@kestack/auth-toolkit/gate/Device') {}\n\n/** Opens Sessions; each ends with its scope. */\nexport class Sessions extends Context.Service<\n  Sessions,\n  {\n    readonly open: (\n      account: Held,\n    ) => Effect.Effect<unknown, never, Scope.Scope>;\n  }\n>()('@kestack/auth-toolkit/gate/Sessions') {}\n\n/** The browser-wide Account Switch, one at a time, the last one asked for\n * winning; and telling the device's other tabs what changed. */\nexport class Switching extends Context.Service<\n  Switching,\n  {\n    readonly switchTo: (token: string) => Effect.Effect<void, unknown>;\n    /** Tells the other tabs to look again; `quiet` are accounts this tab\n     * signed out, so they are not reported lost there. */\n    readonly announce: (quiet?: ReadonlyArray<string>) => Effect.Effect<void>;\n  }\n>()('@kestack/auth-toolkit/gate/Switching') {}\n"],"mappings":";;;AAWA,IAAa,SAAb,cAA4B,QAAQ,QAYlC,CAAC,CAAC,mCAAmC,CAAC,CAAC,CAAC;;AAG1C,IAAa,WAAb,cAA8B,QAAQ,QAOpC,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC;;;AAI5C,IAAa,YAAb,cAA+B,QAAQ,QAQrC,CAAC,CAAC,sCAAsC,CAAC,CAAC,CAAC"}

package/dist/app/gate/domain/types.d.ts

@@ -0,0 +1,44 @@
+import { Account, LoginError, User } from "@kestack/auth-toolkit/client";
+//#region src/app/gate/domain/types.d.ts
+/** An Account as the Gate holds it, marked active or not. Its token is null
+ * while it is only remembered, as when it opened before the Backend
+ * answered. */
+export type Held = Account & {
+  readonly active: boolean;
+};
+/** What every screen asks the Gate. */
+export type GateView<S> = {
+  readonly kind: 'checking';
+} | {
+  readonly kind: 'signedOut';
+  readonly unreachable: boolean;
+} | {
+  readonly kind: 'opening';
+  readonly account: Account;
+} | {
+  readonly kind: 'signingOut';
+} | {
+  readonly kind: 'open';
+  readonly session: S;
+  readonly account: Account;
+  readonly accounts: ReadonlyArray<Account>;
+} | {
+  readonly kind: 'unopenable';
+  readonly account: Account;
+} |
+/** The account that was open is signed out on another device or app. The
+ * User signs in to it again, keeping its Sync, or opens another account,
+ * deleting it; `accounts` are those still signed in. */
+{
+  readonly kind: 'accountLost';
+  readonly account: Account;
+  readonly accounts: ReadonlyArray<Account>;
+};
+/** A message the Gate leaves for the app once. */
+export type GateNotice = {
+  readonly kind: 'loginError';
+  readonly error: LoginError;
+};
+//#endregion
+export type { User };
+//# sourceMappingURL=types.d.ts.map

package/dist/app/gate/domain/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/app/gate/domain/types.ts"],"mappings":";;;;;YAKY,OAAO;WAAqB;;;YAG5B,SAAS;WACN;;WACA;WAA4B;;WAC5B;WAA0B,SAAS;;WACnC;;WAEA;WACA,SAAS;WACT,SAAS;WACT,UAAU,cAAc;;WAExB;WAA6B,SAAS;;;;;;WAKtC;WACA,SAAS;WACT,UAAU,cAAc;;;YAI3B;WACD;WACA,OAAO"}

package/dist/app/gate/gate.d.ts

@@ -0,0 +1,86 @@
+import { Backend, Host } from "../host/host.js";
+import "../host/index.js";
+import { StatusCell } from "../session/status.js";
+import "../session/index.js";
+import { GateNotice, GateView } from "./domain/types.js";
+import "./domain/index.js";
+import { Effect, Layer, Scope } from "effect";
+import { Account, NamedChoice, SignIn } from "@kestack/auth-toolkit/client";
+//#region src/app/gate/gate.d.ts
+/** What an app gives the Gate. `B` is what the app keeps for as long as it
+ * runs on one Backend; `S` is what one Account's Session opens to. */
+export interface GateConfig<S, B> {
+  /** The Host, made the first time the Gate is asked anything, so the Gate
+   * can be made where the Host is not there yet, as on a server. The Gate
+   * keeps what it remembers in its own `gate` database there. */
+  readonly host: () => Host;
+  /** What runs while the app is on the cloud Backend: its Sign-in and
+   * whatever else the app keeps there. */
+  readonly cloud: () => Layer.Layer<SignIn | B>;
+  /** The same for the device Backend, loaded the first time it is chosen.
+   * `choose` asks who signs in; the Named Sign-In answers it. Without it,
+   * the app has only the cloud Backend. */
+  readonly device?: (choose: Effect.Effect<NamedChoice | null>) => Promise<Layer.Layer<SignIn | B>>;
+  /** Opens one Account's Session, with what runs on the Backend; everything
+   * it acquires ends with the scope. `token` is the Account's token at each
+   * call, waited for while the Gate holds none, as when the Account opened
+   * before the Backend answered. `status` says whether it has been
+   * confirmed since; the Gate keeps it. */
+  readonly session: (account: Account, token: Effect.Effect<string>, status: StatusCell) => Effect.Effect<S, never, Scope.Scope | B>;
+  /** Deletes what the device keeps for every account but these. */
+  readonly keep?: (userIds: ReadonlyArray<string>) => Effect.Effect<void, never, B>;
+}
+/**
+ * The Gate: runs sign-in on one device for one app. It keeps the app on the
+ * Backend chosen, and the active Account's Session open while that Account
+ * stays active. Nothing runs until something first asks. Make one per app.
+ */
+export declare const createGate: <S, B>(config: GateConfig<S, B>) => {
+  subscribe: (changed: () => void) => () => undefined;
+  /** What every screen shows: checking until the Gate runs, and while the
+   * Backend changes. */
+  view: () => GateView<S>;
+  /** The Backend running; null until it has started. */
+  backend: () => Backend | null;
+  /** Whether the device is online. */
+  online: () => boolean;
+  onOnlineChange: (changed: () => void) => () => void;
+  canSignOut: () => boolean;
+  /** Chooses `backend` and runs on it at once. Each Backend keeps its own
+   * Signed-in Accounts. */
+  setBackend: (asked: Backend) => Promise<void>;
+  /** An Account Switch: the account opens at once from what the device
+   * keeps; the Backend hears of it behind. From an Account Lost, the lost
+   * account's Copy is deleted. */
+  switchTo: (userId: string) => void | undefined;
+  /** Signs one more account in, who becomes the Active Account. On the
+   * cloud Backend the page leaves for the sign-in service; on the device
+   * Backend the Named Sign-In asks who. */
+  addAccount: () => Promise<void>;
+  /** Signs the Active Account out of this device; whoever is left opens.
+   * From an Account Lost, forgets the lost account and deletes its Copy.
+   * False, and nothing happens, when the Backend can't be reached. */
+  signOut: () => boolean;
+  /** Signs every account out of this device. False, and nothing happens,
+   * when the Backend can't be reached. */
+  signOutEveryone: () => boolean;
+  /** Asks the Backend again who is signed in. */
+  checkAgain: () => void | undefined;
+  /** Tries again to open an account that would not open. */
+  retry: () => void | undefined;
+  /** The oldest Gate Notice not yet taken, once; null when none. */
+  takeNotice: () => GateNotice | null;
+  /** The oldest Gate Notice not yet taken, without taking it. */
+  notice: () => GateNotice | null;
+  /** Whether the device Backend is asking who signs in, and how to answer:
+   * a choice, or null to sign nobody in. */
+  namedSignIn: {
+    subscribe: (listener: () => void) => () => undefined;
+    isAsking: () => boolean;
+    answer: (choice: NamedChoice | null) => void;
+  };
+};
+/** A Gate, as `createGate` makes it. */
+export type Gate<S> = ReturnType<typeof createGate<S, never>>;
+//#endregion
+//# sourceMappingURL=gate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","names":[],"sources":["../../../src/app/gate/gate.ts"],"mappings":";;;;;;;;;;;iBAyBiB,WAAW,GAAG;;;;WAIpB,YAAY;;;WAGZ,aAAa,MAAM,MAAM,SAAS;;;;WAIlC,UACP,QAAQ,OAAO,OAAO,wBACnB,QAAQ,MAAM,MAAM,SAAS;;;;;;WAMzB,UACP,SAAS,SACT,OAAO,OAAO,gBACd,QAAQ,eACL,OAAO,OAAO,UAAU,MAAM,QAAQ;;WAElC,QACP,SAAS,0BACN,OAAO,oBAAoB;;;;;;;qBA8DrB,aAAc,GAAG,GAAC,QAAU,WAAW,GAAG;EAwRzB,YAAA;;;EAgBhB,YAAA,SAAS;;EAEN,eAAA;;;EAGa,iBAAA;;;;EAMA,aAAA,OAAA,YAAO;;;;EAUd,WAAA;;;;;;;;EAwBN;;;EAaQ;;;;;;EAaL,kBAAA;;EAMJ,cAAA;;;;IAKV,YAAS;IACT;IACA,SAAM,QAAW;;;;YAMX,KAAK,KAAK,kBAAkB,WAAW"}