@yielded/auth-persistence-drizzle 0.1.0-beta.25 → 0.1.0-beta.26

package/src/drizzle/passkey-write-drivers.ts

@@ -1,23 +1,23 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { LifecycleHooks } from "@yielded/auth/Hooks";
 import { PasskeyManagementPersistence, PasskeyPersistence } from "@yielded/auth/Passkey";
 import type { Table } from "drizzle-orm";
 import { type Crypto, Context, Effect } from "effect";
 
-import { nativeDatabase } from "./native-database";
+import type { D1BatchStatements } from "./D1BatchStatements";
+import { NativeDatabase, nativeDatabase } from "./native-database";
 import type { PasskeyMappingSource } from "./passkey-model";
-import type { PasskeyCoordinatorError, PasskeyTargetConfiguration } from "./passkey-target";
 import type {
   PasskeyManagementMapping,
   PasskeyRegistrationMapping,
   PasskeyRegistrationWriter,
 } from "./passkey-write-model";
+import type { PasskeyCoordinatorError, PasskeyTargetConfiguration } from "./passkey/target";
 import {
   coordinateTargetPasskeyManagement,
   coordinateTargetPasskeyRegistrationWriter,
   makeTargetPasskeyManagement,
   makeTargetPasskeyRegistrationWriter,
-} from "./passkey-write-target";
+} from "./passkey/write-target";
 import type { SuppliedService } from "./SuppliedService";
 // oxlint-disable-next-line no-explicit-any -- inspect the installed concrete transaction callback.
 type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => any }
@@ -29,7 +29,7 @@ export const makePasskeyWriteTarget = <
   D,
   T extends Table,
   Extra = unknown,
-  Synchronous extends boolean = false,
+  Provided extends D1BatchStatements = never,
 >(
   databaseService: Context.Service<DatabaseId, D>,
   configuration: PasskeyTargetConfiguration,
@@ -39,13 +39,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Command extends T,
     N,
     A,
     E,
@@ -57,22 +51,16 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        PasskeyManagementMapping<S, C, F, Flow, N> & Extra,
         RSetup
       >;
       readonly transaction?: never;
     },
-    body: Effect.Effect<
-      A,
-      E,
-      Synchronous extends true ? NoInfer<PasskeyPersistence | PasskeyManagementPersistence> : R
-    >,
+    body: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
     PasskeyCoordinatorError<E> | DatabaseError,
-    | (Synchronous extends true
-        ? never
-        : Exclude<R, PasskeyPersistence | PasskeyManagementPersistence>)
+    | Exclude<R, PasskeyPersistence | PasskeyManagementPersistence | Provided>
     | Crypto.Crypto
     | LifecycleHooks
     | RSetup
@@ -83,13 +71,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Command extends T,
     N,
     A,
     E,
@@ -103,24 +85,20 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        PasskeyManagementMapping<S, C, F, Flow, N> & Extra,
         RSetup
       >;
-      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<[Provided] extends [never] ? TransactionOf<Database> : never>,
+        TxShape
+      >;
     },
-    body: Effect.Effect<
-      A,
-      E,
-      Synchronous extends true
-        ? NoInfer<PasskeyPersistence | PasskeyManagementPersistence | TxId>
-        : R
-    >,
+    body: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
     PasskeyCoordinatorError<E> | DatabaseError,
-    | (Synchronous extends true
-        ? never
-        : Exclude<R, PasskeyPersistence | PasskeyManagementPersistence | TxId>)
+    | Exclude<R, PasskeyPersistence | PasskeyManagementPersistence | TxId | Provided>
     | Crypto.Crypto
     | LifecycleHooks
     | RSetup
@@ -131,13 +109,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Command extends T,
     N,
     A,
     E,
@@ -151,7 +123,7 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        PasskeyManagementMapping<S, C, F, Flow, N> & Extra,
         RSetup
       >;
       readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
