@yielded/auth 0.1.0-beta.1

package/dist/Workflows.mjs

@@ -0,0 +1,11 @@
+import { AuthSession } from "./AuthSession.mjs";
+import { EmailOtp } from "./EmailOtp.mjs";
+import { PasswordAuth } from "./PasswordAuth.mjs";
+import { Layer } from "effect";
+//#region src/Workflows.ts
+/** The three core auth workflows, retaining their adapter requirements. */
+const layerAuthWorkflows = Layer.mergeAll(EmailOtp.layer, AuthSession.layer, PasswordAuth.layer);
+//#endregion
+export { layerAuthWorkflows };
+
+//# sourceMappingURL=Workflows.mjs.map

package/dist/Workflows.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Workflows.mjs","names":[],"sources":["../src/Workflows.ts"],"sourcesContent":["import { Layer } from \"effect\";\n\nimport { AuthSession } from \"./AuthSession\";\nimport { EmailOtp } from \"./EmailOtp\";\nimport { PasswordAuth } from \"./PasswordAuth\";\n\n/** The three core auth workflows, retaining their adapter requirements. */\nexport const layerAuthWorkflows = Layer.mergeAll(\n  EmailOtp.layer,\n  AuthSession.layer,\n  PasswordAuth.layer,\n);\n"],"mappings":";;;;;;AAOA,MAAa,qBAAqB,MAAM,SACtC,SAAS,OACT,YAAY,OACZ,aAAa,KACf"}

package/dist/atom/AuthAtomLifetime.d.mts

@@ -0,0 +1,35 @@
+import { OperationAuthenticationCompletion, OperationFetchClient } from "../http-operation/client.mjs";
+import { Context, Effect, Scope } from "effect";
+import { Atom, AtomRegistry } from "effect/unstable/reactivity";
+//#region src/atom/AuthAtomLifetime.d.ts
+interface AuthSubjectLifetime {
+  readonly subject: string | null;
+  readonly generation: number;
+  readonly registry: AtomRegistry.AtomRegistry;
+}
+declare const AuthAtomLifetime_base: Context.ServiceClass<AuthAtomLifetime, "effect-auth/AuthAtomLifetime", {
+  readonly client: OperationFetchClient;
+  readonly current: Atom.Atom<AuthSubjectLifetime>;
+  readonly get: Effect.Effect<AuthSubjectLifetime>;
+  readonly controlRegistry: AtomRegistry.AtomRegistry;
+  readonly replaceSubject: (subject: string | null) => Effect.Effect<void>;
+  readonly completeAuthentication: OperationAuthenticationCompletion;
+}>;
+declare class AuthAtomLifetime extends AuthAtomLifetime_base {}
+/** A dedicated registry is disposed before the next subject is published. Mount
+ * only `current` in `controlRegistry`. All operation atoms, including auth
+ * mutations and device workflows, belong to the current subject registry. Acquire
+ * this lifetime in the host scope, then provide its value to the Atom runtime. */
+declare const makeLifetime: (client: OperationFetchClient, options?: {
+  readonly initialSubject?: string | null;
+} | undefined) => Effect.Effect<{
+  client: OperationFetchClient;
+  current: Atom.Atom<AuthSubjectLifetime>;
+  get: Effect.Effect<AuthSubjectLifetime, never, never>;
+  controlRegistry: AtomRegistry.AtomRegistry;
+  replaceSubject: (subject: string | null) => Effect.Effect<void, never, never>;
+  completeAuthentication: OperationAuthenticationCompletion;
+}, never, Scope.Scope>;
+//#endregion
+export { AuthAtomLifetime, AuthSubjectLifetime, makeLifetime };
+//# sourceMappingURL=AuthAtomLifetime.d.mts.map

package/dist/atom/AuthAtomLifetime.mjs

@@ -0,0 +1,50 @@
+import { makeAuthenticationCompletion } from "../http-operation/client.mjs";
+import { Context, Effect, Scope, Semaphore, SubscriptionRef } from "effect";
+import { Atom, AtomRegistry } from "effect/unstable/reactivity";
+//#region src/atom/AuthAtomLifetime.ts
+var AuthAtomLifetime = class extends Context.Service()("effect-auth/AuthAtomLifetime") {};
+/** A dedicated registry is disposed before the next subject is published. Mount
+* only `current` in `controlRegistry`. All operation atoms, including auth
+* mutations and device workflows, belong to the current subject registry. Acquire
+* this lifetime in the host scope, then provide its value to the Atom runtime. */
+const makeLifetime = Effect.fn("AuthAtom.makeLifetime")(function* (client, options) {
+	const gate = yield* Semaphore.make(1);
+	const controlRegistry = AtomRegistry.make();
+	const state = yield* SubscriptionRef.make({
+		subject: options?.initialSubject ?? null,
+		generation: 0,
+		registry: AtomRegistry.make()
+	});
+	const publishSubject = Effect.fn("AuthAtom.publishSubject")(function* (subject) {
+		const previous = yield* SubscriptionRef.get(state);
+		previous.registry.dispose();
+		yield* SubscriptionRef.set(state, {
+			subject,
+			generation: previous.generation + 1,
+			registry: AtomRegistry.make()
+		});
+	});
+	const replaceSubject = Effect.fn("AuthAtom.replaceSubject")(function* (subject) {
+		yield* gate.withPermits(1)(Effect.uninterruptible(Effect.gen(function* () {
+			yield* client.transition;
+			yield* publishSubject(subject);
+		})));
+	});
+	yield* Scope.addFinalizer(yield* Effect.scope, gate.withPermits(1)(Effect.gen(function* () {
+		yield* client.transition;
+		(yield* SubscriptionRef.get(state)).registry.dispose();
+		controlRegistry.dispose();
+	})));
+	return {
+		client,
+		current: Atom.subscriptionRef(state),
+		get: SubscriptionRef.get(state),
+		controlRegistry,
+		replaceSubject,
+		completeAuthentication: makeAuthenticationCompletion(client, gate, publishSubject)
+	};
+});
+//#endregion
+export { AuthAtomLifetime, makeLifetime };
+
+//# sourceMappingURL=AuthAtomLifetime.mjs.map

