@yielded/auth 0.1.0-beta.1

package/src/operations/requestBinding.ts

@@ -0,0 +1,237 @@
+import { Context, Crypto, DateTime, Effect, Encoding, Layer, Redacted, Schema } from "effect";
+
+import { TokenDigest } from "../Schema";
+import { makeSessionSigningCodec, type SessionSigningKeyring } from "../sessions/crypto";
+import type { AuthOperationResult } from "./credentials";
+import { RequestBindingConfig } from "./RequestBindingConfig";
+import { RequestBindingFlowId, type RequestBindingPublic } from "./requestBindingModels";
+
+export {
+  RequestBindingFlowId,
+  RequestBindingCredential,
+  RequestBindingPublic,
+} from "./requestBindingModels";
+
+export class RequestBindingInvalid extends Schema.TaggedError<RequestBindingInvalid>()(
+  "RequestBindingInvalid",
+  {},
+) {}
+
+export class RequestBindingUnavailable extends Schema.TaggedError<RequestBindingUnavailable>()(
+  "RequestBindingUnavailable",
+  {},
+) {}
+
+export class RequestBindingConfigurationError extends Schema.TaggedError<RequestBindingConfigurationError>()(
+  "RequestBindingConfigurationError",
+  {},
+) {}
+
+export interface VerifiedRequestBinding {
+  /** Internal correlation only; never an accepted substitute for the credential. */
+  readonly verifier: TokenDigest;
+  readonly expiresAtMillis: number;
+}
+
+export interface RequestBindingConfiguration {
+  readonly lifetimeMillis: number;
+  readonly generation: number;
+  /** Dedicated binding keys; no implicit reuse of session signing keys. */
+  readonly keyring: SessionSigningKeyring;
+}
+
+const configurationSchema = Schema.Struct({
+  lifetimeMillis: Schema.Int.check(Schema.isBetween({ minimum: 1000, maximum: 1_800_000 })),
+  generation: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),
+  keyring: Schema.Struct({
+    activeKeyId: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{1,64}$/)),
+    keys: Schema.Array(
+      Schema.Struct({
+        id: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{1,64}$/)),
+        material: Schema.Redacted(Schema.String.check(Schema.isMaxLength(172))),
+      }),
+    ).check(Schema.isMinLength(1), Schema.isMaxLength(8)),
+  }),
+});
+
+const label = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._:/-]{1,128}$/));
+
+const envelope = Schema.Struct({
+  namespace: Schema.Literal("effect-auth/request-binding/v1"),
+  moduleId: label,
+  purpose: label,
+  flowId: RequestBindingFlowId,
+  generation: Schema.Int,
+  nonce: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)),
+  issuedAtMillis: Schema.Int,
+  expiresAtMillis: Schema.Int,
+});
+
+const verifierMessage = Schema.fromJsonString(
+  Schema.Tuple([
+    Schema.Literal("effect-auth/request-binding-verifier/v1"),
+    label,
+    label,
+    Schema.String,
+  ]),
+);
+
+export interface BindingModule<Id extends string, Purpose extends string> {
+  readonly moduleId: Id;
+  readonly purpose: Purpose;
+}
+
+/** The scalar private slot supports one standard browser flow at a time. Native
+ * consumers may explicitly retain credentials by flow in their own secure store.
+ * Browser adapters inject this credential from private storage and reject URL/body
+ * overrides. Every binding-bearing mutation, including issuance, requires CSRF
+ * protection. GET/preview routes neither begin nor consume an authentication flow.
+ */
+export const makeRequestBinding = <const Id extends string, const Purpose extends string>(
+  moduleId: Id,
+  purpose: Purpose,
+) => {
+  const RequestBinding = Context.Service<
+    BindingModule<Id, Purpose>,
+    {
+      readonly issue: (
+        flowId: RequestBindingFlowId,
+      ) => Effect.Effect<
+        AuthOperationResult<RequestBindingPublic>,
+        RequestBindingUnavailable | RequestBindingInvalid
+      >;
+      readonly verify: (
+        flowId: RequestBindingFlowId,
+        credential: Redacted.Redacted<string>,
+      ) => Effect.Effect<VerifiedRequestBinding, RequestBindingInvalid | RequestBindingUnavailable>;
+    }
+  >(
+    `effect-auth/operations/RequestBinding/${moduleId.length}:${moduleId}/${purpose.length}:${purpose}`,
+  );
+
+  const signedLayer = (configuration: RequestBindingConfiguration) => {
+    if (!Schema.is(configurationSchema)(configuration))
+      return Layer.effect(RequestBinding, Effect.fail(RequestBindingConfigurationError.make({})));
+
+    const input = Object.freeze({
+      lifetimeMillis: configuration.lifetimeMillis,
+      generation: configuration.generation,
+      keyring: Object.freeze({
+        activeKeyId: configuration.keyring.activeKeyId,
+        keys: Object.freeze(
+          configuration.keyring.keys.map((entry) =>
+            Object.freeze({ id: entry.id, material: entry.material }),
+          ),
+        ),
+      }),
+    });
+
+    return Layer.effect(
+      RequestBinding,
+      Effect.gen(function* () {
+        yield* Schema.decodeEffect(label)(moduleId).pipe(
+          Effect.mapError(() => RequestBindingConfigurationError.make({})),
+        );
+        yield* Schema.decodeEffect(label)(purpose).pipe(
+          Effect.mapError(() => RequestBindingConfigurationError.make({})),
+        );
+
+        const policy = yield* Schema.decodeEffect(configurationSchema)(input).pipe(
+          Effect.mapError(() => RequestBindingConfigurationError.make({})),
+        );
+
+        const signer = yield* makeSessionSigningCodec(envelope, policy.keyring, 2048).pipe(
+          Effect.mapError(() => RequestBindingConfigurationError.make({})),
+        );
+
+        const crypto = yield* Crypto.Crypto;
+
+        return RequestBinding.of({
+          issue: Effect.fn("RequestBinding.issue")(function* (flowId) {
+            yield* Schema.decodeEffect(RequestBindingFlowId)(flowId).pipe(
+              Effect.mapError(() => RequestBindingInvalid.make({})),
+            );
+            const now = DateTime.toEpochMillis(yield* DateTime.now);
+
+            const nonce = yield* crypto
+              .randomBytes(32)
+              .pipe(Effect.mapError(() => RequestBindingUnavailable.make({})));
+
+            const expiresAtMillis = now + policy.lifetimeMillis;
+
+            const credential = yield* signer
+              .encode({
+                namespace: "effect-auth/request-binding/v1",
+                moduleId,
+                purpose,
+                flowId,
+                generation: policy.generation,
+                nonce: Encoding.encodeBase64Url(nonce),
+                issuedAtMillis: now,
+                expiresAtMillis,
+              })
+              .pipe(Effect.mapError(() => RequestBindingUnavailable.make({})));
+
+            return {
+              value: { flowId, expiresAtMillis },
+              credentialCommands: [
+                { _tag: "Issue", slot: "request-binding", credential, expiresAtMillis },
+              ],
+            };
+          }),
+          verify: Effect.fn("RequestBinding.verify")(function* (flowId, credential) {
+            yield* Schema.decodeEffect(RequestBindingFlowId)(flowId).pipe(
+              Effect.mapError(() => RequestBindingInvalid.make({})),
+            );
+
+            const value = yield* signer
+              .decode(credential)
+              .pipe(
+                Effect.mapError((error) =>
+                  error._tag === "SessionUnavailable"
+                    ? RequestBindingUnavailable.make({})
+                    : RequestBindingInvalid.make({}),
+                ),
+              );
+
+            const now = DateTime.toEpochMillis(yield* DateTime.now);
+
+            if (
+              value.moduleId !== moduleId ||
+              value.purpose !== purpose ||
+              value.flowId !== flowId ||
+              value.generation !== policy.generation ||
+              value.issuedAtMillis > now ||
+              value.expiresAtMillis <= now ||
+              value.expiresAtMillis <= value.issuedAtMillis ||
+              value.expiresAtMillis - value.issuedAtMillis > policy.lifetimeMillis
+            )
+              return yield* RequestBindingInvalid.make({});
+
+            const message = yield* Schema.encodeEffect(verifierMessage)([
+              "effect-auth/request-binding-verifier/v1",
+              moduleId,
+              purpose,
+              Redacted.value(credential),
+            ]).pipe(Effect.mapError(() => RequestBindingInvalid.make({})));
+
+            const digest = yield* crypto
+              .digest("SHA-256", new TextEncoder().encode(message))
+              .pipe(Effect.mapError(() => RequestBindingUnavailable.make({})));
+
+            // Entry verification deadline only. Final proof/action expiry is still
+            // enforced by the actual mutation owner; this is not a commit deadline.
+            return Object.freeze({
+              verifier: TokenDigest.make(Encoding.encodeBase64Url(digest)),
+              expiresAtMillis: value.expiresAtMillis,
+            });
+          }),
+        });
+      }),
+    );
+  };
+
+  const layer = Layer.unwrap(Effect.map(RequestBindingConfig, signedLayer));
+
+  return Object.freeze({ RequestBinding, signedLayer, layer });
+};