@@ -193,20 +165,11 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Command extends T,
     N,
     RSetup = never,
   >(
-    mapping: PasskeyMappingSource<
-      PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
-      RSetup
-    >,
+    mapping: PasskeyMappingSource<PasskeyManagementMapping<S, C, F, Flow, N> & Extra, RSetup>,
   ) =>
     makeTargetPasskeyManagement(mapping, configuration).pipe(
       Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
@@ -217,13 +180,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Intent extends T,
     N,
     Value,
     A,
@@ -237,22 +194,17 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
-          Extra,
+        PasskeyRegistrationMapping<S, C, F, Flow, N, Value> & Extra,
         RSetup
       >;
       readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
       readonly transaction?: never;
     },
-    body: Effect.Effect<
-      A,
-      E,
-      Synchronous extends true ? NoInfer<PasskeyPersistence | AuthorityId> : R
-    >,
+    body: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
     PasskeyCoordinatorError<E> | DatabaseError,
-    | (Synchronous extends true ? never : Exclude<R, PasskeyPersistence | AuthorityId>)
+    | Exclude<R, PasskeyPersistence | AuthorityId | Provided>
     | Crypto.Crypto
     | LifecycleHooks
     | RSetup
@@ -263,13 +215,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Intent extends T,
     N,
     Value,
     A,
@@ -285,22 +231,21 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
-          Extra,
+        PasskeyRegistrationMapping<S, C, F, Flow, N, Value> & Extra,
         RSetup
       >;
       readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
-      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<[Provided] extends [never] ? TransactionOf<Database> : never>,
+        TxShape
+      >;
     },
-    body: Effect.Effect<
-      A,
-      E,
-      Synchronous extends true ? NoInfer<PasskeyPersistence | AuthorityId | TxId> : R
-    >,
+    body: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
     PasskeyCoordinatorError<E> | DatabaseError,
-    | (Synchronous extends true ? never : Exclude<R, PasskeyPersistence | AuthorityId | TxId>)
+    | Exclude<R, PasskeyPersistence | AuthorityId | TxId | Provided>
     | Crypto.Crypto
     | LifecycleHooks
     | RSetup
@@ -311,13 +256,7 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Intent extends T,
     N,
     Value,
     A,