package/dist/atom/AuthAtomLifetime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthAtomLifetime.mjs","names":[],"sources":["../../src/atom/AuthAtomLifetime.ts"],"sourcesContent":["import { Context, Effect, Scope, Semaphore, SubscriptionRef } from \"effect\";\nimport { Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport {\n  makeAuthenticationCompletion,\n  type OperationAuthenticationCompletion,\n  type OperationFetchClient,\n} from \"../http-operation/client\";\n\nexport interface AuthSubjectLifetime {\n  readonly subject: string | null;\n  readonly generation: number;\n  readonly registry: AtomRegistry.AtomRegistry;\n}\n\nexport class AuthAtomLifetime extends Context.Service<\n  AuthAtomLifetime,\n  {\n    readonly client: OperationFetchClient;\n    readonly current: Atom.Atom<AuthSubjectLifetime>;\n    readonly get: Effect.Effect<AuthSubjectLifetime>;\n    readonly controlRegistry: AtomRegistry.AtomRegistry;\n    readonly replaceSubject: (subject: string | null) => Effect.Effect<void>;\n    readonly completeAuthentication: OperationAuthenticationCompletion;\n  }\n>()(\"effect-auth/AuthAtomLifetime\") {}\n\n/** A dedicated registry is disposed before the next subject is published. Mount\n * only `current` in `controlRegistry`. All operation atoms, including auth\n * mutations and device workflows, belong to the current subject registry. Acquire\n * this lifetime in the host scope, then provide its value to the Atom runtime. */\nexport const makeLifetime = Effect.fn(\"AuthAtom.makeLifetime\")(function* (\n  client: OperationFetchClient,\n  options?: { readonly initialSubject?: string | null },\n) {\n  const gate = yield* Semaphore.make(1);\n  const controlRegistry = AtomRegistry.make();\n\n  const state = yield* SubscriptionRef.make<AuthSubjectLifetime>({\n    subject: options?.initialSubject ?? null,\n    generation: 0,\n    registry: AtomRegistry.make(),\n  });\n\n  const publishSubject = Effect.fn(\"AuthAtom.publishSubject\")(function* (subject: string | null) {\n    const previous = yield* SubscriptionRef.get(state);\n\n    previous.registry.dispose();\n    yield* SubscriptionRef.set(state, {\n      subject,\n      generation: previous.generation + 1,\n      registry: AtomRegistry.make(),\n    });\n  });\n\n  const replaceSubject = Effect.fn(\"AuthAtom.replaceSubject\")(function* (subject: string | null) {\n    yield* gate.withPermits(1)(\n      Effect.uninterruptible(\n        Effect.gen(function* () {\n          // The Fetch client waits for browser credential responses before advancing.\n          yield* client.transition;\n          yield* publishSubject(subject);\n        }),\n      ),\n    );\n  });\n\n  yield* Scope.addFinalizer(\n    yield* Effect.scope,\n    gate.withPermits(1)(\n      Effect.gen(function* () {\n        yield* client.transition;\n        (yield* SubscriptionRef.get(state)).registry.dispose();\n        controlRegistry.dispose();\n      }),\n    ),\n  );\n\n  return {\n    client,\n    current: Atom.subscriptionRef(state) as Atom.Atom<AuthSubjectLifetime>,\n    get: SubscriptionRef.get(state),\n    controlRegistry,\n    replaceSubject,\n    completeAuthentication: makeAuthenticationCompletion(client, gate, publishSubject),\n  };\n});\n"],"mappings":";;;;AAeA,IAAa,mBAAb,cAAsC,QAAQ,QAU5C,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;;;;;AAMrC,MAAa,eAAe,OAAO,GAAG,uBAAuB,CAAC,CAAC,WAC7D,QACA,SACA;CACA,MAAM,OAAO,OAAO,UAAU,KAAK,CAAC;CACpC,MAAM,kBAAkB,aAAa,KAAK;CAE1C,MAAM,QAAQ,OAAO,gBAAgB,KAA0B;EAC7D,SAAS,SAAS,kBAAkB;EACpC,YAAY;EACZ,UAAU,aAAa,KAAK;CAC9B,CAAC;CAED,MAAM,iBAAiB,OAAO,GAAG,yBAAyB,CAAC,CAAC,WAAW,SAAwB;EAC7F,MAAM,WAAW,OAAO,gBAAgB,IAAI,KAAK;EAEjD,SAAS,SAAS,QAAQ;EAC1B,OAAO,gBAAgB,IAAI,OAAO;GAChC;GACA,YAAY,SAAS,aAAa;GAClC,UAAU,aAAa,KAAK;EAC9B,CAAC;CACH,CAAC;CAED,MAAM,iBAAiB,OAAO,GAAG,yBAAyB,CAAC,CAAC,WAAW,SAAwB;EAC7F,OAAO,KAAK,YAAY,CAAC,CAAC,CACxB,OAAO,gBACL,OAAO,IAAI,aAAa;GAEtB,OAAO,OAAO;GACd,OAAO,eAAe,OAAO;EAC/B,CAAC,CACH,CACF;CACF,CAAC;CAED,OAAO,MAAM,aACX,OAAO,OAAO,OACd,KAAK,YAAY,CAAC,CAAC,CACjB,OAAO,IAAI,aAAa;EACtB,OAAO,OAAO;EACd,CAAC,OAAO,gBAAgB,IAAI,KAAK,EAAA,CAAG,SAAS,QAAQ;EACrD,gBAAgB,QAAQ;CAC1B,CAAC,CACH,CACF;CAEA,OAAO;EACL;EACA,SAAS,KAAK,gBAAgB,KAAK;EACnC,KAAK,gBAAgB,IAAI,KAAK;EAC9B;EACA;EACA,wBAAwB,6BAA6B,QAAQ,MAAM,cAAc;CACnF;AACF,CAAC"}

package/dist/atom/AuthAtomWorkflow.d.mts

@@ -0,0 +1,17 @@
+import { AnyRoute, RouteFailure, RouteInput, RouteSuccess } from "../http-operation/contract.mjs";
+import { OperationHttpError } from "../http-operation/errors.mjs";
+import { OperationFetchClient } from "../http-operation/client.mjs";
+import { Context, Effect } from "effect";
+//#region src/atom/AuthAtomWorkflow.d.ts
+declare const AuthAtomWorkflow_base: Context.ServiceClass<AuthAtomWorkflow, "effect-auth/AuthAtomWorkflow", {
+  readonly call: OperationFetchClient["call"];
+  /** Check after browser/device work before making the next operation call. */
+  readonly current: Effect.Effect<void, OperationHttpError>;
+  readonly completeAuthentication: <Route extends AnyRoute>(route: Route, input: RouteInput<Route>, subject: (value: RouteSuccess<Route>) => string | null | undefined) => Effect.Effect<RouteSuccess<Route>, RouteFailure<Route> | OperationHttpError, Route["operation"]["rpc"]["successSchema"]["DecodingServices"] | Route["operation"]["rpc"]["errorSchema"]["DecodingServices"]>;
+}>;
+/** Each workflow invocation owns one generation fence. Device work stays
+ * interruptible; its final authentication call and subject publication settle together. */
+declare class AuthAtomWorkflow extends AuthAtomWorkflow_base {}
+//#endregion
+export { AuthAtomWorkflow };
+//# sourceMappingURL=AuthAtomWorkflow.d.mts.map

package/dist/atom/AuthAtomWorkflow.mjs

@@ -0,0 +1,9 @@
+import { Context } from "effect";
+//#region src/atom/AuthAtomWorkflow.ts
+/** Each workflow invocation owns one generation fence. Device work stays
+* interruptible; its final authentication call and subject publication settle together. */
+var AuthAtomWorkflow = class extends Context.Service()("effect-auth/AuthAtomWorkflow") {};
+//#endregion
+export { AuthAtomWorkflow };
+
+//# sourceMappingURL=AuthAtomWorkflow.mjs.map

package/dist/atom/AuthAtomWorkflow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthAtomWorkflow.mjs","names":[],"sources":["../../src/atom/AuthAtomWorkflow.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport { Context } from \"effect\";\n\nimport type { OperationFetchClient } from \"../http-operation/client\";\nimport type { AnyRoute, RouteFailure, RouteInput, RouteSuccess } from \"../http-operation/contract\";\nimport type { OperationHttpError } from \"../http-operation/errors\";\n\n/** Each workflow invocation owns one generation fence. Device work stays\n * interruptible; its final authentication call and subject publication settle together. */\nexport class AuthAtomWorkflow extends Context.Service<\n  AuthAtomWorkflow,\n  {\n    readonly call: OperationFetchClient[\"call\"];\n    /** Check after browser/device work before making the next operation call. */\n    readonly current: Effect.Effect<void, OperationHttpError>;\n    readonly completeAuthentication: <Route extends AnyRoute>(\n      route: Route,\n      input: RouteInput<Route>,\n      subject: (value: RouteSuccess<Route>) => string | null | undefined,\n    ) => Effect.Effect<\n      RouteSuccess<Route>,\n      RouteFailure<Route> | OperationHttpError,\n      | Route[\"operation\"][\"rpc\"][\"successSchema\"][\"DecodingServices\"]\n      | Route[\"operation\"][\"rpc\"][\"errorSchema\"][\"DecodingServices\"]\n    >;\n  }\n>()(\"effect-auth/AuthAtomWorkflow\") {}\n"],"mappings":";;;;AASA,IAAa,mBAAb,cAAsC,QAAQ,QAiB5C,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC"}