package/src/operations/requestBindingModels.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+
+export const RequestBindingFlowId = Schema.String.check(
+  Schema.isPattern(/^[A-Za-z0-9._:/-]{1,256}$/),
+).pipe(Schema.brand("effect-auth/RequestBindingFlowId"));
+
+export type RequestBindingFlowId = typeof RequestBindingFlowId.Type;
+
+export const RequestBindingCredential = Schema.RedactedFromValue(
+  Schema.String.check(Schema.isMaxLength(2048)),
+);
+
+export const RequestBindingPublic = Schema.Struct({
+  flowId: RequestBindingFlowId,
+  expiresAtMillis: Schema.Int,
+});
+
+export type RequestBindingPublic = typeof RequestBindingPublic.Type;

package/src/operations/reveals.ts

@@ -0,0 +1,147 @@
+import { type Effect, Predicate, Redacted, Schema } from "effect";
+
+export const AuthRevealKind = Schema.Literals(["totp-enrollment", "recovery-codes"]);
+export type AuthRevealKind = typeof AuthRevealKind.Type;
+
+const utf8 = new TextEncoder();
+
+const boundedText = (maximum: number) =>
+  Schema.NonEmptyString.check(
+    Schema.makeFilter(
+      (value) =>
+        value.length <= maximum &&
+        !/[\uD800-\uDFFF]/u.test(value) &&
+        utf8.encode(value).byteLength <= maximum,
+    ),
+  );
+
+const enrollment = Schema.Struct({
+  uri: boundedText(4096).check(
+    Schema.isPattern(/^otpauth:\/\/totp\//),
+    // oxlint-disable-next-line no-control-regex -- Private enrollment URIs must reject control characters.
+    Schema.isPattern(/^[^\u0000-\u001f\u007f-\u009f]*$/),
+  ),
+  manualKey: Schema.String.check(Schema.isPattern(/^[A-Z2-7]{32}$/)),
+});
+
+const recoveryCode = Schema.String.check(
+  Schema.isPattern(/^rc1-[A-F0-9]{8}-[A-F0-9]{8}-[A-F0-9]{8}-[A-F0-9]{8}$/),
+);
+
+const recovery = Schema.Array(recoveryCode).check(
+  Schema.isLengthBetween(10, 10),
+  Schema.makeFilter((codes) => new Set(codes).size === codes.length),
+);
+
+const fields = {
+  revealId: boundedText(256),
+  expiresAtMillis: Schema.Int.check(
+    Schema.isBetween({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+  ),
+};
+
+/** Private display data. Never use this schema as an operation's ordinary success. */
+export const AuthRevealCommand = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("totp-enrollment"),
+    ...fields,
+    payload: Schema.Redacted(enrollment, { disallowJsonEncode: true }),
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("recovery-codes"),
+    ...fields,
+    payload: Schema.Redacted(recovery, { disallowJsonEncode: true }),
+  }),
+]);
+
+export type AuthRevealCommand = typeof AuthRevealCommand.Type;
+
+/** Request-local memory acceptance. Invoked without a receiver; not physical delivery. */
+export interface AuthRevealCommandCollector {
+  readonly supportedKinds: ReadonlyArray<AuthRevealKind>;
+  readonly accept: (commands: ReadonlyArray<AuthRevealCommand>) => Effect.Effect<void>;
+}
+
+const decodeKinds = Schema.decodeSync(Schema.Array(AuthRevealKind));
+// oxlint-disable-next-line no-restricted-properties -- Provider output is captured as unknown before validating this closed private boundary.
+const decodeCommand = Schema.decodeUnknownSync(AuthRevealCommand);
+const invalid = () => new globalThis.Error("Auth operation failed");
+
+/** Package-private: do not expose the snapshot mechanics through the public barrel. */
+export const snapshotRevealKinds = (input: ReadonlyArray<AuthRevealKind>) => {
+  if (!Array.isArray(input)) throw invalid();
+  const length = input.length;
+
+  if (!Number.isInteger(length) || length < 0 || length > 2) throw invalid();
+  const captured = [];
+
+  for (let index = 0; index < length; index++) captured.push(input[index]);
+  const kinds = decodeKinds(captured);
+
+  if (new Set(kinds).size !== kinds.length) throw invalid();
+
+  return Object.freeze([...kinds]);
+};
+
+/** Fully detach before a consumer's success Iso projection can suspend. */
+export const snapshotRevealCommands = (
+  input: ReadonlyArray<AuthRevealCommand> | undefined,
+  declared: ReadonlyArray<AuthRevealKind>,
+): ReadonlyArray<AuthRevealCommand> => {
+  if (input === undefined) return Object.freeze([]);
+  if (!Array.isArray(input)) throw invalid();
+  const length = input.length;
+
+  if (
+    !Number.isInteger(length) ||
+    length < 0 ||
+    length > 2 ||
+    (declared.length === 0 && length > 0)
+  )
+    throw invalid();
+  const kinds = new Set<AuthRevealKind>();
+  const ids = new Set<string>();
+  const commands: AuthRevealCommand[] = [];
+
+  for (let index = 0; index < length; index++) {
+    const command = input[index];
+    const kind = command.kind;
+    const revealId = command.revealId;
+    const expiresAtMillis = command.expiresAtMillis;
+    // Capture each caller-owned primitive once. Redacted's schema validates but
+    // preserves its wrapper, so validating the original would not detach it.
+    let payload: unknown;
+
+    if (kind === "totp-enrollment") {
+      const value = Redacted.value(command.payload);
+
+      if (!Predicate.isObject(value)) throw invalid();
+      payload = Object.freeze({ uri: value.uri, manualKey: value.manualKey });
+    } else if (kind === "recovery-codes") {
+      const source = Redacted.value(command.payload);
+
+      if (!Array.isArray(source) || source.length !== 10) throw invalid();
+      const codes: unknown[] = [];
+
+      for (let code = 0; code < 10; code++) codes.push(source[code]);
+      payload = Object.freeze(codes);
+    } else {
+      throw invalid();
+    }
+
+    const value = decodeCommand({
+      kind,
+      revealId,
+      expiresAtMillis,
+      payload: Redacted.make(payload, { label: "Auth reveal" }),
+    });
+
+    if (!declared.includes(value.kind) || kinds.has(value.kind) || ids.has(value.revealId))
+      throw invalid();
+    kinds.add(value.kind);
+    ids.add(value.revealId);
+    commands.push(Object.freeze(value));
+  }
+
+  return Object.freeze(commands);
+};