@@ -333,8 +272,7 @@ export const makePasskeyWriteTarget = <
     acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
     options: {
       readonly mapping: PasskeyMappingSource<
-        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
-          Extra,
+        PasskeyRegistrationMapping<S, C, F, Flow, N, Value> & Extra,
         RSetup
       >;
       readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
@@ -377,26 +315,18 @@ export const makePasskeyWriteTarget = <
     S extends T,
     C extends T,
     F extends T,
-    O extends T,
-    H extends T,
-    M extends T,
     Flow extends T,
-    Admission extends T,
-    Charge extends T,
-    Intent extends T,
     N,
     Value,
     RSetup = never,
   >(
     mapping: PasskeyMappingSource<
-      PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
-        Extra,
+      PasskeyRegistrationMapping<S, C, F, Flow, N, Value> & Extra,
       RSetup
     >,
   ) =>
     makeTargetPasskeyRegistrationWriter<
-      PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
-        Extra,
+      PasskeyRegistrationMapping<S, C, F, Flow, N, Value> & Extra,
       Value,
       RSetup
     >(mapping, configuration).pipe(

package/src/drizzle/passkey-write-model.ts

@@ -1,74 +1,52 @@
 import * as Shared from "@yielded/auth-persistence/Adapter";
-import type { InferInsertModel, SQL, Table } from "drizzle-orm";
+import type { SQL, Table } from "drizzle-orm";
 
 import type { DrizzleTableModel } from "./table-model";
 
-export {
-  type PasskeyCredentialInsert,
-  type PasskeyInvalidationInput,
-  requiredPasskeyManagementConstraints,
-  type PasskeyManagementServices,
-  type PasskeyRegistrationWriter,
-  type PasskeyRegistrationServices,
-  requiredPasskeyRegistrationWriteConstraints,
+export type {
+  PasskeyCredentialInsert,
+  PasskeyInvalidationInput,
+  PasskeyManagementServices,
+  PasskeyRegistrationWriter,
+  PasskeyRegistrationServices,
 } from "@yielded/auth-persistence/Adapter";
 
 export type PasskeyWriteTables<
   S extends Table,
   C extends Table,
   F extends Table,
-  O extends Table,
-  H extends Table,
   N,
 > = Shared.PasskeyWriteTables<
   DrizzleTableModel<S>,
   DrizzleTableModel<C>,
   DrizzleTableModel<F>,
-  DrizzleTableModel<O>,
-  DrizzleTableModel<H>,
   N,
   SQL
 >;
 
 export type PasskeyInvalidationMutation<N> = Shared.PasskeyInvalidationMutation<N, SQL>;
 
-/** Same-owner updates for consumer session/pending tables. No external effects or callbacks after commit. */
 export const passkeyInvalidationMutation = <T extends Table, N>(input: {
   readonly table: T;
   readonly where: (input: Shared.PasskeyInvalidationInput<N>) => SQL;
-  readonly values: (input: Shared.PasskeyInvalidationInput<N>) => Partial<InferInsertModel<T>>;
+  readonly values: (
+    input: Shared.PasskeyInvalidationInput<N>,
+  ) => Partial<DrizzleTableModel<T>["insert"]>;
   readonly postcondition: (input: Shared.PasskeyInvalidationInput<N>) => SQL;
 }): PasskeyInvalidationMutation<N> =>
   Shared.passkeyInvalidationMutation<DrizzleTableModel<T>, N, SQL>(input);
 
-export type PasskeyCommandTable<T extends Table, N> = Shared.PasskeyCommandTable<
-  DrizzleTableModel<T>,
-  N
->;
-
 export type PasskeyManagementMapping<
   S extends Table,
   C extends Table,
   F extends Table,
-  O extends Table,
-  H extends Table,
-  M extends Table,
   Flow extends Table,
-  A extends Table,
-  Charge extends Table,
-  Command extends Table,
   N,
 > = Shared.PasskeyManagementMapping<
   DrizzleTableModel<S>,
   DrizzleTableModel<C>,
   DrizzleTableModel<F>,
-  DrizzleTableModel<O>,
-  DrizzleTableModel<H>,
-  DrizzleTableModel<M>,
   DrizzleTableModel<Flow>,
-  DrizzleTableModel<A>,
-  DrizzleTableModel<Charge>,
-  DrizzleTableModel<Command>,
   N,
   SQL
 >;
@@ -77,26 +55,14 @@ export type PasskeyRegistrationMapping<
   S extends Table,
   C extends Table,
   F extends Table,
-  O extends Table,
-  H extends Table,
-  M extends Table,
   Flow extends Table,
-  A extends Table,
-  Charge extends Table,
-  Intent extends Table,
   N,
   R,
 > = Shared.PasskeyRegistrationMapping<
   DrizzleTableModel<S>,
   DrizzleTableModel<C>,
   DrizzleTableModel<F>,
-  DrizzleTableModel<O>,
-  DrizzleTableModel<H>,
-  DrizzleTableModel<M>,
   DrizzleTableModel<Flow>,
-  DrizzleTableModel<A>,
-  DrizzleTableModel<Charge>,
-  DrizzleTableModel<Intent>,
   N,
   R,
   SQL

package/src/drizzle/password-drivers.ts

@@ -0,0 +1,286 @@
+import type { PasswordRegistrationAuthority } from "@yielded/auth-persistence/Adapter";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasswordPersistence, type PasswordUnavailable } from "@yielded/auth/Password";
+import type { Table } from "drizzle-orm";
+import { type Context, Effect, type Crypto } from "effect";
+
+import type { NativeDriverDatabase, NativeDriverTransaction } from "./driver-types";
+import { NativeDatabase, nativeDatabase } from "./native-database";
+import type { NativeTargetConfiguration } from "./native-target";
+import type {
+  AnyPasswordPersistenceMapping,
+  AnyPasswordRegistrationMapping,
+  PasswordPersistenceMapping,
+  PasswordRegistrationMapping,
+} from "./password-model";
+import {
+  coordinateTargetPasswordPersistence,
+  coordinateTargetPasswordRegistration,
+  makeTargetPasswordPersistenceServices,
+  makeTargetPasswordRegistrationServices,
+} from "./password-target";
+import type { AnyProofPersistenceMapping, ProofPersistenceMapping } from "./proof-model";
+import type { SuppliedService } from "./SuppliedService";
+
+type ProofOption<Proof extends Table, Subject extends Table, NativeId> = {
+  readonly proofMapping?: ProofPersistenceMapping<Proof, Subject, NativeId>;
+};
+
+/** Foreign table callback variance is erased only after these public signatures;
+ * the target validates physical metadata and the workflow invokes row codecs. */
+export const makePasswordTarget = <DatabaseId, D extends NativeDriverDatabase>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration: NativeTargetConfiguration,
+) => {
+  function coordinatePasswordPersistence<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordPersistenceMapping<S, I, C, AC, N>;
+      readonly transaction?: never;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | PasswordUnavailable,
+    Exclude<R, PasswordPersistence> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinatePasswordPersistence<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordPersistenceMapping<S, I, C, AC, N>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | PasswordUnavailable,
+    Exclude<R, PasswordPersistence | TxId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinatePasswordPersistence<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordPersistenceMapping<S, I, C, AC, N>;
+      readonly transaction?: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ) {
+    return Effect.flatMap(nativeDatabase(acquire), (database) =>
+      coordinateTargetPasswordPersistence(
+        database,
+        options.mapping as unknown as AnyPasswordPersistenceMapping,
+        configuration,
+        (transaction: NativeDriverTransaction<Database>, services) => {
+          const work = Effect.provideService(
+            body,
+            PasswordPersistence,
+            services.passwordPersistence,
+          );
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+        options.proofMapping as unknown as AnyProofPersistenceMapping | undefined,
+      ),
+    );
+  }
+
+  function coordinatePasswordRegistration<
+    TargetId,
+    Registration,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | PasswordUnavailable,
+    Exclude<R, TargetId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinatePasswordRegistration<
+    TargetId,
+    Registration,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | PasswordUnavailable,
+    Exclude<R, TargetId | TxId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinatePasswordRegistration<
+    TargetId,
+    Registration,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+      readonly transaction?: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    },
+    body: Effect.Effect<A, E, R>,
+  ) {
+    return Effect.flatMap(nativeDatabase(acquire), (database) =>
+      coordinateTargetPasswordRegistration(
+        database,
+        options.mapping as unknown as AnyPasswordRegistrationMapping<Registration>,
+        configuration,
+        (transaction: NativeDriverTransaction<Database>, services) => {
+          const work = Effect.provideService(body, options.target, services.registrationAuthority);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+
+  return {
+    makePasswordPersistenceServices: <
+      S extends Table,
+      I extends Table,
+      C extends Table,
+      AC extends Table,
+      N,
+      Proof extends Table,
+      PS extends Table,
+      PN,
+    >(
+      mapping: PasswordPersistenceMapping<S, I, C, AC, N>,
+      proofMapping?: ProofPersistenceMapping<Proof, PS, PN>,
+    ) =>
+      makeTargetPasswordPersistenceServices(
+        mapping as unknown as AnyPasswordPersistenceMapping,
+        configuration,
+        proofMapping as unknown as AnyProofPersistenceMapping | undefined,
+      ).pipe(Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService))),
+    makePasswordRegistrationServices: <
+      Registration,
+      S extends Table,
+      I extends Table,
+      C extends Table,
+      AC extends Table,
+      N,
+    >(
+      mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, N>,
+    ) =>
+      makeTargetPasswordRegistrationServices(
+        mapping as unknown as AnyPasswordRegistrationMapping<Registration>,
+        configuration,
+      ).pipe(Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService))),
+    coordinatePasswordPersistence,
+    coordinatePasswordRegistration,
+  };
+};