package/dist/atom/client.d.mts

@@ -0,0 +1,43 @@
+import { RouteFailure, RouteInput, RouteSuccess } from "../http-operation/contract.mjs";
+import { OperationHttpError } from "../http-operation/errors.mjs";
+import { AuthAtomLifetime } from "./AuthAtomLifetime.mjs";
+import { ReactivityKeys } from "./operations.mjs";
+import { AnyAuthAction, AuthActions } from "../operations/actions.mjs";
+import { ActionDecodeServices, ClientDefinition, ClientService } from "../http-operation/auth-client.mjs";
+import { Layer } from "effect";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region src/atom/client.d.ts
+type ActionsWithSession = AuthActions & {
+  readonly getSession: AnyAuthAction;
+};
+type DecoderServices<Actions extends AuthActions> = ActionDecodeServices<Actions[keyof Actions]>;
+interface AuthAtomOptions<Actions extends AuthActions, E = never, Id extends string = string> {
+  /** Use the application's runtime factory to share Layers and invalidation. */
+  readonly runtime?: Atom.RegistryRuntimeFactory | Atom.SharedRuntimeFactory;
+  /** Replace the configured client service, for example with an application test Layer. */
+  readonly layer?: Layer.Layer<ClientService<Id, Actions>, E>;
+  /** Additional application queries invalidated by a successful mutation. */
+  readonly reactivityKeys?: Partial<{ readonly [Name in keyof Actions as Actions[Name]["mode"] extends "mutation" ? Name : never]: ReactivityKeys; }>;
+  /** Encoded initial display data. Define a separate binding for each SSR request. */
+  readonly initialSession?: unknown;
+  /** Required when action result codecs depend on services. */
+  readonly services?: Layer.Layer<DecoderServices<Actions>, E>;
+}
+type QueryAtom<Action extends AnyAuthAction, E = never> = Atom.Atom<AsyncResult.AsyncResult<RouteSuccess<Action["route"]>, RouteFailure<Action["route"]> | OperationHttpError | E>>;
+type AuthActionAtom<Action extends AnyAuthAction, E = never> = Action["mode"] extends "query" ? undefined extends RouteInput<Action["route"]> ? QueryAtom<Action, E> : (input: RouteInput<Action["route"]>) => QueryAtom<Action, E> : Atom.AtomResultFn<RouteInput<Action["route"]>, RouteSuccess<Action["route"]>, RouteFailure<Action["route"]> | OperationHttpError | E>;
+type AuthAtoms<Id extends string, Actions extends ActionsWithSession, E = never> = { readonly [Name in keyof Actions]: AuthActionAtom<Actions[Name], E>; } & {
+  readonly session: QueryAtom<Actions["getSession"], E>;
+  readonly client: ClientDefinition<Id, Actions>;
+  /** Account-scoped queries, effects, state and workflows. Named auth mutations
+   * use the host lifetime so their own successful account change can settle. */
+  readonly runtime: Atom.AtomRuntime<ClientService<Id, Actions> | AuthAtomLifetime | DecoderServices<Actions>, E | OperationHttpError>;
+};
+/** Define importable atoms without acquiring a client. The host registry owns
+ * one client Scope; private account registries are replaced internally. Supply
+ * the same runtime factory as other application queries to share invalidation. */
+declare const make: <const Id extends string, Actions extends ActionsWithSession, E = never>(client: ClientDefinition<Id, Actions>, ...args: [DecoderServices<Actions>] extends [never] ? [options?: AuthAtomOptions<Actions, E, Id>] : [options: AuthAtomOptions<Actions, E, Id> & {
+  readonly services: Layer.Layer<DecoderServices<Actions>, E>;
+}]) => AuthAtoms<Id, Actions, E>;
+//#endregion
+export { AuthActionAtom, AuthAtomOptions, AuthAtoms, make };
+//# sourceMappingURL=client.d.mts.map

package/dist/atom/client.mjs