package/src/passkey/PasskeyActionEvidence.ts

@@ -0,0 +1,25 @@
+import { Context, type Effect, type Redacted } from "effect";
+
+import type { AuthInvocation } from "../operations/context";
+import type { AuthenticationEvidence, AuthenticationRequirement } from "../sessions/models";
+import type { PasskeyActionRequired, PasskeyUnavailable } from "./errors";
+import type { PasskeyActionChallenge } from "./models";
+
+/** Independent current action authority. Consume replay-sensitive input in its
+ * own authority; later enrollment/removal failure never refunds it. No default. */
+export class PasskeyActionEvidence extends Context.Service<
+  PasskeyActionEvidence,
+  {
+    readonly verify: (input: {
+      readonly invocation: AuthInvocation;
+      readonly challenge: PasskeyActionChallenge;
+      readonly proof?: Redacted.Redacted<string>;
+    }) => Effect.Effect<
+      {
+        readonly evidence: AuthenticationEvidence;
+        readonly requirement: AuthenticationRequirement;
+      },
+      PasskeyActionRequired | PasskeyUnavailable
+    >;
+  }
+>()("effect-auth/PasskeyActionEvidence") {}

package/src/passkey/PasskeyCredentials.ts

@@ -0,0 +1,16 @@
+import { Context, type Effect } from "effect";
+
+import type { PasskeyUnavailable } from "./errors";
+import type { PasskeyCredential, PasskeyProtocolCredentialId } from "./models";
+
+/** Minimum read capability. The tuple is RP-global across module/profile aliases;
+ * protocol ID and opaque handle never become application subject identifiers. */
+export class PasskeyCredentials extends Context.Service<
+  PasskeyCredentials,
+  {
+    readonly lookup: (input: {
+      readonly rpId: string;
+      readonly protocolCredentialId: PasskeyProtocolCredentialId;
+    }) => Effect.Effect<PasskeyCredential | undefined, PasskeyUnavailable>;
+  }
+>()("effect-auth/PasskeyCredentials") {}

