@yielded/auth-persistence 0.1.0-beta.7

package/src/drizzle/d1-oauth.ts

@@ -0,0 +1,340 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import {
+  OAuthAccountsPersistence,
+  OAuthRegistrationIntents,
+  OAuthSignInPersistence,
+  OAuthUnavailable,
+} from "@yielded/auth/OAuth";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { Effect, Context } from "effect";
+
+import { makeD1Owner } from "./d1-planning";
+import { D1BatchStatements } from "./D1BatchStatements";
+import type {
+  OAuthAccountsMapping,
+  OAuthD1Mapping,
+  OAuthRegistrationAuthority,
+  OAuthRegistrationIntentMapping,
+  OAuthRegistrationMapping,
+  OAuthSignInMapping,
+} from "./oauth-model";
+import {
+  type OAuthCoordinatorError,
+  coordinateTargetOAuthAccounts,
+  coordinateTargetOAuthSignIn,
+  coordinateTargetOAuthRegistrationIntents,
+  coordinateTargetOAuthRegistration,
+  makeTargetOAuthRegistrationIntentServices,
+  makeTargetOAuthRegistrationServices,
+  makeTargetOAuthSignInServices,
+  makeTargetOAuthAccountsServices,
+} from "./oauth-target";
+import type { SuppliedService } from "./SuppliedService";
+type SQLiteTable = AnySQLiteTable<{ dialect: "sqlite" }>;
+type Database = EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client };
+const unavailable = () => OAuthUnavailable.make({});
+
+const configuration = {
+  mode: "batch" as const,
+  dialect: "sqlite" as const,
+  locking: false,
+  standaloneGuard: () => Effect.void,
+};
+
+export const makeD1OAuthAccountsServices = <
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  T extends SQLiteTable,
+  U extends SQLiteTable,
+  N,
+>(
+  database: Database,
+  mapping: OAuthAccountsMapping<S, O, C, AC, F, T, U, N> & OAuthD1Mapping,
+) => makeTargetOAuthAccountsServices(database, mapping, configuration);
+
+export const makeD1OAuthSignInServices = <
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  N,
+>(
+  database: Database,
+  mapping: OAuthSignInMapping<S, O, C, AC, F, N> & OAuthD1Mapping,
+) => makeTargetOAuthSignInServices(database, mapping, configuration);
+
+export const makeD1OAuthRegistrationIntentServices = <
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  T extends SQLiteTable,
+  I extends SQLiteTable,
+  N,
+>(
+  database: Database,
+  mapping: OAuthRegistrationIntentMapping<S, O, C, AC, F, T, I, N> & OAuthD1Mapping,
+) => makeTargetOAuthRegistrationIntentServices(database, mapping, configuration);
+
+export const makeD1OAuthRegistrationServices = <
+  Registration,
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  T extends SQLiteTable,
+  I extends SQLiteTable,
+  R extends SQLiteTable,
+  N,
+>(
+  database: Database,
+  mapping: OAuthRegistrationMapping<Registration, S, O, C, AC, T, I, R, N> & OAuthD1Mapping,
+) => makeTargetOAuthRegistrationServices<Registration>(database, mapping, configuration);
+
+export function coordinateD1OAuthSignIn<
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  N,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+  options: { readonly mapping: OAuthSignInMapping<S, O, C, AC, F, N> & OAuthD1Mapping },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  OAuthCoordinatorError<E> | DatabaseError,
+  Exclude<R, OAuthSignInPersistence | D1BatchStatements> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetOAuthSignIn<
+      never,
+      A,
+      E | OAuthUnavailable,
+      Exclude<R, OAuthSignInPersistence | D1BatchStatements>
+    >(database, options.mapping, configuration, (_transaction, services, append) =>
+      Effect.gen(function* () {
+        const nativeCollector = D1BatchStatements.of({
+          append: (statement) => Effect.sync(() => append(statement)),
+        });
+
+        const owner = yield* makeD1Owner(unavailable()).pipe(
+          Effect.provideService(D1BatchStatements, nativeCollector),
+        );
+
+        const original = services.oauthSignInPersistence;
+
+        const service: OAuthSignInPersistence["Service"] = {
+          issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+          claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+          settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+          cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+        };
+
+        const provided = Context.make(OAuthSignInPersistence, service).pipe(
+          Context.add(D1BatchStatements, owner.collector),
+        );
+
+        return yield* owner.close(Effect.provideContext(body, provided));
+      }),
+    ),
+  );
+}
+
+export function coordinateD1OAuthRegistrationIntents<
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  T extends SQLiteTable,
+  I extends SQLiteTable,
+  N,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: OAuthRegistrationIntentMapping<S, O, C, AC, F, T, I, N> & OAuthD1Mapping;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  OAuthCoordinatorError<E> | DatabaseError,
+  Exclude<R, OAuthRegistrationIntents | D1BatchStatements> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetOAuthRegistrationIntents<
+      never,
+      A,
+      E | OAuthUnavailable,
+      Exclude<R, OAuthRegistrationIntents | D1BatchStatements>
+    >(database, options.mapping, configuration, (_transaction, services, append) =>
+      Effect.gen(function* () {
+        const nativeCollector = D1BatchStatements.of({
+          append: (statement) => Effect.sync(() => append(statement)),
+        });
+
+        const owner = yield* makeD1Owner(unavailable()).pipe(
+          Effect.provideService(D1BatchStatements, nativeCollector),
+        );
+
+        const original = services.oauthRegistrationIntents;
+
+        const service: OAuthRegistrationIntents["Service"] = {
+          settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+        };
+
+        const provided = Context.make(OAuthRegistrationIntents, service).pipe(
+          Context.add(D1BatchStatements, owner.collector),
+        );
+
+        return yield* owner.close(Effect.provideContext(body, provided));
+      }),
+    ),
+  );
+}
+
+export function coordinateD1OAuthAccounts<
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  F extends SQLiteTable,
+  T extends SQLiteTable,
+  U extends SQLiteTable,
+  N,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+  options: { readonly mapping: OAuthAccountsMapping<S, O, C, AC, F, T, U, N> & OAuthD1Mapping },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  OAuthCoordinatorError<E> | DatabaseError,
+  Exclude<R, OAuthAccountsPersistence | D1BatchStatements> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetOAuthAccounts<
+      never,
+      A,
+      E | OAuthUnavailable,
+      Exclude<R, OAuthAccountsPersistence | D1BatchStatements>
+    >(database, options.mapping, configuration, (_transaction, services, append) =>
+      Effect.gen(function* () {
+        const nativeCollector = D1BatchStatements.of({
+          append: (statement) => Effect.sync(() => append(statement)),
+        });
+
+        const owner = yield* makeD1Owner(unavailable()).pipe(
+          Effect.provideService(D1BatchStatements, nativeCollector),
+        );
+
+        const original = services.oauthAccountsPersistence;
+
+        const service: OAuthAccountsPersistence["Service"] = {
+          capture: (input) => owner.run(original.capture(input)),
+          issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+          preflight: (input) => owner.run(original.preflight(input)),
+          claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+          settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+          inspectUnlink: (input) => owner.run(original.inspectUnlink(input)),
+          unlink: (input, prepare) => owner.run(original.unlink(input, prepare)),
+          cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+        };
+
+        const provided = Context.make(OAuthAccountsPersistence, service).pipe(
+          Context.add(D1BatchStatements, owner.collector),
+        );
+
+        return yield* owner.close(Effect.provideContext(body, provided));
+      }),
+    ),
+  );
+}
+
+export function coordinateD1OAuthRegistration<
+  TargetId,
+  Registration,
+  S extends SQLiteTable,
+  O extends SQLiteTable,
+  C extends SQLiteTable,
+  AC extends SQLiteTable,
+  T extends SQLiteTable,
+  I extends SQLiteTable,
+  Rq extends SQLiteTable,
+  N,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: OAuthRegistrationMapping<NoInfer<Registration>, S, O, C, AC, T, I, Rq, N> &
+      OAuthD1Mapping;
+    readonly target: SuppliedService<TargetId, OAuthRegistrationAuthority<Registration>>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  OAuthCoordinatorError<E> | DatabaseError,
+  Exclude<R, TargetId | D1BatchStatements> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetOAuthRegistration<
+      Registration,
+      never,
+      A,
+      E | OAuthUnavailable,
+      Exclude<R, TargetId | D1BatchStatements>
+    >(database, options.mapping, configuration, (_transaction, services, append) =>
+      Effect.gen(function* () {
+        const nativeCollector = D1BatchStatements.of({
+          append: (statement) => Effect.sync(() => append(statement)),
+        });
+
+        const owner = yield* makeD1Owner(unavailable()).pipe(
+          Effect.provideService(D1BatchStatements, nativeCollector),
+        );
+
+        const original = services.registrationAuthority;
+
+        const service: OAuthRegistrationAuthority<Registration> = {
+          read: (input) => owner.run(original.read(input)),
+          inspect: (input) => owner.run(original.inspect(input)),
+          register: (input, prepare) => owner.run(original.register(input, prepare)),
+          cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+        };
+
+        const provided = Context.make(options.target, service).pipe(
+          Context.add(D1BatchStatements, owner.collector),
+        );
+
+        return yield* owner.close(Effect.provideContext(body, provided));
+      }),
+    ),
+  );
+}