@@ -0,0 +1,168 @@
+import { OperationHttpError } from "../http-operation/errors.mjs";
+import { AuthClientTypeId } from "../http-operation/auth-client.mjs";
+import { AuthAtomLifetime } from "./AuthAtomLifetime.mjs";
+import { makeScopedRuntime } from "./scoped-runtime.mjs";
+import { Context, Effect, Layer, Schema, Scope } from "effect";
+import { AsyncResult, Atom, AtomRegistry, Reactivity } from "effect/unstable/reactivity";
+//#region src/atom/client.ts
+var AuthAtomBinding = class extends Context.Service()("effect-auth/Atom/Binding") {};
+/** Define importable atoms without acquiring a client. The host registry owns
+* one client Scope; private account registries are replaced internally. Supply
+* the same runtime factory as other application queries to share invalidation. */
+const make = (client, ...args) => {
+	const options = args[0] ?? {};
+	const factory = options.runtime ?? Atom.runtime;
+	const actions = client.contract.actions;
+	const queryKeys = [Symbol("effect-auth/client/queries")];
+	const extraKeys = options.reactivityKeys;
+	const services = options.services ?? Layer.empty;
+	const acquire = Effect.gen(function* () {
+		const controller = (yield* client).auth[AuthClientTypeId];
+		const reactivity = yield* Reactivity.Reactivity;
+		const parent = yield* AtomRegistry.AtomRegistry;
+		const scope = yield* Effect.scope;
+		const codecServices = yield* Effect.context();
+		if (actions.getSession.mode !== "query" || [
+			"session",
+			"runtime",
+			"client"
+		].some((name) => Object.hasOwn(actions, name)) || Object.values(actions).some(({ mode, route }) => mode === "query" && (route.operation.credentials || route.operation.reveals.length > 0 || route.operation.replay !== "read-only"))) return yield* OperationHttpError.make({ reason: "request" });
+		const initial = yield* controller.state;
+		const hasSeed = Object.hasOwn(options, "initialSession");
+		if (hasSeed && initial.generation !== 0) return yield* OperationHttpError.make({ reason: "stale-response" });
+		const sessionSchema = actions.getSession.route.operation.rpc.successSchema;
+		const seed = hasSeed ? yield* Schema.decodeUnknownEffect(sessionSchema)(options.initialSession).pipe(Effect.mapError(() => OperationHttpError.make({ reason: "response" })), Effect.provide(codecServices)) : void 0;
+		const memoMap = Atom.isAtom(factory.memoMap) ? parent.get(factory.memoMap) : factory.memoMap;
+		const newRegistry = () => AtomRegistry.make({ initialValues: Atom.isAtom(factory.memoMap) ? [Atom.initialValue(factory.memoMap, memoMap)] : void 0 });
+		const controlRegistry = AtomRegistry.make();
+		let current = {
+			...initial,
+			registry: newRegistry()
+		};
+		const state = Atom.make(current).pipe(Atom.keepAlive);
+		const listeners = /* @__PURE__ */ new Set();
+		let closed = false;
+		const lifetime = {
+			client: controller.transport,
+			current: Atom.readable((get) => {
+				get.addFinalizer(controlRegistry.subscribe(state, (value) => get.setSelf(value)));
+				return controlRegistry.get(state);
+			}),
+			get: Effect.sync(() => current),
+			controlRegistry,
+			replaceSubject: controller.replaceSubject,
+			completeAuthentication: controller.completeAuthentication
+		};
+		const binding = {
+			lifetime,
+			current: () => current,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			},
+			seed,
+			seedAvailable: hasSeed
+		};
+		yield* controller.subscribe((event) => Effect.gen(function* () {
+			if (closed) return;
+			if (event._tag === "Mutation") {
+				yield* reactivity.invalidate(queryKeys);
+				const keys = extraKeys?.[event.name];
+				if (keys !== void 0) yield* reactivity.invalidate(keys);
+				return;
+			}
+			if (current.generation === event.state.generation) return;
+			binding.seedAvailable = false;
+			for (const listener of [...listeners]) listener(event);
+			current.registry.dispose();
+			current = {
+				...event.state,
+				registry: newRegistry()
+			};
+			controlRegistry.set(state, current);
+			const keys = event.action === void 0 ? void 0 : extraKeys?.[event.action];
+			if (keys !== void 0) yield* reactivity.invalidate(keys);
+		}));
+		yield* Scope.addFinalizer(scope, Effect.sync(() => {
+			closed = true;
+			binding.seedAvailable = false;
+			for (const listener of [...listeners]) listener({});
+			listeners.clear();
+			current.registry.dispose();
+			controlRegistry.dispose();
+		}));
+		return Context.make(AuthAtomBinding, binding).pipe(Context.add(AuthAtomLifetime, lifetime));
+	});
+	const clientLayer = options.layer ?? client.layer;
+	const host = factory(Layer.effectContext(acquire).pipe(Layer.provideMerge(clientLayer), Layer.provideMerge(services))).pipe(Atom.keepAlive);
+	const runtime = makeScopedRuntime(host, (context) => Context.get(context, AuthAtomBinding));
+	const call = Effect.fn("AuthAtom.call")(function* (name, input) {
+		return yield* (yield* client).auth[AuthClientTypeId].call(name, input);
+	});
+	const mutation = (name) => {
+		const active = Atom.make(() => ({}));
+		const source = host.fn()((input, get) => Effect.gen(function* () {
+			const binding = yield* AuthAtomBinding;
+			const instance = yield* client;
+			const origin = {};
+			const state = get(active);
+			state.origin = origin;
+			return yield* Effect.acquireUseRelease(Effect.sync(() => binding.subscribe((event) => {
+				if (state.origin !== origin) return;
+				get.setSelf(AsyncResult.initial(true));
+				if (event.origin !== origin) get.registry.set(source, Atom.Interrupt);
+			})), () => instance.auth[AuthClientTypeId].call(name, input, { origin }), (unsubscribe) => Effect.sync(() => {
+				if (state.origin === origin) state.origin = void 0;
+				unsubscribe();
+			}));
+		}));
+		return Atom.writable((get) => {
+			const context = get(host);
+			const state = get(active);
+			if (AsyncResult.isSuccess(context)) {
+				const binding = Context.get(context.value, AuthAtomBinding);
+				get.addFinalizer(binding.subscribe(() => {
+					if (state.origin === void 0) get.registry.set(source, Atom.Reset);
+				}));
+			}
+			return get(source);
+		}, (ctx, input) => {
+			if (input !== Atom.Reset && input !== Atom.Interrupt) ctx.set(source, Atom.Reset);
+			ctx.set(source, input);
+		}).pipe(Atom.withServerValueInitial);
+	};
+	const atoms = Object.fromEntries(Object.entries(actions).map(([name, action]) => {
+		if (action.mode === "mutation") return [name, mutation(name)];
+		const query = Atom.family((input) => runtime.atom(call(name, input)).pipe(factory.withReactivity(queryKeys), Atom.withServerValueInitial));
+		const payloadSchema = action.route.operation.rpc.payloadSchema;
+		const input = void 0;
+		if (!Schema.is(Schema.toEncoded(payloadSchema))(input)) return [name, query];
+		if (name !== "getSession" || !Object.hasOwn(options, "initialSession")) return [name, query(input)];
+		const session = query(input);
+		return [name, Atom.readable((get) => {
+			const result = get(session);
+			const context = get(host);
+			if (!AsyncResult.isSuccess(context)) return result;
+			const binding = Context.get(context.value, AuthAtomBinding);
+			if (!AsyncResult.isInitial(result)) binding.seedAvailable = false;
+			return binding.seedAvailable ? AsyncResult.success(binding.seed, { waiting: true }) : result;
+		}).pipe(Atom.withServerValue((get) => {
+			const context = get(host);
+			if (!AsyncResult.isSuccess(context)) return AsyncResult.initial(true);
+			const binding = Context.get(context.value, AuthAtomBinding);
+			return binding.seedAvailable ? AsyncResult.success(binding.seed, { waiting: true }) : AsyncResult.initial(true);
+		}))];
+	}));
+	return Object.freeze({
+		...atoms,
+		session: atoms.getSession,
+		client,
+		runtime
+	});
+};
+//#endregion
+export { make };
+
+//# sourceMappingURL=client.mjs.map