package/src/passkey/PasskeyEnrollmentContext.ts

@@ -0,0 +1,26 @@
+import { Context, type Effect } from "effect";
+
+import type { SubjectId } from "../Schema";
+import type { PasskeyUnavailable } from "./errors";
+import type { PasskeyDescriptor, PasskeyRevision, PasskeyUserHandle } from "./models";
+
+/** Current active subject, original revisions and every same-RP exclusion. An
+ * absent handle is installed conditionally with issue, never by this read. */
+export class PasskeyEnrollmentContext extends Context.Service<
+  PasskeyEnrollmentContext,
+  {
+    readonly capture: (input: {
+      readonly moduleId: string;
+      readonly rpId: string;
+      readonly subjectId: SubjectId;
+    }) => Effect.Effect<
+      | {
+          readonly revision: typeof PasskeyRevision.Type;
+          readonly userHandle?: PasskeyUserHandle;
+          readonly credentials: ReadonlyArray<typeof PasskeyDescriptor.Type>;
+        }
+      | undefined,
+      PasskeyUnavailable
+    >;
+  }
+>()("effect-auth/PasskeyEnrollmentContext") {}

package/src/passkey/PasskeyManagementPersistence.ts

@@ -0,0 +1,124 @@
+import { Context, type Effect } from "effect";
+
+import type { PreparedCommit } from "../hooks/commit";
+import type { SubjectId } from "../Schema";
+import type { SessionInvalidationWindow } from "../sessions/invalidation";
+import type { PasskeyUnavailable } from "./errors";
+import type {
+  PasskeyActionAuthorization,
+  PasskeyCeremony,
+  PasskeyClaim,
+  PasskeyCredential,
+  PasskeyCredentialSummary,
+  PasskeyIssueDecision,
+  PasskeyRegistrationVerified,
+  PasskeyRemoved,
+} from "./models";
+import type { PreparePasskeyCommit } from "./PasskeyPersistence";
+import type { PasskeyManagementPolicy, PasskeyMethodPolicy } from "./policy";
+
+/** Optional same-owner composites. Global (rpId,id)/(rpId,handle) ownership spans
+ * all modules/profile aliases and unresolved registrations. No network or Claims. */
+export class PasskeyManagementPersistence extends Context.Service<
+  PasskeyManagementPersistence,
+  {
+    /** Active current metadata-access policy and ownership, including replay. */
+    readonly list: (input: {
+      readonly moduleId: string;
+      readonly subjectId: SubjectId;
+      readonly cursor?: string;
+      readonly limit: number;
+    }) => Effect.Effect<
+      { readonly credentials: ReadonlyArray<PasskeyCredentialSummary>; readonly cursor?: string },
+      PasskeyUnavailable
+    >;
+    /** Exact action authority, exclusion set, proposed existing/absent handle and
+     * credential cap + durable admission + Pending ceremony in one owner. */
+    readonly issueEnrollment: <A>(
+      input: {
+        readonly ceremony: PasskeyCeremony;
+        readonly policy: PasskeyMethodPolicy;
+        readonly management: PasskeyManagementPolicy;
+        readonly authorization: PasskeyActionAuthorization;
+      },
+      prepare: PreparePasskeyCommit<PasskeyIssueDecision, A>,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    /** Repeat original+current requirements and all revisions/freshness at final
+     * clock, exact claim/key/handle/RP/global uniqueness and count. Join credential,
+     * shared factor, subject revision, session/pending invalidation + terminal event.
+     * Enrollment never creates AuthenticationEvidence/session. Primary eligibility
+     * requires the persisted enrollment profile AND verified UV, never later promotion. */
+    readonly completeEnrollment: <A>(
+      input: {
+        readonly claim: PasskeyClaim;
+        readonly verified: PasskeyRegistrationVerified;
+        readonly authorization: PasskeyActionAuthorization;
+        readonly management: PasskeyManagementPolicy;
+        readonly invalidation: SessionInvalidationWindow;
+        readonly nowMillis: number;
+      },
+      prepare: PreparePasskeyCommit<
+        | { readonly _tag: "Enrolled"; readonly credential: PasskeyCredentialSummary }
+        | { readonly _tag: "Rejected" },
+        A
+      >,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    /** Authenticated exact command replay before fresh action input is consumed.
+     * Wrong command/subject/target reuse rejects; missing row never proves rollback. */
+    readonly inspectRemove: (input: {
+      readonly moduleId: string;
+      readonly subjectId: SubjectId;
+      readonly commandId: string;
+      readonly credentialId: string;
+    }) => Effect.Effect<
+      | { readonly _tag: "Target"; readonly credential: PasskeyCredential }
+      | { readonly _tag: "Replay"; readonly result: typeof PasskeyRemoved.Type }
+      | { readonly _tag: "Rejected" },
+      PasskeyUnavailable
+    >;
+    /** Current independent action authority and last usable primary/recovery/factor
+     * policy in SAME owner; factor-only and connected grants are not alternatives.
+     * Concurrent removals leave a usable path. Remove credential/shared factor,
+     * bump semantic+subject revisions, terminalize dependent ceremonies, invalidate
+     * under declared strategy, retain exact command. Repeat postconditions last. */
+    readonly remove: <A>(
+      input: {
+        readonly moduleId: string;
+        readonly commandId: string;
+        readonly credential: PasskeyCredential;
+        readonly authorization: PasskeyActionAuthorization;
+        readonly management: PasskeyManagementPolicy;
+        readonly invalidation: SessionInvalidationWindow;
+        readonly nowMillis: number;
+        readonly retentionUntilMillis: number;
+      },
+      prepare: PreparePasskeyCommit<
+        | { readonly _tag: "Removed"; readonly result: typeof PasskeyRemoved.Type }
+        | { readonly _tag: "Rejected" | "LastSignInMethod" },
+        A
+      >,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    /** Safe metadata only, no semantic revision bump. Current active owner/policy
+     * and exact original name/target on replay; conflicting command reuse rejects. */
+    readonly rename: <A>(
+      input: {
+        readonly moduleId: string;
+        readonly subjectId: SubjectId;
+        readonly commandId: string;
+        readonly credentialId: string;
+        readonly name: string;
+        readonly nowMillis: number;
+        readonly retentionUntilMillis: number;
+      },
+      prepare: PreparePasskeyCommit<
+        | {
+            readonly _tag: "Renamed";
+            readonly credential: PasskeyCredentialSummary;
+            readonly replayed: boolean;
+          }
+        | { readonly _tag: "Rejected" },
+        A
+      >,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+  }
+>()("effect-auth/PasskeyManagementPersistence") {}

package/src/passkey/PasskeyPersistence.ts

@@ -0,0 +1,85 @@
+import { Context, type Effect } from "effect";
+
+import type { CommitJournal, PreparedCommit } from "../hooks/commit";
+import type { PasskeyUnavailable } from "./errors";
+import type {
+  PasskeyAccess,
+  PasskeyAssertionVerified,
+  PasskeyCeremony,
+  PasskeyClaim,
+  PasskeyClaimDecision,
+  PasskeyCleanupResult,
+  PasskeyCredential,
+  PasskeyEvidence,
+  PasskeyIssueDecision,
+  PasskeySettlement,
+} from "./models";
+import type { PasskeyMethodPolicy } from "./policy";
+
+export type PreparePasskeyCommit<Value, A> = (
+  value: Value,
+  journal: CommitJournal,
+) => PreparedCommit<A>;
+
+/** Same-owner authority. Synchronous generic prepare precedes physical commit.
+ * Unknown/caught-child/rollback discards all receipts and events; no owner retry.
+ * Claim-before-verifier is mandatory. Nothing accepts raw response or bearer. */
+export class PasskeyPersistence extends Context.Service<
+  PasskeyPersistence,
+  {
+    /** Unique module/flow + command. Exact challenge, context and binder; durable
+     * global/subject/target rolling budgets and pending caps at authority time.
+     * Duplicate never returns old ceremony with a new binder. Retain charge windows. */
+    readonly issue: <A>(
+      input: { readonly ceremony: PasskeyCeremony; readonly policy: PasskeyMethodPolicy },
+      prepare: PreparePasskeyCommit<PasskeyIssueDecision, A>,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    readonly context: (
+      input: PasskeyAccess,
+    ) => Effect.Effect<PasskeyCeremony | undefined, PasskeyUnavailable>;
+    /** Recheck exact Pending/context/config/binder/current revisions/expiry and
+     * the immutable issue policy. Atomically charge the newly resolved subject
+     * for discoverable flows whose subject was unknown at issue; retain known
+     * subject/target issue charges through full physical rolling windows. Serialize
+     * the subject budget decision with claim so different flows cannot bypass it.
+     * Optional credential authority is captured before signature verification.
+     * One fixed claim; no takeover, lease renewal or return to Pending. */
+    readonly claim: <A>(
+      input: {
+        readonly access: PasskeyAccess;
+        readonly policy: PasskeyMethodPolicy;
+        readonly ceremony: PasskeyCeremony;
+        readonly claimId: string;
+        readonly credential?: PasskeyCredential;
+      },
+      prepare: PreparePasskeyCommit<PasskeyClaimDecision, A>,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    /** Every outcome terminalizes. Verified checks original active subject, full
+     * credential/key/profile/handle/BE and semantic revisions at final engine time.
+     * Single-device: zero/zero or strict positive increase against current counter.
+     * Multi-device: allow zero/reset/out-of-order; atomically merge max and BS without
+     * telemetry CAS rejecting another valid challenge. No semantic revision bump.
+     * Recheck all postconditions AFTER final writes; failures roll back everything. */
+    readonly settle: <A>(
+      input: {
+        readonly claim: PasskeyClaim;
+        readonly outcome:
+          | { readonly _tag: "Rejected" | "Ambiguous" }
+          | {
+              readonly _tag: "Assertion";
+              readonly credential: PasskeyCredential;
+              readonly assertion: PasskeyAssertionVerified;
+              readonly evidence: typeof PasskeyEvidence.Type;
+            };
+        readonly nowMillis: number;
+      },
+      prepare: PreparePasskeyCommit<PasskeySettlement, A>,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+    /** Expired Pending->Rejected, Claimed->Ambiguous, never reopen. Keep claim and
+     * charge/replay horizons and unresolved registration; bounded authority-time CAS. */
+    readonly cleanup: <A>(
+      input: { readonly moduleId: string; readonly nowMillis: number; readonly limit: number },
+      prepare: PreparePasskeyCommit<PasskeyCleanupResult, A>,
+    ) => Effect.Effect<PreparedCommit<A>, PasskeyUnavailable>;
+  }
+>()("effect-auth/PasskeyPersistence") {}