package/src/drizzle/d1-passkey.ts

@@ -0,0 +1,373 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import {
+  PasskeyUnavailable,
+  PasskeyPersistence,
+  PasskeyManagementPersistence,
+} from "@yielded/auth/Passkey";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { Effect, Context } from "effect";
+
+import { makeD1Owner } from "./d1-planning";
+import { D1BatchStatements } from "./D1BatchStatements";
+import { makePasskeyTarget } from "./passkey-drivers";
+import type {
+  D1PasskeyMapping,
+  PasskeyCredentialMapping,
+  PasskeyMappingSource,
+  PasskeyPersistenceMapping,
+} from "./passkey-model";
+import type { PasskeyRegistrationCeremonyMapping } from "./passkey-registration-ceremony-model";
+import {
+  type PasskeyCoordinatorError,
+  coordinateTargetPasskey,
+  coordinateTargetPasskeyRegistration,
+} from "./passkey-target";
+
+type Table = AnySQLiteTable<{ dialect: "sqlite" }>;
+type Database = EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client };
+
+const unavailable = () => PasskeyUnavailable.make({});
+
+const configuration = {
+  mode: "batch" as const,
+  dialect: "sqlite" as const,
+  locking: false,
+  standaloneGuard: () => Effect.void,
+};
+
+const target = makePasskeyTarget<Database, Table, D1PasskeyMapping>(configuration);
+
+export const {
+  makePasskeyCredentialServices,
+  makePasskeyEnrollmentContextServices,
+  makePasskeyPersistenceServices,
+  makePasskeyRegistrationCeremonyServices,
+  makePasskeyManagementServices,
+  makePasskeyRegistrationServices,
+} = target;
+
+export function coordinatePasskeyPersistence<
+  D extends Database,
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  M extends Table,
+  Flow extends Table,
+  Admission extends Table,
+  Charge extends Table,
+  N,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasskeyMappingSource<
+      PasskeyPersistenceMapping<
+        PasskeyCredentialMapping<S, C, F, O, H, N>,
+        M,
+        Flow,
+        Admission,
+        Charge,
+        N
+      > &
+        D1PasskeyMapping,
+      RSetup
+    >;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  PasskeyCoordinatorError<E> | DatabaseError,
+  | Exclude<R, PasskeyPersistence | D1BatchStatements>
+  | LifecycleHooks
+  | DatabaseRequirements
+  | RSetup
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasskey(database, options.mapping, configuration, (_, services, append) =>
+      Effect.gen(function* () {
+        const original = services.passkeyPersistence;
+
+        const nativeCollector = D1BatchStatements.of({
+          append: (statement) => Effect.sync(() => append(statement)),
+        });
+
+        const owner = yield* makeD1Owner(unavailable()).pipe(
+          Effect.provideService(D1BatchStatements, nativeCollector),
+        );
+
+        const service: PasskeyPersistence["Service"] = {
+          issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+          context: (input) => owner.run(original.context(input)),
+          claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+          settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+          cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+        };
+
+        const provided = Context.make(PasskeyPersistence, service).pipe(
+          Context.add(D1BatchStatements, owner.collector),
+        );
+
+        return yield* owner.close(Effect.provideContext(body, provided));
+      }),
+    ),
+  );
+}
+
+export function coordinatePasskeyRegistrationCeremony<
+  D extends Database,
+  M extends Table,
+  Flow extends Table,
+  Admission extends Table,
+  Charge extends Table,
+  Intent extends Table,
+  H extends Table,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasskeyMappingSource<
+      PasskeyRegistrationCeremonyMapping<M, Flow, Admission, Charge, Intent, H> & D1PasskeyMapping,
+      RSetup
+    >;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  PasskeyCoordinatorError<E> | DatabaseError,
+  | Exclude<R, PasskeyPersistence | D1BatchStatements>
+  | LifecycleHooks
+  | DatabaseRequirements
+  | RSetup
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasskeyRegistration(
+      database,
+      options.mapping,
+      configuration,
+      (_, services, append) =>
+        Effect.gen(function* () {
+          const original = services.passkeyPersistence;
+
+          const nativeCollector = D1BatchStatements.of({
+            append: (statement) => Effect.sync(() => append(statement)),
+          });
+
+          const owner = yield* makeD1Owner(unavailable()).pipe(
+            Effect.provideService(D1BatchStatements, nativeCollector),
+          );
+
+          const service: PasskeyPersistence["Service"] = {
+            issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+            context: (input) => owner.run(original.context(input)),
+            claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+            settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+            cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+          };
+
+          const provided = Context.make(PasskeyPersistence, service).pipe(
+            Context.add(D1BatchStatements, owner.collector),
+          );
+
+          return yield* owner.close(Effect.provideContext(body, provided));
+        }),
+    ),
+  );
+}
+
+import type {
+  PasskeyManagementMapping,
+  PasskeyRegistrationMapping,
+  PasskeyRegistrationServices,
+  PasskeyRegistrationWriter,
+} from "./passkey-write-model";
+import {
+  coordinateTargetPasskeyManagement,
+  coordinateTargetPasskeyRegistrationWriter,
+} from "./passkey-write-target";
+
+export function coordinatePasskeyManagement<
+  D extends Database,
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  M extends Table,
+  Flow extends Table,
+  Admission extends Table,
+  Charge extends Table,
+  Command extends Table,
+  N,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasskeyMappingSource<
+      PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> &
+        D1PasskeyMapping,
+      RSetup
+    >;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  PasskeyCoordinatorError<E> | DatabaseError,
+  | Exclude<R, PasskeyPersistence | PasskeyManagementPersistence | D1BatchStatements>
+  | LifecycleHooks
+  | DatabaseRequirements
+  | RSetup
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasskeyManagement(
+      database,
+      options.mapping,
+      configuration,
+      (_, services, append) =>
+        Effect.gen(function* () {
+          const collector = D1BatchStatements.of({
+            append: (statement) => Effect.sync(() => append(statement)),
+          });
+
+          const owner = yield* makeD1Owner(unavailable()).pipe(
+            Effect.provideService(D1BatchStatements, collector),
+          );
+
+          const original = services.passkeyPersistence;
+
+          const persistence: PasskeyPersistence["Service"] = {
+            issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+            context: (input) => owner.run(original.context(input)),
+            claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+            settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+            cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+          };
+
+          const authority = services.passkeyManagementPersistence;
+
+          const service: PasskeyManagementPersistence["Service"] = {
+            list: (input) => owner.run(authority.list(input)),
+            inspectRemove: (input) => owner.run(authority.inspectRemove(input)),
+            issueEnrollment: (input, prepare) =>
+              owner.run(authority.issueEnrollment(input, prepare)),
+            completeEnrollment: (input, prepare) =>
+              owner.run(authority.completeEnrollment(input, prepare)),
+            rename: (input, prepare) => owner.run(authority.rename(input, prepare)),
+            remove: (input, prepare) => owner.run(authority.remove(input, prepare)),
+          };
+
+          const context = Context.make(PasskeyPersistence, persistence).pipe(
+            Context.add(PasskeyManagementPersistence, service),
+            Context.add(D1BatchStatements, owner.collector),
+          );
+
+          return yield* owner.close(Effect.provideContext(body, context));
+        }),
+    ),
+  );
+}
+
+export function coordinatePasskeyRegistration<
+  D extends Database,
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  M extends Table,
+  Flow extends Table,
+  Admission extends Table,
+  Charge extends Table,
+  Intent extends Table,
+  N,
+  Value,
+  AuthorityId,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasskeyMappingSource<
+      PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+        D1PasskeyMapping,
+      RSetup
+    >;
+    readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  PasskeyCoordinatorError<E> | DatabaseError,
+  | Exclude<R, PasskeyPersistence | AuthorityId | D1BatchStatements>
+  | LifecycleHooks
+  | DatabaseRequirements
+  | RSetup
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasskeyRegistrationWriter(
+      database,
+      options.mapping,
+      configuration,
+      (_, services: PasskeyRegistrationServices<Value>, append) =>
+        Effect.gen(function* () {
+          const collector = D1BatchStatements.of({
+            append: (statement) => Effect.sync(() => append(statement)),
+          });
+
+          const owner = yield* makeD1Owner(unavailable()).pipe(
+            Effect.provideService(D1BatchStatements, collector),
+          );
+
+          const original = services.passkeyPersistence;
+
+          const persistence: PasskeyPersistence["Service"] = {
+            issue: (input, prepare) => owner.run(original.issue(input, prepare)),
+            context: (input) => owner.run(original.context(input)),
+            claim: (input, prepare) => owner.run(original.claim(input, prepare)),
+            settle: (input, prepare) => owner.run(original.settle(input, prepare)),
+            cleanup: (input, prepare) => owner.run(original.cleanup(input, prepare)),
+          };
+
+          const authority = services.passkeyRegistrationAuthority;
+
+          const service: PasskeyRegistrationWriter<Value> = {
+            inspect: (input) => owner.run(authority.inspect(input)),
+            issueRegistration: (input, prepare) =>
+              owner.run(authority.issueRegistration(input, prepare)),
+            completeRegistration: (input, prepare) =>
+              owner.run(authority.completeRegistration(input, prepare)),
+          };
+
+          const context = Context.make(PasskeyPersistence, persistence).pipe(
+            Context.add(options.authority, service),
+            Context.add(D1BatchStatements, owner.collector),
+          );
+
+          return yield* owner.close(Effect.provideContext(body, context));
+        }),
+    ),
+  );
+}