package/dist/atom/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../src/atom/client.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema, Scope } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry, Reactivity } from \"effect/unstable/reactivity\";\n\nimport {\n  type ActionDecodeServices,\n  AuthClientTypeId,\n  type ClientDefinition,\n  type ClientService,\n} from \"../http-operation/auth-client\";\nimport type { RouteFailure, RouteInput, RouteSuccess } from \"../http-operation/contract\";\nimport { OperationHttpError } from \"../http-operation/errors\";\nimport type { AnyAuthAction, AuthActions } from \"../operations/actions\";\nimport { AuthAtomLifetime, type AuthSubjectLifetime } from \"./AuthAtomLifetime\";\nimport type { ReactivityKeys } from \"./operations\";\nimport { type AccountBinding, makeScopedRuntime } from \"./scoped-runtime\";\n\ntype ActionsWithSession = AuthActions & { readonly getSession: AnyAuthAction };\ntype DecoderServices<Actions extends AuthActions> = ActionDecodeServices<Actions[keyof Actions]>;\n\nexport interface AuthAtomOptions<\n  Actions extends AuthActions,\n  E = never,\n  Id extends string = string,\n> {\n  /** Use the application's runtime factory to share Layers and invalidation. */\n  readonly runtime?: Atom.RegistryRuntimeFactory | Atom.SharedRuntimeFactory;\n  /** Replace the configured client service, for example with an application test Layer. */\n  readonly layer?: Layer.Layer<ClientService<Id, Actions>, E>;\n  /** Additional application queries invalidated by a successful mutation. */\n  readonly reactivityKeys?: Partial<{\n    readonly [\n      Name in keyof Actions as Actions[Name][\"mode\"] extends \"mutation\" ? Name : never\n    ]: ReactivityKeys;\n  }>;\n  /** Encoded initial display data. Define a separate binding for each SSR request. */\n  readonly initialSession?: unknown;\n  /** Required when action result codecs depend on services. */\n  readonly services?: Layer.Layer<DecoderServices<Actions>, E>;\n}\n\ntype QueryAtom<Action extends AnyAuthAction, E = never> = Atom.Atom<\n  AsyncResult.AsyncResult<\n    RouteSuccess<Action[\"route\"]>,\n    RouteFailure<Action[\"route\"]> | OperationHttpError | E\n  >\n>;\n\nexport type AuthActionAtom<Action extends AnyAuthAction, E = never> = Action[\"mode\"] extends \"query\"\n  ? undefined extends RouteInput<Action[\"route\"]>\n    ? QueryAtom<Action, E>\n    : (input: RouteInput<Action[\"route\"]>) => QueryAtom<Action, E>\n  : Atom.AtomResultFn<\n      RouteInput<Action[\"route\"]>,\n      RouteSuccess<Action[\"route\"]>,\n      RouteFailure<Action[\"route\"]> | OperationHttpError | E\n    >;\n\nexport type AuthAtoms<Id extends string, Actions extends ActionsWithSession, E = never> = {\n  readonly [Name in keyof Actions]: AuthActionAtom<Actions[Name], E>;\n} & {\n  readonly session: QueryAtom<Actions[\"getSession\"], E>;\n  readonly client: ClientDefinition<Id, Actions>;\n  /** Account-scoped queries, effects, state and workflows. Named auth mutations\n   * use the host lifetime so their own successful account change can settle. */\n  readonly runtime: Atom.AtomRuntime<\n    ClientService<Id, Actions> | AuthAtomLifetime | DecoderServices<Actions>,\n    E | OperationHttpError\n  >;\n};\n\ninterface Binding extends AccountBinding {\n  readonly seed: unknown;\n  seedAvailable: boolean;\n}\n\nclass AuthAtomBinding extends Context.Service<AuthAtomBinding, Binding>()(\n  \"effect-auth/Atom/Binding\",\n) {}\n\n/** Define importable atoms without acquiring a client. The host registry owns\n * one client Scope; private account registries are replaced internally. Supply\n * the same runtime factory as other application queries to share invalidation. */\nexport const make = <const Id extends string, Actions extends ActionsWithSession, E = never>(\n  client: ClientDefinition<Id, Actions>,\n  ...args: [DecoderServices<Actions>] extends [never]\n    ? [options?: AuthAtomOptions<Actions, E, Id>]\n    : [\n        options: AuthAtomOptions<Actions, E, Id> & {\n          readonly services: Layer.Layer<DecoderServices<Actions>, E>;\n        },\n      ]\n): AuthAtoms<Id, Actions, E> => {\n  const options = args[0] ?? {};\n  const factory = options.runtime ?? Atom.runtime;\n  const actions = client.contract.actions;\n  const queryKeys = [Symbol(\"effect-auth/client/queries\")];\n\n  const extraKeys = options.reactivityKeys as\n    | Readonly<Record<string, ReactivityKeys | undefined>>\n    | undefined;\n\n  // The options tuple requires this Layer whenever codec services are nonempty.\n  const services = (options.services ?? Layer.empty) as Layer.Layer<DecoderServices<Actions>, E>;\n\n  const acquire = Effect.gen(function* () {\n    const controller = (yield* client).auth[AuthClientTypeId];\n    const reactivity = yield* Reactivity.Reactivity;\n    const parent = yield* AtomRegistry.AtomRegistry;\n    const scope = yield* Effect.scope;\n    const codecServices = yield* Effect.context<DecoderServices<Actions>>();\n\n    if (\n      actions.getSession.mode !== \"query\" ||\n      [\"session\", \"runtime\", \"client\"].some((name) => Object.hasOwn(actions, name)) ||\n      Object.values(actions).some(\n        ({ mode, route }) =>\n          mode === \"query\" &&\n          (route.operation.credentials ||\n            route.operation.reveals.length > 0 ||\n            route.operation.replay !== \"read-only\"),\n      )\n    )\n      return yield* OperationHttpError.make({ reason: \"request\" });\n\n    const initial = yield* controller.state;\n    const hasSeed = Object.hasOwn(options, \"initialSession\");\n\n    if (hasSeed && initial.generation !== 0)\n      return yield* OperationHttpError.make({ reason: \"stale-response\" });\n\n    const sessionSchema: Actions[\"getSession\"][\"route\"][\"operation\"][\"rpc\"][\"successSchema\"] =\n      actions.getSession.route.operation.rpc.successSchema;\n\n    const seed = hasSeed\n      ? yield* Schema.decodeUnknownEffect(sessionSchema)(options.initialSession).pipe(\n          Effect.mapError(() => OperationHttpError.make({ reason: \"response\" })),\n          Effect.provide(codecServices),\n        )\n      : undefined;\n\n    const memoMap = Atom.isAtom(factory.memoMap) ? parent.get(factory.memoMap) : factory.memoMap;\n\n    const newRegistry = () =>\n      AtomRegistry.make({\n        initialValues: Atom.isAtom(factory.memoMap)\n          ? [Atom.initialValue(factory.memoMap, memoMap)]\n          : undefined,\n      });\n\n    const controlRegistry = AtomRegistry.make();\n    let current: AuthSubjectLifetime = { ...initial, registry: newRegistry() };\n    const state = Atom.make(current).pipe(Atom.keepAlive);\n    const listeners = new Set<(event: { readonly origin?: object }) => void>();\n    let closed = false;\n\n    const lifetime: AuthAtomLifetime[\"Service\"] = {\n      client: controller.transport,\n      current: Atom.readable((get) => {\n        get.addFinalizer(controlRegistry.subscribe(state, (value) => get.setSelf(value)));\n\n        return controlRegistry.get(state);\n      }),\n      get: Effect.sync(() => current),\n      controlRegistry,\n      replaceSubject: controller.replaceSubject,\n      completeAuthentication: controller.completeAuthentication,\n    };\n\n    const binding: Binding = {\n      lifetime,\n      current: () => current,\n      subscribe: (listener) => {\n        listeners.add(listener);\n\n        return () => {\n          listeners.delete(listener);\n        };\n      },\n      seed,\n      seedAvailable: hasSeed,\n    };\n\n    yield* controller.subscribe((event) =>\n      Effect.gen(function* () {\n        if (closed) return;\n        if (event._tag === \"Mutation\") {\n          yield* reactivity.invalidate(queryKeys);\n          const keys = extraKeys?.[event.name];\n\n          if (keys !== undefined) yield* reactivity.invalidate(keys);\n\n          return;\n        }\n        if (current.generation === event.state.generation) return;\n        binding.seedAvailable = false;\n        // Retire public views and settle pending dispatch observers before disposal.\n        for (const listener of [...listeners]) listener(event);\n        current.registry.dispose();\n        current = { ...event.state, registry: newRegistry() };\n        controlRegistry.set(state, current);\n        // Account-owned workflows may be interrupted during this transition.\n        const keys = event.action === undefined ? undefined : extraKeys?.[event.action];\n\n        if (keys !== undefined) yield* reactivity.invalidate(keys);\n      }),\n    );\n\n    yield* Scope.addFinalizer(\n      scope,\n      Effect.sync(() => {\n        closed = true;\n        binding.seedAvailable = false;\n        for (const listener of [...listeners]) listener({});\n        listeners.clear();\n        current.registry.dispose();\n        controlRegistry.dispose();\n      }),\n    );\n\n    return Context.make(AuthAtomBinding, binding).pipe(Context.add(AuthAtomLifetime, lifetime));\n  });\n\n  const clientLayer: Layer.Layer<\n    ClientService<Id, Actions>,\n    E | OperationHttpError\n  > = options.layer ?? client.layer;\n\n  const host = factory(\n    Layer.effectContext(acquire).pipe(\n      Layer.provideMerge(clientLayer),\n      Layer.provideMerge(services),\n    ),\n  ).pipe(Atom.keepAlive);\n\n  const runtime = makeScopedRuntime(host, (context) => Context.get(context, AuthAtomBinding));\n\n  const call = Effect.fn(\"AuthAtom.call\")(function* <Name extends keyof Actions>(\n    name: Name,\n    input: RouteInput<Actions[Name][\"route\"]>,\n  ) {\n    const instance = yield* client;\n\n    return yield* instance.auth[AuthClientTypeId].call(name, input);\n  });\n\n  const mutation = <Name extends keyof Actions>(name: Name) => {\n    const active = Atom.make((): { origin?: object } => ({}));\n\n    const source = host.fn<RouteInput<Actions[Name][\"route\"]>>()((input, get) =>\n      Effect.gen(function* () {\n        const binding = yield* AuthAtomBinding;\n        const instance = yield* client;\n        const origin = {};\n        const state = get(active);\n\n        state.origin = origin;\n\n        return yield* Effect.acquireUseRelease(\n          Effect.sync(() =>\n            binding.subscribe((event) => {\n              // A replaced call may still be settling credentials uninterruptibly.\n              // Its observer must never interrupt the newer dispatch in this atom.\n              if (state.origin !== origin) return;\n              // Remove any previous account's public result without cancelling the\n              // authentication call that owns this admitted transition.\n              get.setSelf(AsyncResult.initial(true));\n              if (event.origin !== origin) get.registry.set(source, Atom.Interrupt);\n            }),\n          ),\n          () => instance.auth[AuthClientTypeId].call(name, input, { origin }),\n          (unsubscribe) =>\n            Effect.sync(() => {\n              if (state.origin === origin) state.origin = undefined;\n              unsubscribe();\n            }),\n        );\n      }),\n    );\n\n    return Atom.writable(\n      (get) => {\n        const context = get(host);\n        const state = get(active);\n\n        if (AsyncResult.isSuccess(context)) {\n          const binding = Context.get(context.value, AuthAtomBinding);\n\n          get.addFinalizer(\n            binding.subscribe(() => {\n              if (state.origin === undefined) get.registry.set(source, Atom.Reset);\n            }),\n          );\n        }\n\n        return get(source);\n      },\n      (ctx, input: RouteInput<Actions[Name][\"route\"]> | Atom.Reset | Atom.Interrupt) => {\n        // Each dispatch starts without a previous account result. Native fn\n        // captures its previous value when running, before transition callbacks.\n        if (input !== Atom.Reset && input !== Atom.Interrupt) ctx.set(source, Atom.Reset);\n        ctx.set(source, input);\n      },\n    ).pipe(Atom.withServerValueInitial);\n  };\n\n  const atoms = Object.fromEntries(\n    Object.entries(actions).map(([name, action]) => {\n      if (action.mode === \"mutation\") return [name, mutation(name)];\n\n      const query = Atom.family((input: RouteInput<Actions[string][\"route\"]>) =>\n        runtime\n          .atom(call(name, input))\n          .pipe(factory.withReactivity(queryKeys), Atom.withServerValueInitial),\n      );\n\n      // Restore the encoded payload relationship while inspecting heterogeneous actions.\n      const payloadSchema = action.route.operation.rpc.payloadSchema as Schema.Top & {\n        readonly Encoded: RouteInput<Actions[string][\"route\"]>;\n      };\n\n      const input: unknown = undefined;\n\n      if (!Schema.is(Schema.toEncoded(payloadSchema))(input)) return [name, query];\n      if (name !== \"getSession\" || !Object.hasOwn(options, \"initialSession\"))\n        return [name, query(input)];\n      const session = query(input);\n\n      return [\n        name,\n        Atom.readable((get) => {\n          const result = get(session);\n          const context = get(host);\n\n          if (!AsyncResult.isSuccess(context)) return result;\n          const binding = Context.get(context.value, AuthAtomBinding);\n\n          if (!AsyncResult.isInitial(result)) binding.seedAvailable = false;\n\n          return binding.seedAvailable\n            ? AsyncResult.success(binding.seed, { waiting: true })\n            : result;\n        }).pipe(\n          Atom.withServerValue((get) => {\n            const context = get(host);\n\n            if (!AsyncResult.isSuccess(context)) return AsyncResult.initial(true);\n            const binding = Context.get(context.value, AuthAtomBinding);\n\n            return binding.seedAvailable\n              ? AsyncResult.success(binding.seed, { waiting: true })\n              : AsyncResult.initial(true);\n          }),\n        ),\n      ];\n    }),\n  );\n\n  // Action mode and encoded payload choose each named atom's exact public form.\n  return Object.freeze({ ...atoms, session: atoms.getSession, client, runtime }) as AuthAtoms<\n    Id,\n    Actions,\n    E\n  >;\n};\n"],"mappings":"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"}

package/dist/atom/operations.d.mts

@@ -0,0 +1,35 @@
+import { AnyRoute, RouteFailure, RouteInput, RouteSuccess } from "../http-operation/contract.mjs";
+import { OperationHttpError } from "../http-operation/errors.mjs";
+import { AuthAtomLifetime } from "./AuthAtomLifetime.mjs";
+import { AuthAtomWorkflow } from "./AuthAtomWorkflow.mjs";
+import "../OperationHttp.mjs";
+import { Effect, Scope } from "effect";
+import { Atom, AtomRegistry, Reactivity } from "effect/unstable/reactivity";
+//#region src/atom/operations.d.ts
+type DecodeServices<Route extends AnyRoute> = Route["operation"]["rpc"]["successSchema"]["DecodingServices"] | Route["operation"]["rpc"]["errorSchema"]["DecodingServices"];
+type ReactivityKeys = ReadonlyArray<unknown> | Readonly<Record<string, ReadonlyArray<unknown>>>;
+/** Queries cannot contain private reveals. Their values belong to the current
+ * subject registry; declare the same keys on mutations that invalidate them. */
+declare const query: <Route extends AnyRoute, RuntimeError>(route: Route, input: RouteInput<Route>, options: {
+  readonly runtime: Atom.AtomRuntime<AuthAtomLifetime | DecodeServices<Route>, RuntimeError>;
+  readonly reactivityKeys: ReactivityKeys;
+}) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<RouteSuccess<Route>, RuntimeError | OperationHttpError | RouteFailure<Route>>>;
+/** Operation atoms run in the current subject registry. A subject-changing
+ * mutation disposes its old result and publishes the new lifetime; rendering
+ * follows `lifetime.current` rather than retaining that mutation's success. */
+declare const mutation: <Route extends AnyRoute, RuntimeError>(route: Route, options: {
+  readonly runtime: Atom.AtomRuntime<AuthAtomLifetime | DecodeServices<Route>, RuntimeError>;
+  readonly reactivityKeys: ReactivityKeys;
+  readonly subject?: {
+    readonly fromSuccess: (success: RouteSuccess<Route>) => string | null | undefined;
+  };
+}) => Atom.AtomResultFn<RouteInput<Route>, RouteSuccess<Route>, RuntimeError | OperationHttpError | RouteFailure<Route>>;
+/** Compose protocol operations and device effects in Atom, leaving rendering
+ * and promise-mode dispatch free of authentication logic. Each workflow is
+ * fenced at entry, between consumer steps through `current`, and on completion. */
+declare const workflow: <Input>() => <A, E, R, RuntimeError>(runtime: Atom.AtomRuntime<AuthAtomLifetime | R, RuntimeError>, run: (input: Input, atoms: Atom.FnContext) => Effect.Effect<A, E, R | AuthAtomLifetime | AuthAtomWorkflow | Scope.Scope | AtomRegistry.AtomRegistry | Reactivity.Reactivity>, options: {
+  readonly reactivityKeys: ReactivityKeys;
+}) => Atom.AtomResultFn<Input, A, E | RuntimeError | OperationHttpError>;
+//#endregion
+export { ReactivityKeys, mutation, query, workflow };
+//# sourceMappingURL=operations.d.mts.map

package/dist/atom/operations.mjs

@@ -0,0 +1,58 @@
+import { OperationHttpConfigurationError, OperationHttpError } from "../http-operation/errors.mjs";
+import { AuthAtomLifetime } from "./AuthAtomLifetime.mjs";
+import { AuthAtomWorkflow } from "./AuthAtomWorkflow.mjs";
+import { Effect } from "effect";
+import { AtomRegistry, Reactivity } from "effect/unstable/reactivity";
+//#region src/atom/operations.ts
+const inLifetime = Effect.fn("AuthAtom.inLifetime")(function* (effect) {
+	const lifetime = yield* AuthAtomLifetime;
+	const registry = yield* AtomRegistry.AtomRegistry;
+	if ((yield* lifetime.get).registry !== registry) return yield* OperationHttpError.make({ reason: "stale-response" });
+	return yield* effect;
+});
+/** Queries cannot contain private reveals. Their values belong to the current
+* subject registry; declare the same keys on mutations that invalidate them. */
+const query = (route, input, options) => {
+	if (route.operation.credentials || route.operation.reveals.length > 0 || route.operation.replay !== "read-only") throw OperationHttpConfigurationError.make({ reason: "route" });
+	return options.runtime.atom(inLifetime(Effect.gen(function* () {
+		const { client } = yield* AuthAtomLifetime;
+		return yield* client.call(route, input);
+	}))).pipe(options.runtime.factory.withReactivity(options.reactivityKeys));
+};
+/** Operation atoms run in the current subject registry. A subject-changing
+* mutation disposes its old result and publishes the new lifetime; rendering
+* follows `lifetime.current` rather than retaining that mutation's success. */
+const mutation = (route, options) => options.runtime.fn()((input) => inLifetime(Effect.gen(function* () {
+	if (options.subject !== void 0) return yield* completeAuthentication(route, input, options.subject.fromSuccess, options.reactivityKeys);
+	const { client } = yield* AuthAtomLifetime;
+	return yield* client.call(route, input);
+})), { reactivityKeys: options.reactivityKeys });
+const completeAuthentication = Effect.fn("AuthAtom.completeAuthentication")(function* (route, input, subject, reactivityKeys) {
+	const lifetime = yield* AuthAtomLifetime;
+	const reactivity = yield* Reactivity.Reactivity;
+	return yield* lifetime.completeAuthentication(route, input, subject, { onTransition: reactivity.invalidate(reactivityKeys) });
+});
+/** Compose protocol operations and device effects in Atom, leaving rendering
+* and promise-mode dispatch free of authentication logic. Each workflow is
+* fenced at entry, between consumer steps through `current`, and on completion. */
+const workflow = () => (runtime, run, options) => runtime.fn()((input, atoms) => inLifetime(Effect.gen(function* () {
+	const lifetime = yield* AuthAtomLifetime;
+	const { client } = lifetime;
+	const started = yield* client.generation;
+	const current = Effect.gen(function* () {
+		if ((yield* client.generation) !== started) return yield* OperationHttpError.make({ reason: "stale-response" });
+	});
+	const call = (route, value, options) => options?.replaceSubject !== void 0 && options.replaceSubject !== false ? Effect.fail(OperationHttpError.make({ reason: "request" })) : current.pipe(Effect.andThen(client.call(route, value, options)), Effect.tap(() => current));
+	const finish = (route, value, subject) => current.pipe(Effect.andThen(completeAuthentication(route, value, subject, options.reactivityKeys)), Effect.provideService(AuthAtomLifetime, lifetime));
+	const value = yield* run(input, atoms).pipe(Effect.provideService(AuthAtomWorkflow, {
+		call,
+		current,
+		completeAuthentication: finish
+	}));
+	yield* current;
+	return value;
+})), { reactivityKeys: options.reactivityKeys });
+//#endregion
+export { mutation, query, workflow };
+
+//# sourceMappingURL=operations.mjs.map

package/dist/atom/operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.mjs","names":[],"sources":["../../src/atom/operations.ts"],"sourcesContent":["import type { Scope } from \"effect\";\nimport { Effect } from \"effect\";\nimport type { Atom } from \"effect/unstable/reactivity\";\nimport { AtomRegistry, Reactivity } from \"effect/unstable/reactivity\";\n\nimport type { OperationFetchClient } from \"../http-operation/client\";\nimport type { AnyRoute, RouteInput, RouteSuccess } from \"../http-operation/contract\";\nimport { OperationHttpConfigurationError, OperationHttpError } from \"../http-operation/errors\";\nimport { AuthAtomLifetime } from \"./AuthAtomLifetime\";\nimport { AuthAtomWorkflow } from \"./AuthAtomWorkflow\";\n\ntype DecodeServices<Route extends AnyRoute> =\n  | Route[\"operation\"][\"rpc\"][\"successSchema\"][\"DecodingServices\"]\n  | Route[\"operation\"][\"rpc\"][\"errorSchema\"][\"DecodingServices\"];\n\nconst inLifetime = Effect.fn(\"AuthAtom.inLifetime\")(function* <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n) {\n  const lifetime = yield* AuthAtomLifetime;\n  const registry = yield* AtomRegistry.AtomRegistry;\n  const current = yield* lifetime.get;\n\n  if (current.registry !== registry)\n    return yield* OperationHttpError.make({ reason: \"stale-response\" });\n\n  return yield* effect;\n});\n\nexport type ReactivityKeys =\n  | ReadonlyArray<unknown>\n  | Readonly<Record<string, ReadonlyArray<unknown>>>;\n\n/** Queries cannot contain private reveals. Their values belong to the current\n * subject registry; declare the same keys on mutations that invalidate them. */\nexport const query = <Route extends AnyRoute, RuntimeError>(\n  route: Route,\n  input: RouteInput<Route>,\n  options: {\n    readonly runtime: Atom.AtomRuntime<AuthAtomLifetime | DecodeServices<Route>, RuntimeError>;\n    readonly reactivityKeys: ReactivityKeys;\n  },\n) => {\n  if (\n    route.operation.credentials ||\n    route.operation.reveals.length > 0 ||\n    route.operation.replay !== \"read-only\"\n  ) {\n    throw OperationHttpConfigurationError.make({ reason: \"route\" });\n  }\n\n  return options.runtime\n    .atom(\n      inLifetime(\n        Effect.gen(function* () {\n          const { client } = yield* AuthAtomLifetime;\n\n          return yield* client.call(route, input);\n        }),\n      ),\n    )\n    .pipe(options.runtime.factory.withReactivity(options.reactivityKeys));\n};\n\n/** Operation atoms run in the current subject registry. A subject-changing\n * mutation disposes its old result and publishes the new lifetime; rendering\n * follows `lifetime.current` rather than retaining that mutation's success. */\nexport const mutation = <Route extends AnyRoute, RuntimeError>(\n  route: Route,\n  options: {\n    readonly runtime: Atom.AtomRuntime<AuthAtomLifetime | DecodeServices<Route>, RuntimeError>;\n    readonly reactivityKeys: ReactivityKeys;\n    readonly subject?: {\n      readonly fromSuccess: (success: RouteSuccess<Route>) => string | null | undefined;\n    };\n  },\n) =>\n  options.runtime.fn<RouteInput<Route>>()(\n    (input) =>\n      inLifetime(\n        Effect.gen(function* () {\n          if (options.subject !== undefined)\n            return yield* completeAuthentication(\n              route,\n              input,\n              options.subject.fromSuccess,\n              options.reactivityKeys,\n            );\n          const { client } = yield* AuthAtomLifetime;\n\n          return yield* client.call(route, input);\n        }),\n      ),\n    { reactivityKeys: options.reactivityKeys },\n  );\n\nconst completeAuthentication = Effect.fn(\"AuthAtom.completeAuthentication\")(function* <\n  Route extends AnyRoute,\n>(\n  route: Route,\n  input: RouteInput<Route>,\n  subject: (value: RouteSuccess<Route>) => string | null | undefined,\n  reactivityKeys: ReactivityKeys,\n) {\n  const lifetime = yield* AuthAtomLifetime;\n  const reactivity = yield* Reactivity.Reactivity;\n\n  return yield* lifetime.completeAuthentication(route, input, subject, {\n    onTransition: reactivity.invalidate(reactivityKeys),\n  });\n});\n\n/** Compose protocol operations and device effects in Atom, leaving rendering\n * and promise-mode dispatch free of authentication logic. Each workflow is\n * fenced at entry, between consumer steps through `current`, and on completion. */\nexport const workflow =\n  <Input>() =>\n  <A, E, R, RuntimeError>(\n    runtime: Atom.AtomRuntime<AuthAtomLifetime | R, RuntimeError>,\n    run: (\n      input: Input,\n      atoms: Atom.FnContext,\n    ) => Effect.Effect<\n      A,\n      E,\n      | R\n      | AuthAtomLifetime\n      | AuthAtomWorkflow\n      | Scope.Scope\n      | AtomRegistry.AtomRegistry\n      | Reactivity.Reactivity\n    >,\n    options: {\n      readonly reactivityKeys: ReactivityKeys;\n    },\n  ) =>\n    runtime.fn<Input>()(\n      (input, atoms) =>\n        inLifetime(\n          Effect.gen(function* () {\n            const lifetime = yield* AuthAtomLifetime;\n            const { client } = lifetime;\n            const started = yield* client.generation;\n\n            const current = Effect.gen(function* () {\n              if ((yield* client.generation) !== started)\n                return yield* OperationHttpError.make({ reason: \"stale-response\" });\n            });\n\n            const call: OperationFetchClient[\"call\"] = (route, value, options) =>\n              options?.replaceSubject !== undefined && options.replaceSubject !== false\n                ? Effect.fail(OperationHttpError.make({ reason: \"request\" }))\n                : current.pipe(\n                    Effect.andThen(client.call(route, value, options)),\n                    Effect.tap(() => current),\n                  );\n\n            const finish: AuthAtomWorkflow[\"Service\"][\"completeAuthentication\"] = (\n              route,\n              value,\n              subject,\n            ) =>\n              current.pipe(\n                Effect.andThen(\n                  completeAuthentication(route, value, subject, options.reactivityKeys),\n                ),\n                Effect.provideService(AuthAtomLifetime, lifetime),\n              );\n\n            const value = yield* run(input, atoms).pipe(\n              Effect.provideService(AuthAtomWorkflow, {\n                call,\n                current,\n                completeAuthentication: finish,\n              }),\n            );\n\n            yield* current;\n\n            return value;\n          }),\n        ),\n      { reactivityKeys: options.reactivityKeys },\n    );\n"],"mappings":";;;;;;AAeA,MAAM,aAAa,OAAO,GAAG,qBAAqB,CAAC,CAAC,WAClD,QACA;CACA,MAAM,WAAW,OAAO;CACxB,MAAM,WAAW,OAAO,aAAa;CAGrC,KAAI,OAFmB,SAAS,IAAA,CAEpB,aAAa,UACvB,OAAO,OAAO,mBAAmB,KAAK,EAAE,QAAQ,iBAAiB,CAAC;CAEpE,OAAO,OAAO;AAChB,CAAC;;;AAQD,MAAa,SACX,OACA,OACA,YAIG;CACH,IACE,MAAM,UAAU,eAChB,MAAM,UAAU,QAAQ,SAAS,KACjC,MAAM,UAAU,WAAW,aAE3B,MAAM,gCAAgC,KAAK,EAAE,QAAQ,QAAQ,CAAC;CAGhE,OAAO,QAAQ,QACZ,KACC,WACE,OAAO,IAAI,aAAa;EACtB,MAAM,EAAE,WAAW,OAAO;EAE1B,OAAO,OAAO,OAAO,KAAK,OAAO,KAAK;CACxC,CAAC,CACH,CACF,CAAC,CACA,KAAK,QAAQ,QAAQ,QAAQ,eAAe,QAAQ,cAAc,CAAC;AACxE;;;;AAKA,MAAa,YACX,OACA,YAQA,QAAQ,QAAQ,GAAsB,CAAC,EACpC,UACC,WACE,OAAO,IAAI,aAAa;CACtB,IAAI,QAAQ,YAAY,KAAA,GACtB,OAAO,OAAO,uBACZ,OACA,OACA,QAAQ,QAAQ,aAChB,QAAQ,cACV;CACF,MAAM,EAAE,WAAW,OAAO;CAE1B,OAAO,OAAO,OAAO,KAAK,OAAO,KAAK;AACxC,CAAC,CACH,GACF,EAAE,gBAAgB,QAAQ,eAAe,CAC3C;AAEF,MAAM,yBAAyB,OAAO,GAAG,iCAAiC,CAAC,CAAC,WAG1E,OACA,OACA,SACA,gBACA;CACA,MAAM,WAAW,OAAO;CACxB,MAAM,aAAa,OAAO,WAAW;CAErC,OAAO,OAAO,SAAS,uBAAuB,OAAO,OAAO,SAAS,EACnE,cAAc,WAAW,WAAW,cAAc,EACpD,CAAC;AACH,CAAC;;;;AAKD,MAAa,kBAGT,SACA,KAaA,YAIA,QAAQ,GAAU,CAAC,EAChB,OAAO,UACN,WACE,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO;CACxB,MAAM,EAAE,WAAW;CACnB,MAAM,UAAU,OAAO,OAAO;CAE9B,MAAM,UAAU,OAAO,IAAI,aAAa;EACtC,KAAK,OAAO,OAAO,gBAAgB,SACjC,OAAO,OAAO,mBAAmB,KAAK,EAAE,QAAQ,iBAAiB,CAAC;CACtE,CAAC;CAED,MAAM,QAAsC,OAAO,OAAO,YACxD,SAAS,mBAAmB,KAAA,KAAa,QAAQ,mBAAmB,QAChE,OAAO,KAAK,mBAAmB,KAAK,EAAE,QAAQ,UAAU,CAAC,CAAC,IAC1D,QAAQ,KACN,OAAO,QAAQ,OAAO,KAAK,OAAO,OAAO,OAAO,CAAC,GACjD,OAAO,UAAU,OAAO,CAC1B;CAEN,MAAM,UACJ,OACA,OACA,YAEA,QAAQ,KACN,OAAO,QACL,uBAAuB,OAAO,OAAO,SAAS,QAAQ,cAAc,CACtE,GACA,OAAO,eAAe,kBAAkB,QAAQ,CAClD;CAEF,MAAM,QAAQ,OAAO,IAAI,OAAO,KAAK,CAAC,CAAC,KACrC,OAAO,eAAe,kBAAkB;EACtC;EACA;EACA,wBAAwB;CAC1B,CAAC,CACH;CAEA,OAAO;CAEP,OAAO;AACT,CAAC,CACH,GACF,EAAE,gBAAgB,QAAQ,eAAe,CAC3C"}