@yielded/auth-persistence 0.1.0-beta.7

package/dist/drizzle/password-target.d.mts

@@ -0,0 +1,17 @@
+import "./proof-target.mjs";
+import "./password-sql.mjs";
+import { PasswordRegistrationAuthority } from "./password-registration.mjs";
+import { Context, Effect, Layer } from "effect";
+import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasswordPersistence, PasswordUnavailable } from "@yielded/auth/Password";
+import "effect/unstable/sql/SqlError";
+//#region src/drizzle/password-target.d.ts
+declare const passwordPersistenceLayer: (services: Effect.Effect<{
+  readonly passwordPersistence: PasswordPersistence["Service"];
+}, never, LifecycleHooks>) => Layer.Layer<PasswordPersistence, never, LifecycleHooks>;
+declare const passwordRegistrationLayer: <Id, Registration>(tag: Context.Key<Id, PasswordRegistrationAuthority<Registration>>, services: Effect.Effect<{
+  readonly registrationAuthority: PasswordRegistrationAuthority<Registration>;
+}, never, LifecycleHooks>) => Layer.Layer<Id, never, LifecycleHooks>;
+//#endregion
+export { passwordPersistenceLayer, passwordRegistrationLayer };
+//# sourceMappingURL=password-target.d.mts.map

package/dist/drizzle/password-target.mjs

@@ -0,0 +1,61 @@
+import { sqlClientStandaloneGuard } from "./standalone-guard.mjs";
+import { makeSqlPasswordPersistence } from "./password-sql.mjs";
+import { makeSqlPasswordRegistrationAuthority } from "./password-registration.mjs";
+import { Effect, Layer } from "effect";
+import { LifecycleHooks, coordinateCommit, hasCommitScope } from "@yielded/auth/Hooks";
+import { PasswordPersistence, PasswordUnavailable } from "@yielded/auth/Password";
+//#region src/drizzle/password-target.ts
+const sqlClientPasswordStandaloneGuard = (database) => sqlClientStandaloneGuard(database, () => PasswordUnavailable.make({}));
+const passwordOptions = (configuration, proofMapping, coordinated = false) => ({
+	mode: configuration.mode,
+	locking: configuration.locking,
+	standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,
+	insertIfAbsent: configuration.insertIfAbsent,
+	coordinated,
+	...proofMapping === void 0 ? {} : { proof: {
+		mapping: proofMapping,
+		configuration: {
+			mode: configuration.proof.mode,
+			locking: configuration.proof.locking,
+			standaloneGuard: Effect.void,
+			coordinated,
+			insertIfAbsent: configuration.proof.insertIfAbsent
+		}
+	} }
+});
+const registrationOptions = (configuration, coordinated = false) => ({
+	mode: configuration.mode,
+	locking: configuration.locking,
+	standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,
+	generatedSubjectRows: configuration.generatedSubjectRows,
+	coordinated
+});
+const makeTargetPasswordPersistenceServices = (database, mapping, configuration, proofMapping) => Effect.gen(function* () {
+	return { passwordPersistence: yield* makeSqlPasswordPersistence(database, mapping, passwordOptions(configuration, proofMapping)) };
+});
+const makeTargetPasswordRegistrationServices = (database, mapping, configuration) => Effect.gen(function* () {
+	return { registrationAuthority: yield* makeSqlPasswordRegistrationAuthority(database, mapping, registrationOptions(configuration)) };
+});
+/** Native transaction acquisition exposes SqlError; caller errors propagate unchanged. */
+const coordinateTargetPasswordPersistence = (database, mapping, configuration, proofMapping, owner) => Effect.gen(function* () {
+	const hooks = yield* LifecycleHooks;
+	if (yield* hasCommitScope) return yield* PasswordUnavailable.make({});
+	yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
+	return (yield* coordinateCommit(() => database.transaction((transaction) => Effect.gen(function* () {
+		return yield* owner(transaction, { passwordPersistence: yield* makeSqlPasswordPersistence(transaction, mapping, passwordOptions(configuration, proofMapping, true)) });
+	})), { mode: configuration.mode }).pipe(Effect.provideService(LifecycleHooks, hooks))).value;
+});
+const coordinateTargetPasswordRegistration = (database, mapping, configuration, owner) => Effect.gen(function* () {
+	const hooks = yield* LifecycleHooks;
+	if (yield* hasCommitScope) return yield* PasswordUnavailable.make({});
+	yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
+	return (yield* coordinateCommit(() => database.transaction((transaction) => Effect.gen(function* () {
+		return yield* owner(transaction, { registrationAuthority: yield* makeSqlPasswordRegistrationAuthority(transaction, mapping, registrationOptions(configuration, true)) });
+	})), { mode: configuration.mode }).pipe(Effect.provideService(LifecycleHooks, hooks))).value;
+});
+const passwordPersistenceLayer = (services) => Layer.effect(PasswordPersistence, Effect.map(services, (value) => value.passwordPersistence));
+const passwordRegistrationLayer = (tag, services) => Layer.effect(tag, Effect.map(services, (value) => value.registrationAuthority));
+//#endregion
+export { coordinateTargetPasswordPersistence, coordinateTargetPasswordRegistration, makeTargetPasswordPersistenceServices, makeTargetPasswordRegistrationServices, passwordOptions, passwordPersistenceLayer, passwordRegistrationLayer, sqlClientPasswordStandaloneGuard };
+
+//# sourceMappingURL=password-target.mjs.map

package/dist/drizzle/password-target.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-target.mjs","names":[],"sources":["../../src/drizzle/password-target.ts"],"sourcesContent":["import {\n  coordinateCommit,\n  hasCommitScope,\n  LifecycleHooks,\n  type HookConfigurationError,\n} from \"@yielded/auth/Hooks\";\nimport { PasswordUnavailable, PasswordPersistence } from \"@yielded/auth/Password\";\n/* oxlint-disable no-explicit-any -- public driver wrappers restore concrete Drizzle generics. */\nimport { type Context, Effect, Layer } from \"effect\";\nimport type * as SqlError from \"effect/unstable/sql/SqlError\";\n\nimport {\n  makeSqlPasswordRegistrationAuthority,\n  type PasswordRegistrationAuthority,\n  type PasswordRegistrationConfiguration,\n} from \"./password-registration\";\nimport {\n  makeSqlPasswordPersistence,\n  type PasswordSqlConfiguration,\n  type PasswordSqlDatabase,\n  type PasswordSqlQuery,\n} from \"./password-sql\";\nimport type { ProofTargetConfiguration } from \"./proof-target\";\nimport { sqlClientStandaloneGuard } from \"./standalone-guard\";\n\nexport interface PasswordTargetConfiguration {\n  readonly mode: \"interactive\" | \"synchronous\";\n  readonly locking: boolean;\n  readonly standaloneGuard: Effect.Effect<void, PasswordUnavailable>;\n  readonly coordinatorGuard?: Effect.Effect<void, PasswordUnavailable>;\n  readonly insertIfAbsent: (\n    query: PasswordSqlQuery,\n    selfKey: string,\n    selfValue: unknown,\n  ) => PasswordSqlQuery;\n  readonly generatedSubjectRows: (query: PasswordSqlQuery) => PasswordSqlQuery;\n  readonly proof: ProofTargetConfiguration;\n}\n\ninterface TransactionOwner<Transaction> {\n  readonly transaction: <A, E, R>(\n    body: (transaction: Transaction) => Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, E | SqlError.SqlError, R>;\n}\n\nexport type PasswordCoordinatorError<E> =\n  | E\n  | PasswordUnavailable\n  | HookConfigurationError\n  | SqlError.SqlError;\n\nexport const sqlClientPasswordStandaloneGuard = (\n  database: unknown,\n): Effect.Effect<void, PasswordUnavailable> =>\n  sqlClientStandaloneGuard(database, () => PasswordUnavailable.make({}));\n\nexport const passwordOptions = (\n  configuration: PasswordTargetConfiguration,\n  proofMapping?: any,\n  coordinated = false,\n): PasswordSqlConfiguration => ({\n  mode: configuration.mode,\n  locking: configuration.locking,\n\n  standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,\n  insertIfAbsent: configuration.insertIfAbsent,\n  coordinated,\n  ...(proofMapping === undefined\n    ? {}\n    : {\n        proof: {\n          mapping: proofMapping,\n          configuration: {\n            mode: configuration.proof.mode,\n            locking: configuration.proof.locking,\n\n            standaloneGuard: Effect.void,\n\n            coordinated,\n            insertIfAbsent: configuration.proof.insertIfAbsent,\n          },\n        },\n      }),\n});\n\nconst registrationOptions = (\n  configuration: PasswordTargetConfiguration,\n  coordinated = false,\n): PasswordRegistrationConfiguration => ({\n  mode: configuration.mode,\n  locking: configuration.locking,\n\n  standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,\n  generatedSubjectRows: configuration.generatedSubjectRows,\n  coordinated,\n});\n\nexport const makeTargetPasswordPersistenceServices = (\n  database: any,\n  mapping: any,\n  configuration: PasswordTargetConfiguration,\n  proofMapping?: any,\n) =>\n  Effect.gen(function* () {\n    return {\n      passwordPersistence: yield* makeSqlPasswordPersistence(\n        database,\n        mapping,\n        passwordOptions(configuration, proofMapping),\n      ),\n    };\n  });\n\nexport const makeTargetPasswordRegistrationServices = <Registration>(\n  database: any,\n  mapping: any,\n  configuration: PasswordTargetConfiguration,\n) =>\n  Effect.gen(function* () {\n    return {\n      registrationAuthority: yield* makeSqlPasswordRegistrationAuthority<Registration>(\n        database,\n        mapping,\n        registrationOptions(configuration),\n      ),\n    };\n  });\n\n/** Native transaction acquisition exposes SqlError; caller errors propagate unchanged. */\nexport const coordinateTargetPasswordPersistence = <Transaction, A, E, R>(\n  database: TransactionOwner<Transaction>,\n  mapping: any,\n  configuration: PasswordTargetConfiguration,\n  proofMapping: any | undefined,\n  owner: (\n    transaction: Transaction,\n    services: { readonly passwordPersistence: PasswordPersistence[\"Service\"] },\n  ) => Effect.Effect<A, E, R>,\n): Effect.Effect<A, PasswordCoordinatorError<E>, R | LifecycleHooks> =>\n  Effect.gen(function* (): Effect.fn.Return<A, PasswordCoordinatorError<E>, R | LifecycleHooks> {\n    const hooks = yield* LifecycleHooks;\n\n    if (yield* hasCommitScope) return yield* PasswordUnavailable.make({});\n    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;\n\n    const result = yield* coordinateCommit(\n      () =>\n        database.transaction((transaction) =>\n          Effect.gen(function* () {\n            return yield* owner(transaction, {\n              passwordPersistence: yield* makeSqlPasswordPersistence(\n                transaction as unknown as PasswordSqlDatabase,\n                mapping,\n                passwordOptions(configuration, proofMapping, true),\n              ),\n            });\n          }),\n        ),\n      { mode: configuration.mode },\n    ).pipe(Effect.provideService(LifecycleHooks, hooks));\n\n    return result.value;\n  });\n\nexport const coordinateTargetPasswordRegistration = <Registration, Transaction, A, E, R>(\n  database: TransactionOwner<Transaction>,\n  mapping: any,\n  configuration: PasswordTargetConfiguration,\n  owner: (\n    transaction: Transaction,\n    services: {\n      readonly registrationAuthority: PasswordRegistrationAuthority<Registration>;\n    },\n  ) => Effect.Effect<A, E, R>,\n): Effect.Effect<A, PasswordCoordinatorError<E>, R | LifecycleHooks> =>\n  Effect.gen(function* (): Effect.fn.Return<A, PasswordCoordinatorError<E>, R | LifecycleHooks> {\n    const hooks = yield* LifecycleHooks;\n\n    if (yield* hasCommitScope) return yield* PasswordUnavailable.make({});\n    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;\n\n    const result = yield* coordinateCommit(\n      () =>\n        database.transaction((transaction) =>\n          Effect.gen(function* () {\n            return yield* owner(transaction, {\n              registrationAuthority: yield* makeSqlPasswordRegistrationAuthority<Registration>(\n                transaction as unknown as PasswordSqlDatabase,\n                mapping,\n                registrationOptions(configuration, true),\n              ),\n            });\n          }),\n        ),\n      { mode: configuration.mode },\n    ).pipe(Effect.provideService(LifecycleHooks, hooks));\n\n    return result.value;\n  });\n\nexport const passwordPersistenceLayer = (\n  services: Effect.Effect<\n    { readonly passwordPersistence: PasswordPersistence[\"Service\"] },\n    never,\n    LifecycleHooks\n  >,\n) =>\n  Layer.effect(\n    PasswordPersistence,\n    Effect.map(services, (value) => value.passwordPersistence),\n  );\n\nexport const passwordRegistrationLayer = <Id, Registration>(\n  tag: Context.Key<Id, PasswordRegistrationAuthority<Registration>>,\n  services: Effect.Effect<\n    { readonly registrationAuthority: PasswordRegistrationAuthority<Registration> },\n    never,\n    LifecycleHooks\n  >,\n) =>\n  Layer.effect(\n    tag,\n    Effect.map(services, (value) => value.registrationAuthority),\n  );\n"],"mappings":";;;;;;;AAmDA,MAAa,oCACX,aAEA,yBAAyB,gBAAgB,oBAAoB,KAAK,CAAC,CAAC,CAAC;AAEvE,MAAa,mBACX,eACA,cACA,cAAc,WACgB;CAC9B,MAAM,cAAc;CACpB,SAAS,cAAc;CAEvB,iBAAiB,CAAC,cAAc,cAAc,kBAAkB,OAAO;CACvE,gBAAgB,cAAc;CAC9B;CACA,GAAI,iBAAiB,KAAA,IACjB,CAAC,IACD,EACE,OAAO;EACL,SAAS;EACT,eAAe;GACb,MAAM,cAAc,MAAM;GAC1B,SAAS,cAAc,MAAM;GAE7B,iBAAiB,OAAO;GAExB;GACA,gBAAgB,cAAc,MAAM;EACtC;CACF,EACF;AACN;AAEA,MAAM,uBACJ,eACA,cAAc,WACyB;CACvC,MAAM,cAAc;CACpB,SAAS,cAAc;CAEvB,iBAAiB,CAAC,cAAc,cAAc,kBAAkB,OAAO;CACvE,sBAAsB,cAAc;CACpC;AACF;AAEA,MAAa,yCACX,UACA,SACA,eACA,iBAEA,OAAO,IAAI,aAAa;CACtB,OAAO,EACL,qBAAqB,OAAO,2BAC1B,UACA,SACA,gBAAgB,eAAe,YAAY,CAC7C,EACF;AACF,CAAC;AAEH,MAAa,0CACX,UACA,SACA,kBAEA,OAAO,IAAI,aAAa;CACtB,OAAO,EACL,uBAAuB,OAAO,qCAC5B,UACA,SACA,oBAAoB,aAAa,CACnC,EACF;AACF,CAAC;;AAGH,MAAa,uCACX,UACA,SACA,eACA,cACA,UAKA,OAAO,IAAI,aAAmF;CAC5F,MAAM,QAAQ,OAAO;CAErB,IAAI,OAAO,gBAAgB,OAAO,OAAO,oBAAoB,KAAK,CAAC,CAAC;CACpE,OAAO,cAAc,oBAAoB,cAAc;CAkBvD,QAAO,OAhBe,uBAElB,SAAS,aAAa,gBACpB,OAAO,IAAI,aAAa;EACtB,OAAO,OAAO,MAAM,aAAa,EAC/B,qBAAqB,OAAO,2BAC1B,aACA,SACA,gBAAgB,eAAe,cAAc,IAAI,CACnD,EACF,CAAC;CACH,CAAC,CACH,GACF,EAAE,MAAM,cAAc,KAAK,CAC7B,CAAC,CAAC,KAAK,OAAO,eAAe,gBAAgB,KAAK,CAAC,EAAA,CAErC;AAChB,CAAC;AAEH,MAAa,wCACX,UACA,SACA,eACA,UAOA,OAAO,IAAI,aAAmF;CAC5F,MAAM,QAAQ,OAAO;CAErB,IAAI,OAAO,gBAAgB,OAAO,OAAO,oBAAoB,KAAK,CAAC,CAAC;CACpE,OAAO,cAAc,oBAAoB,cAAc;CAkBvD,QAAO,OAhBe,uBAElB,SAAS,aAAa,gBACpB,OAAO,IAAI,aAAa;EACtB,OAAO,OAAO,MAAM,aAAa,EAC/B,uBAAuB,OAAO,qCAC5B,aACA,SACA,oBAAoB,eAAe,IAAI,CACzC,EACF,CAAC;CACH,CAAC,CACH,GACF,EAAE,MAAM,cAAc,KAAK,CAC7B,CAAC,CAAC,KAAK,OAAO,eAAe,gBAAgB,KAAK,CAAC,EAAA,CAErC;AAChB,CAAC;AAEH,MAAa,4BACX,aAMA,MAAM,OACJ,qBACA,OAAO,IAAI,WAAW,UAAU,MAAM,mBAAmB,CAC3D;AAEF,MAAa,6BACX,KACA,aAMA,MAAM,OACJ,KACA,OAAO,IAAI,WAAW,UAAU,MAAM,qBAAqB,CAC7D"}

package/dist/drizzle/pg-emails.d.mts

@@ -0,0 +1,72 @@
+import { EmailAddressMapping, EmailRegistrationMapping, EmailSignInMapping } from "./email-model.mjs";
+import { ProofPersistenceMapping } from "./proof-model.mjs";
+import { EmailRegistrationAuthority } from "./email-registration.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { EmailAddressPersistence, EmailUnavailable } from "@yielded/auth/Email";
+import { AnyRelations } from "drizzle-orm";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+import { SqlError } from "effect/unstable/sql/SqlError";
+//#region src/drizzle/pg-emails.d.ts
+type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+type ProofMapping = ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>;
+declare const makePgEmailSignInServices: <S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, NativeId>(database: Database, mapping: EmailSignInMapping<S, I, C, NativeId>) => Effect.Effect<{
+  emailSignInTargets: {
+    readonly lookup: (input: {
+      readonly moduleId: string;
+      readonly identifier: import("@yielded/auth/Identity").LoginIdentifier;
+    }) => Effect.Effect<import("effect/Option").Option<import("@yielded/auth/Email").EmailCredentialSnapshot>, EmailUnavailable>;
+  };
+}, never, never>;
+declare const makePgEmailAddressServices: <S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, M extends AnyPgTable, NativeId>(database: Database, mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>, proofMapping: ProofMapping) => Effect.Effect<{
+  emailAddressPersistence: {
+    readonly target: (input: {
+      readonly moduleId: string;
+      readonly subjectId: import("@yielded/auth/Schema").SubjectId;
+      readonly target: import("@yielded/auth/Identity").LoginIdentifier;
+      readonly sourceCredentialId?: string;
+    }) => Effect.Effect<import("@yielded/auth/Email").EmailAddressTarget, EmailUnavailable>;
+    readonly checkCompletion: (input: import("@yielded/auth/Proofs").ProofCompletionInput) => Effect.Effect<boolean, EmailUnavailable>;
+    readonly verifyWithProof: <A>(input: import("@yielded/auth/Email").EmailAddressMutation, prepare: import("@yielded/auth/Email").PrepareEmailCommit<import("@yielded/auth/Email").EmailAddressDecision, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, EmailUnavailable>;
+    readonly changeWithProof: <A>(input: import("@yielded/auth/Email").EmailAddressMutation, prepare: import("@yielded/auth/Email").PrepareEmailCommit<import("@yielded/auth/Email").EmailAddressDecision, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, EmailUnavailable>;
+    readonly cleanup: <A>(input: {
+      readonly moduleId: string;
+      readonly limit: number;
+    }, prepare: import("@yielded/auth/Email").PrepareEmailCommit<{
+      readonly removed: number;
+      readonly hasMore: boolean;
+    }, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, EmailUnavailable>;
+  };
+}, never, LifecycleHooks>;
+declare function coordinatePgEmailAddress<D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, M extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
+  readonly proofMapping: ProofMapping;
+  readonly transaction?: never;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgEmailAddress<D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, M extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
+  readonly proofMapping: ProofMapping;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, EmailAddressPersistence | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare const makePgEmailRegistrationServices: <Registration, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId>(database: Database, mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>, proofMapping: ProofMapping) => Effect.Effect<{
+  registrationAuthority: EmailRegistrationAuthority<Registration>;
+}, never, LifecycleHooks>;
+declare function coordinatePgEmailRegistration<TargetId, Registration, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+  readonly proofMapping: ProofMapping;
+  readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+  readonly transaction?: never;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgEmailRegistration<TargetId, Registration, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+  readonly proofMapping: ProofMapping;
+  readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinatePgEmailAddress, coordinatePgEmailRegistration, makePgEmailAddressServices, makePgEmailRegistrationServices, makePgEmailSignInServices };
+//# sourceMappingURL=pg-emails.d.mts.map

package/dist/drizzle/pg-emails.mjs

@@ -0,0 +1,38 @@
+import { coordinateTargetEmailAddress, coordinateTargetEmailRegistration, makeTargetEmailAddressServices, makeTargetEmailRegistrationServices, makeTargetEmailSignInServices, sqlClientEmailStandaloneGuard } from "./email-target.mjs";
+import { sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+import { EmailAddressPersistence } from "@yielded/auth/Email";
+//#region src/drizzle/pg-emails.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientEmailStandaloneGuard(database),
+	generatedSubjectRows: (query) => query.returning(),
+	proof: {
+		mode: "interactive",
+		locking: true,
+		standaloneGuard: sqlClientProofStandaloneGuard(database),
+		insertIfAbsent: (query) => query.onConflictDoNothing()
+	}
+});
+const makePgEmailSignInServices = (database, mapping) => makeTargetEmailSignInServices(database, mapping, configuration(database));
+const makePgEmailAddressServices = (database, mapping, proofMapping) => makeTargetEmailAddressServices(database, mapping, proofMapping, configuration(database));
+function coordinatePgEmailAddress(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetEmailAddress(database, options.mapping, options.proofMapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(EmailAddressPersistence, services.emailAddressPersistence);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+const makePgEmailRegistrationServices = (database, mapping, proofMapping) => makeTargetEmailRegistrationServices(database, mapping, proofMapping, configuration(database));
+function coordinatePgEmailRegistration(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetEmailRegistration(database, options.mapping, options.proofMapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.target, services.registrationAuthority);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+//#endregion
+export { coordinatePgEmailAddress, coordinatePgEmailRegistration, makePgEmailAddressServices, makePgEmailRegistrationServices, makePgEmailSignInServices };
+
+//# sourceMappingURL=pg-emails.mjs.map

package/dist/drizzle/pg-emails.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-emails.mjs","names":[],"sources":["../../src/drizzle/pg-emails.ts"],"sourcesContent":["import { EmailAddressPersistence, type EmailUnavailable } from \"@yielded/auth/Email\";\nimport type { LifecycleHooks, HookConfigurationError } from \"@yielded/auth/Hooks\";\n/* oxlint-disable no-explicit-any -- proof mapping tables are independently typed by the proof owner; this driver forwards them unchanged to the shared target. */\nimport type { AnyRelations } from \"drizzle-orm\";\nimport type { EffectPgDatabase as PgliteDatabase } from \"drizzle-orm/effect-pglite\";\nimport type { EffectPgDatabase as PostgresDatabase } from \"drizzle-orm/effect-postgres\";\nimport type { AnyPgTable } from \"drizzle-orm/pg-core\";\nimport { Effect, Context } from \"effect\";\nimport type { SqlError } from \"effect/unstable/sql/SqlError\";\n\nimport type {\n  EmailAddressMapping,\n  EmailRegistrationMapping,\n  EmailSignInMapping,\n} from \"./email-model\";\nimport type { EmailRegistrationAuthority } from \"./email-registration\";\nimport type { EmailSqlQuery } from \"./email-sql\";\nimport {\n  coordinateTargetEmailAddress,\n  coordinateTargetEmailRegistration,\n  makeTargetEmailAddressServices,\n  makeTargetEmailRegistrationServices,\n  makeTargetEmailSignInServices,\n  sqlClientEmailStandaloneGuard,\n} from \"./email-target\";\nimport type { ProofPersistenceMapping } from \"./proof-model\";\nimport type { ProofSqlQuery } from \"./proof-sql\";\nimport { sqlClientProofStandaloneGuard } from \"./proof-target\";\nimport type { SuppliedService } from \"./SuppliedService\";\n\ntype Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;\ntype TransactionOf<D extends Database> = Parameters<Parameters<D[\"transaction\"]>[0]>[0];\ntype ProofMapping = ProofPersistenceMapping<\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any\n>;\n\nconst configuration = (database: Database) => ({\n  mode: \"interactive\" as const,\n  locking: true,\n  standaloneGuard: sqlClientEmailStandaloneGuard(database),\n  generatedSubjectRows: (query: EmailSqlQuery) => query.returning(),\n  proof: {\n    mode: \"interactive\" as const,\n    locking: true,\n    standaloneGuard: sqlClientProofStandaloneGuard(database),\n    insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),\n  },\n});\n\nexport const makePgEmailSignInServices = <\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: EmailSignInMapping<S, I, C, NativeId>,\n) => makeTargetEmailSignInServices(database, mapping, configuration(database));\n\nexport const makePgEmailAddressServices = <\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,\n  proofMapping: ProofMapping,\n) => makeTargetEmailAddressServices(database, mapping, proofMapping, configuration(database));\n\nexport function coordinatePgEmailAddress<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgEmailAddress<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, EmailAddressPersistence | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgEmailAddress<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetEmailAddress<TransactionOf<D>, Out, E, Exclude<R, EmailAddressPersistence>>(\n      database,\n      options.mapping,\n      options.proofMapping,\n      configuration(database),\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly emailAddressPersistence: EmailAddressPersistence[\"Service\"] },\n      ) => {\n        const provided = Context.make(EmailAddressPersistence, services.emailAddressPersistence);\n        const work = Effect.provideContext(body, provided);\n\n        return options.transaction === undefined\n          ? work\n          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));\n      },\n    ),\n  );\n}\n\nexport const makePgEmailRegistrationServices = <\n  Registration,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,\n  proofMapping: ProofMapping,\n) =>\n  makeTargetEmailRegistrationServices<Registration>(\n    database,\n    mapping,\n    proofMapping,\n    configuration(database),\n  );\n\nexport function coordinatePgEmailRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgEmailRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgEmailRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly proofMapping: ProofMapping;\n    readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetEmailRegistration<Registration, TransactionOf<D>, Out, E, Exclude<R, TargetId>>(\n      database,\n      options.mapping,\n      options.proofMapping,\n      configuration(database),\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },\n      ) => {\n        const provided = Context.make(options.target, services.registrationAuthority);\n        const work = Effect.provideContext(body, provided);\n\n        return options.transaction === undefined\n          ? work\n          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));\n      },\n    ),\n  );\n}\n"],"mappings":";;;;;AA+CA,MAAM,iBAAiB,cAAwB;CAC7C,MAAM;CACN,SAAS;CACT,iBAAiB,8BAA8B,QAAQ;CACvD,uBAAuB,UAAyB,MAAM,UAAU;CAChE,OAAO;EACL,MAAM;EACN,SAAS;EACT,iBAAiB,8BAA8B,QAAQ;EACvD,iBAAiB,UAAyB,MAAM,oBAAoB;CACtE;AACF;AAEA,MAAa,6BAMX,UACA,YACG,8BAA8B,UAAU,SAAS,cAAc,QAAQ,CAAC;AAE7E,MAAa,8BAQX,UACA,SACA,iBACG,+BAA+B,UAAU,SAAS,cAAc,cAAc,QAAQ,CAAC;AA0D5F,SAAgB,yBAgBd,SACA,SAKA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,6BACE,UACA,QAAQ,SACR,QAAQ,cACR,cAAc,QAAQ,IAEpB,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,yBAAyB,SAAS,uBAAuB;EACvF,MAAM,OAAO,OAAO,eAAe,MAAM,QAAQ;EAEjD,OAAO,QAAQ,gBAAgB,KAAA,IAC3B,OACA,OAAO,eAAe,MAAM,QAAQ,aAAa,QAAQ,YAAY,GAAG,WAAW,CAAC;CAC1F,CACF,CACF;AACF;AAEA,MAAa,mCASX,UACA,SACA,iBAEA,oCACE,UACA,SACA,cACA,cAAc,QAAQ,CACxB;AAgEF,SAAgB,8BAkBd,SACA,SAMA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,kCACE,UACA,QAAQ,SACR,QAAQ,cACR,cAAc,QAAQ,IAEpB,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,QAAQ,QAAQ,SAAS,qBAAqB;EAC5E,MAAM,OAAO,OAAO,eAAe,MAAM,QAAQ;EAEjD,OAAO,QAAQ,gBAAgB,KAAA,IAC3B,OACA,OAAO,eAAe,MAAM,QAAQ,aAAa,QAAQ,YAAY,GAAG,WAAW,CAAC;CAC1F,CACF,CACF;AACF"}

package/dist/drizzle/pg-password-prepared.d.mts

@@ -0,0 +1,31 @@
+import { PasswordPreparedPersistenceMapping, PasswordPreparedProofMapping } from "./password-prepared-model.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasswordPreparedPersistence, PasswordUnavailable } from "@yielded/auth/Password";
+import { AnyRelations } from "drizzle-orm";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+import { SqlError } from "effect/unstable/sql/SqlError";
+//#region src/drizzle/pg-password-prepared.d.ts
+type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+declare const makePgPasswordPreparedPersistenceServices: <S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, T extends AnyPgTable, B extends AnyPgTable, NativeId, PS extends AnyPgTable = AnyPgTable, PC extends AnyPgTable = AnyPgTable, PM extends AnyPgTable = AnyPgTable, PSub extends AnyPgTable = AnyPgTable, PI extends AnyPgTable = AnyPgTable, PCr extends AnyPgTable = AnyPgTable, PNativeId = unknown>(database: Database, mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>, proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>) => Effect.Effect<{
+  passwordPreparedPersistence: PasswordPreparedPersistence;
+}, never, LifecycleHooks>;
+declare function coordinatePgPasswordPreparedPersistence<TargetId, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, T extends AnyPgTable, B extends AnyPgTable, NativeId, PS extends AnyPgTable, PC extends AnyPgTable, PM extends AnyPgTable, PSub extends AnyPgTable, PI extends AnyPgTable, PCr extends AnyPgTable, PNativeId, Out, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+  readonly proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId> | undefined;
+  readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;
+  readonly transaction?: never;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgPasswordPreparedPersistence<TargetId, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, T extends AnyPgTable, B extends AnyPgTable, NativeId, PS extends AnyPgTable, PC extends AnyPgTable, PM extends AnyPgTable, PSub extends AnyPgTable, PI extends AnyPgTable, PCr extends AnyPgTable, PNativeId, Out, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+  readonly proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId> | undefined;
+  readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinatePgPasswordPreparedPersistence, makePgPasswordPreparedPersistenceServices };
+//# sourceMappingURL=pg-password-prepared.d.mts.map

package/dist/drizzle/pg-password-prepared.mjs

@@ -0,0 +1,16 @@
+import { coordinateTargetPasswordPreparedPersistence, makeTargetPasswordPreparedPersistenceServices } from "./password-prepared-target.mjs";
+import { pgPasswordConfiguration as configuration } from "./pg-passwords.mjs";
+import { Context, Effect } from "effect";
+//#region src/drizzle/pg-password-prepared.ts
+const makePgPasswordPreparedPersistenceServices = (database, mapping, proofMapping) => makeTargetPasswordPreparedPersistenceServices(database, mapping, configuration(database), proofMapping);
+function coordinatePgPasswordPreparedPersistence(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetPasswordPreparedPersistence(database, options.mapping, configuration(database), options.proofMapping, (transaction, services) => {
+		const provided = Context.make(options.target, services.passwordPreparedPersistence);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+//#endregion
+export { coordinatePgPasswordPreparedPersistence, makePgPasswordPreparedPersistenceServices };
+
+//# sourceMappingURL=pg-password-prepared.mjs.map

package/dist/drizzle/pg-password-prepared.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-password-prepared.mjs","names":[],"sources":["../../src/drizzle/pg-password-prepared.ts"],"sourcesContent":["import type { LifecycleHooks, HookConfigurationError } from \"@yielded/auth/Hooks\";\nimport type { PasswordUnavailable, PasswordPreparedPersistence } from \"@yielded/auth/Password\";\nimport type { AnyRelations } from \"drizzle-orm\";\nimport type { EffectPgDatabase as PgliteDatabase } from \"drizzle-orm/effect-pglite\";\nimport type { EffectPgDatabase as PostgresDatabase } from \"drizzle-orm/effect-postgres\";\nimport type { AnyPgTable } from \"drizzle-orm/pg-core\";\nimport { Effect, Context } from \"effect\";\nimport type { SqlError } from \"effect/unstable/sql/SqlError\";\n\nimport type {\n  PasswordPreparedPersistenceMapping,\n  PasswordPreparedProofMapping,\n} from \"./password-prepared-model\";\nimport {\n  makeTargetPasswordPreparedPersistenceServices,\n  coordinateTargetPasswordPreparedPersistence,\n} from \"./password-prepared-target\";\nimport { pgPasswordConfiguration as configuration } from \"./pg-passwords\";\nimport type { SuppliedService } from \"./SuppliedService\";\ntype Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;\ntype TransactionOf<D extends Database> = Parameters<Parameters<D[\"transaction\"]>[0]>[0];\n\nexport const makePgPasswordPreparedPersistenceServices = <\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  T extends AnyPgTable,\n  B extends AnyPgTable,\n  NativeId,\n  PS extends AnyPgTable = AnyPgTable,\n  PC extends AnyPgTable = AnyPgTable,\n  PM extends AnyPgTable = AnyPgTable,\n  PSub extends AnyPgTable = AnyPgTable,\n  PI extends AnyPgTable = AnyPgTable,\n  PCr extends AnyPgTable = AnyPgTable,\n  PNativeId = unknown,\n>(\n  database: Database,\n  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>,\n  proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,\n) =>\n  makeTargetPasswordPreparedPersistenceServices(\n    database,\n    mapping,\n    configuration(database),\n    proofMapping,\n  );\n\nexport function coordinatePgPasswordPreparedPersistence<\n  TargetId,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  T extends AnyPgTable,\n  B extends AnyPgTable,\n  NativeId,\n  PS extends AnyPgTable,\n  PC extends AnyPgTable,\n  PM extends AnyPgTable,\n  PSub extends AnyPgTable,\n  PI extends AnyPgTable,\n  PCr extends AnyPgTable,\n  PNativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;\n    readonly proofMapping?:\n      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>\n      | undefined;\n    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordPreparedPersistence<\n  TargetId,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  T extends AnyPgTable,\n  B extends AnyPgTable,\n  NativeId,\n  PS extends AnyPgTable,\n  PC extends AnyPgTable,\n  PM extends AnyPgTable,\n  PSub extends AnyPgTable,\n  PI extends AnyPgTable,\n  PCr extends AnyPgTable,\n  PNativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;\n    readonly proofMapping?:\n      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>\n      | undefined;\n    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordPreparedPersistence<\n  TargetId,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  T extends AnyPgTable,\n  B extends AnyPgTable,\n  NativeId,\n  PS extends AnyPgTable,\n  PC extends AnyPgTable,\n  PM extends AnyPgTable,\n  PSub extends AnyPgTable,\n  PI extends AnyPgTable,\n  PCr extends AnyPgTable,\n  PNativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;\n    readonly proofMapping?:\n      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>\n      | undefined;\n    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetPasswordPreparedPersistence<TransactionOf<D>, Out, E, Exclude<R, TargetId>>(\n      database,\n      options.mapping,\n      configuration(database),\n      options.proofMapping,\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly passwordPreparedPersistence: PasswordPreparedPersistence },\n      ) => {\n        const provided = Context.make(options.target, services.passwordPreparedPersistence);\n        const work = Effect.provideContext(body, provided);\n\n        return options.transaction === undefined\n          ? work\n          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));\n      },\n    ),\n  );\n}\n"],"mappings":";;;;AAsBA,MAAa,6CAoBX,UACA,SACA,iBAEA,8CACE,UACA,SACA,cAAc,QAAQ,GACtB,YACF;AA0FF,SAAgB,wCA6Bd,SACA,SAQA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,4CACE,UACA,QAAQ,SACR,cAAc,QAAQ,GACtB,QAAQ,eAEN,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,QAAQ,QAAQ,SAAS,2BAA2B;EAClF,MAAM,OAAO,OAAO,eAAe,MAAM,QAAQ;EAEjD,OAAO,QAAQ,gBAAgB,KAAA,IAC3B,OACA,OAAO,eAAe,MAAM,QAAQ,aAAa,QAAQ,YAAY,GAAG,WAAW,CAAC;CAC1F,CACF,CACF;AACF"}

package/dist/drizzle/pg-passwords.d.mts

@@ -0,0 +1,87 @@
+import { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model.mjs";
+import { ProofPersistenceMapping } from "./proof-model.mjs";
+import "./proof-sql.mjs";
+import "./password-sql.mjs";
+import { PasswordRegistrationAuthority } from "./password-registration.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasswordPersistence, PasswordUnavailable } from "@yielded/auth/Password";
+import { AnyRelations } from "drizzle-orm";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+import { SqlError } from "effect/unstable/sql/SqlError";
+//#region src/drizzle/pg-passwords.d.ts
+type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+type PasswordMapping<S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, NativeId> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+declare const makePgPasswordPersistenceServices: <S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, NativeId>(database: Database, mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>, proofMapping?: ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>) => Effect.Effect<{
+  passwordPersistence: {
+    readonly admitAttempt: <A_1>(input: {
+      readonly moduleId: string;
+      readonly action: "sign-in" | "change";
+      readonly identifier: import("@yielded/auth/Identity").LoginIdentifier;
+      readonly subjectId?: import("@yielded/auth/Schema").SubjectId;
+      readonly policy: import("@yielded/auth/Password").PasswordAttemptPolicy;
+    }, prepare: import("@yielded/auth/Password").PreparePasswordCommit<import("@yielded/auth/Password").PasswordAttemptAdmission, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly settleAttempt: <A_1>(input: {
+      readonly moduleId: string;
+      readonly attemptId: import("@yielded/auth/Password").PasswordAttemptId;
+      readonly captured?: import("@yielded/auth/Password").PasswordCredentialSnapshot;
+      readonly outcome: import("@yielded/auth/Password").PasswordAttemptDecision;
+      readonly rehash?: {
+        readonly expectedVersion: import("@yielded/auth/Sessions").SecurityRevision;
+        readonly expectedVerifier: import("effect/Redacted").Redacted<import("@yielded/auth/Password").EncodedPasswordHash>;
+        readonly nextVerifier: import("effect/Redacted").Redacted<import("@yielded/auth/Password").EncodedPasswordHash>;
+      };
+    }, prepare: import("@yielded/auth/Password").PreparePasswordCommit<import("@yielded/auth/Password").PasswordAttemptDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly readForSubject: (input: {
+      readonly moduleId: string;
+      readonly subjectId: import("@yielded/auth/Schema").SubjectId;
+    }) => Effect.Effect<import("effect/Option").Option<import("@yielded/auth/Password").PasswordCredentialSnapshot>, PasswordUnavailable>;
+    readonly recoveryTarget: (input: {
+      readonly moduleId: string;
+      readonly identifier: import("@yielded/auth/Identity").LoginIdentifier;
+    }) => Effect.Effect<import("effect/Option").Option<import("@yielded/auth/Password").PasswordCredentialSnapshot>, PasswordUnavailable>;
+    readonly addIfAbsent: <A_1>(input: import("@yielded/auth/Password").PasswordMutationInput, prepare: import("@yielded/auth/Password").PreparePasswordCommit<import("@yielded/auth/Password").PasswordMutationDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly replaceIfCurrent: <A_1>(input: import("@yielded/auth/Password").PasswordMutationInput, prepare: import("@yielded/auth/Password").PreparePasswordCommit<import("@yielded/auth/Password").PasswordMutationDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly checkReset: (input: import("@yielded/auth/Proofs").ProofCompletionInput) => Effect.Effect<boolean, PasswordUnavailable>;
+    readonly resetWithProof: <A_1>(input: import("@yielded/auth/Password").PasswordMutationInput & {
+      readonly completion: import("@yielded/auth/Proofs").ProofCompletionPlan;
+    }, prepare: import("@yielded/auth/Password").PreparePasswordCommit<import("@yielded/auth/Password").PasswordMutationDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly cleanupAttempts: <A_1>(input: {
+      readonly moduleId: string;
+      readonly limit: number;
+    }, prepare: import("@yielded/auth/Password").PreparePasswordCommit<{
+      readonly removed: number;
+      readonly hasMore: boolean;
+    }, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, PasswordUnavailable>;
+  };
+}, never, LifecycleHooks>;
+declare function coordinatePgPasswordPersistence<D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, NativeId, PM extends ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any> | undefined, Out, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+  readonly proofMapping?: PM;
+  readonly transaction?: never;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, PasswordPersistence> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgPasswordPersistence<D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, A extends AnyPgTable, RS extends AnyPgTable, CE extends AnyPgTable, M extends AnyPgTable, NativeId, PM extends ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any> | undefined, Out, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+  readonly proofMapping?: PM;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, PasswordPersistence | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare const makePgPasswordRegistrationServices: <Registration, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId>(database: Database, mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>) => Effect.Effect<{
+  registrationAuthority: PasswordRegistrationAuthority<Registration>;
+}, never, LifecycleHooks>;
+declare function coordinatePgPasswordRegistration<TargetId, Registration, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+  readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+  readonly transaction?: never;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgPasswordRegistration<TargetId, Registration, D extends Database, S extends AnyPgTable, I extends AnyPgTable, C extends AnyPgTable, AC extends AnyPgTable, Rq extends AnyPgTable, NativeId, Out, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+  readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<Out, E, R>): Effect.Effect<Out, E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinatePgPasswordPersistence, coordinatePgPasswordRegistration, makePgPasswordPersistenceServices, makePgPasswordRegistrationServices };
+//# sourceMappingURL=pg-passwords.d.mts.map

package/dist/drizzle/pg-passwords.mjs

@@ -0,0 +1,38 @@
+import { coordinateTargetPasswordPersistence, coordinateTargetPasswordRegistration, makeTargetPasswordPersistenceServices, makeTargetPasswordRegistrationServices, sqlClientPasswordStandaloneGuard } from "./password-target.mjs";
+import { sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+import { PasswordPersistence } from "@yielded/auth/Password";
+//#region src/drizzle/pg-passwords.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientPasswordStandaloneGuard(database),
+	insertIfAbsent: (query) => query.onConflictDoNothing(),
+	generatedSubjectRows: (query) => query.returning(),
+	proof: {
+		mode: "interactive",
+		locking: true,
+		standaloneGuard: sqlClientProofStandaloneGuard(database),
+		insertIfAbsent: (query) => query.onConflictDoNothing()
+	}
+});
+const makePgPasswordPersistenceServices = (database, mapping, proofMapping) => makeTargetPasswordPersistenceServices(database, mapping, configuration(database), proofMapping);
+function coordinatePgPasswordPersistence(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetPasswordPersistence(database, options.mapping, configuration(database), options.proofMapping, (transaction, services) => {
+		const provided = Context.make(PasswordPersistence, services.passwordPersistence);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+const makePgPasswordRegistrationServices = (database, mapping) => makeTargetPasswordRegistrationServices(database, mapping, configuration(database));
+function coordinatePgPasswordRegistration(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetPasswordRegistration(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.target, services.registrationAuthority);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+//#endregion
+export { coordinatePgPasswordPersistence, coordinatePgPasswordRegistration, makePgPasswordPersistenceServices, makePgPasswordRegistrationServices, configuration as pgPasswordConfiguration };
+
+//# sourceMappingURL=pg-passwords.mjs.map

package/dist/drizzle/pg-passwords.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-passwords.mjs","names":[],"sources":["../../src/drizzle/pg-passwords.ts"],"sourcesContent":["import type { LifecycleHooks, HookConfigurationError } from \"@yielded/auth/Hooks\";\nimport { type PasswordUnavailable, PasswordPersistence } from \"@yielded/auth/Password\";\n/* oxlint-disable no-explicit-any -- proof mapping tables are independently typed by the proof owner; this driver forwards them unchanged to the shared target. */\nimport type { AnyRelations } from \"drizzle-orm\";\nimport type { EffectPgDatabase as PgliteDatabase } from \"drizzle-orm/effect-pglite\";\nimport type { EffectPgDatabase as PostgresDatabase } from \"drizzle-orm/effect-postgres\";\nimport type { AnyPgTable } from \"drizzle-orm/pg-core\";\nimport { Effect, Context } from \"effect\";\nimport type { SqlError } from \"effect/unstable/sql/SqlError\";\n\nimport type { PasswordPersistenceMapping, PasswordRegistrationMapping } from \"./password-model\";\nimport type { PasswordRegistrationAuthority } from \"./password-registration\";\nimport type { PasswordSqlQuery } from \"./password-sql\";\nimport {\n  coordinateTargetPasswordPersistence,\n  coordinateTargetPasswordRegistration,\n  makeTargetPasswordPersistenceServices,\n  makeTargetPasswordRegistrationServices,\n  sqlClientPasswordStandaloneGuard,\n} from \"./password-target\";\nimport type { ProofPersistenceMapping } from \"./proof-model\";\nimport type { ProofSqlQuery } from \"./proof-sql\";\nimport { sqlClientProofStandaloneGuard } from \"./proof-target\";\nimport type { SuppliedService } from \"./SuppliedService\";\n\ntype Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;\ntype TransactionOf<D extends Database> = Parameters<Parameters<D[\"transaction\"]>[0]>[0];\n\nconst configuration = (database: Database) => ({\n  mode: \"interactive\" as const,\n  locking: true,\n  standaloneGuard: sqlClientPasswordStandaloneGuard(database),\n  insertIfAbsent: (query: PasswordSqlQuery) => query.onConflictDoNothing(),\n  generatedSubjectRows: (query: PasswordSqlQuery) => query.returning(),\n  proof: {\n    mode: \"interactive\" as const,\n    locking: true,\n    standaloneGuard: sqlClientProofStandaloneGuard(database),\n    insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),\n  },\n});\n\ntype PasswordMapping<\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;\n\nexport const makePgPasswordPersistenceServices = <\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>,\n  proofMapping?: ProofPersistenceMapping<\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any,\n    any\n  >,\n) =>\n  makeTargetPasswordPersistenceServices(database, mapping, configuration(database), proofMapping);\n\nexport function coordinatePgPasswordPersistence<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  PM extends\n    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>\n    | undefined,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>;\n    readonly proofMapping?: PM;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, PasswordPersistence> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordPersistence<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  PM extends\n    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>\n    | undefined,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>;\n    readonly proofMapping?: PM;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, PasswordPersistence | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordPersistence<\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  A extends AnyPgTable,\n  RS extends AnyPgTable,\n  CE extends AnyPgTable,\n  M extends AnyPgTable,\n  NativeId,\n  PM extends\n    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>\n    | undefined,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>;\n    readonly proofMapping?: PM;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, PasswordPersistence> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetPasswordPersistence<TransactionOf<D>, Out, E, Exclude<R, PasswordPersistence>>(\n      database,\n      options.mapping,\n      configuration(database),\n      options.proofMapping,\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly passwordPersistence: PasswordPersistence[\"Service\"] },\n      ) => {\n        const provided = Context.make(PasswordPersistence, services.passwordPersistence);\n        const work = Effect.provideContext(body, provided);\n\n        return options.transaction === undefined\n          ? work\n          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));\n      },\n    ),\n  );\n}\n\nexport const makePgPasswordRegistrationServices = <\n  Registration,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,\n) =>\n  makeTargetPasswordRegistrationServices<Registration>(database, mapping, configuration(database));\n\nexport function coordinatePgPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyPgTable,\n  I extends AnyPgTable,\n  C extends AnyPgTable,\n  AC extends AnyPgTable,\n  Rq extends AnyPgTable,\n  NativeId,\n  Out,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n  TxId,\n  TxShape,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;\n    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<Out, E, R>,\n): Effect.Effect<\n  Out,\n  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetPasswordRegistration<\n      Registration,\n      TransactionOf<D>,\n      Out,\n      E,\n      Exclude<R, TargetId>\n    >(\n      database,\n      options.mapping,\n      configuration(database),\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly registrationAuthority: PasswordRegistrationAuthority<Registration> },\n      ) => {\n        const provided = Context.make(options.target, services.registrationAuthority);\n        const work = Effect.provideContext(body, provided);\n\n        return options.transaction === undefined\n          ? work\n          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));\n      },\n    ),\n  );\n}\n\nexport { configuration as pgPasswordConfiguration };\n"],"mappings":";;;;;AA4BA,MAAM,iBAAiB,cAAwB;CAC7C,MAAM;CACN,SAAS;CACT,iBAAiB,iCAAiC,QAAQ;CAC1D,iBAAiB,UAA4B,MAAM,oBAAoB;CACvE,uBAAuB,UAA4B,MAAM,UAAU;CACnE,OAAO;EACL,MAAM;EACN,SAAS;EACT,iBAAiB,8BAA8B,QAAQ;EACvD,iBAAiB,UAAyB,MAAM,oBAAoB;CACtE;AACF;AAcA,MAAa,qCAWX,UACA,SACA,iBAeA,sCAAsC,UAAU,SAAS,cAAc,QAAQ,GAAG,YAAY;AAsEhG,SAAgB,gCAsBd,SACA,SAKA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,oCACE,UACA,QAAQ,SACR,cAAc,QAAQ,GACtB,QAAQ,eAEN,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,qBAAqB,SAAS,mBAAmB;EAC/E,MAAM,OAAO,OAAO,eAAe,MAAM,QAAQ;EAEjD,OAAO,QAAQ,gBAAgB,KAAA,IAC3B,OACA,OAAO,eAAe,MAAM,QAAQ,aAAa,QAAQ,YAAY,GAAG,WAAW,CAAC;CAC1F,CACF,CACF;AACF;AAEA,MAAa,sCASX,UACA,YAEA,uCAAqD,UAAU,SAAS,cAAc,QAAQ,CAAC;AA8DjG,SAAgB,iCAkBd,SACA,SAKA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,qCAOE,UACA,QAAQ,SACR,cAAc,QAAQ,IAEpB,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,QAAQ,QAAQ,SAAS,qBAAqB;EAC5E,MAAM,OAAO,OAAO,eAAe,MAAM,QAAQ;EAEjD,OAAO,QAAQ,gBAAgB,KAAA,IAC3B,OACA,OAAO,eAAe,MAAM,QAAQ,aAAa,QAAQ,YAAY,GAAG,WAAW,CAAC;CAC1F,CACF,CACF;AACF"}

package/dist/drizzle/pg-proofs.d.mts

@@ -0,0 +1,76 @@
+import { ProofPersistenceMapping } from "./proof-model.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
+import { ProofPersistence, ProofUnavailable } from "@yielded/auth/Proofs";
+import { AnyRelations } from "drizzle-orm";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+import { SqlError } from "effect/unstable/sql/SqlError";
+//#region src/drizzle/pg-proofs.d.ts
+type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+type Mapping<Request extends AnyPgTable, Series extends AnyPgTable, Generation extends AnyPgTable, Continuation extends AnyPgTable, RateScope extends AnyPgTable, AbuseEvent extends AnyPgTable, FailureEvent extends AnyPgTable, Command extends AnyPgTable, Subject extends AnyPgTable, Identifier extends AnyPgTable, Credential extends AnyPgTable, NativeSubjectId> = ProofPersistenceMapping<Request, Series, Generation, Continuation, RateScope, AbuseEvent, FailureEvent, Command, Subject, Identifier, Credential, NativeSubjectId>;
+declare const makePgProofPersistenceServices: <Rq extends AnyPgTable, S extends AnyPgTable, G extends AnyPgTable, Cn extends AnyPgTable, Rs extends AnyPgTable, A extends AnyPgTable, F extends AnyPgTable, C extends AnyPgTable, Sub extends AnyPgTable, I extends AnyPgTable, Cr extends AnyPgTable, NativeId>(database: Database, mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>) => Effect.Effect<{
+  proofPersistence: {
+    readonly issue: <A_1>(input: {
+      readonly record: import("@yielded/auth/Proofs").ProofRecord;
+      readonly policy: import("@yielded/auth/Proofs").ProofPolicy;
+      readonly eligible: boolean;
+      readonly supersedes?: import("@yielded/auth/Proofs").ProofId;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<import("@yielded/auth/Proofs").ProofIssueDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, import("@yielded/auth/Proofs").ProofRequestConflict | ProofUnavailable>;
+    readonly attempt: <A_1>(input: {
+      readonly moduleId: string;
+      readonly purpose: import("@yielded/auth/Proofs").ProofPurpose;
+      readonly proofId: import("@yielded/auth/Proofs").ProofId;
+      readonly binding: import("@yielded/auth/Proofs").ProofBinding;
+      readonly candidate?: import("@yielded/auth/Proofs").ProofDigest;
+      readonly continuationId: import("@yielded/auth/Proofs").ProofContinuationId;
+      readonly continuationDigest: import("@yielded/auth/Schema").TokenDigest;
+      readonly nowMillis: number;
+      readonly policy: import("@yielded/auth/Proofs").ProofPolicy;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<import("@yielded/auth/Proofs").ProofAttemptDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+    readonly complete: <A_1>(input: import("@yielded/auth/Proofs").ProofCompletionInput, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<import("@yielded/auth/Proofs").ProofCompletionDecision, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+    readonly claimDelivery: <A_1>(input: {
+      readonly moduleId: string;
+      readonly proofId: import("@yielded/auth/Proofs").ProofId;
+      readonly version: import("@yielded/auth/Proofs").ProofVersion;
+      readonly deliveryId: import("@yielded/auth/Proofs").ProofDeliveryId;
+      readonly nowMillis: number;
+      readonly policy: import("@yielded/auth/Proofs").ProofPolicy;
+      readonly allowAmbiguousRetry: boolean;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<import("@yielded/auth/Proofs").ProofDeliveryClaim, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+    readonly settleDelivery: <A_1>(input: {
+      readonly moduleId: string;
+      readonly proofId: import("@yielded/auth/Proofs").ProofId;
+      readonly version: import("@yielded/auth/Proofs").ProofVersion;
+      readonly deliveryId: import("@yielded/auth/Proofs").ProofDeliveryId;
+      readonly claimVersion: import("@yielded/auth/Proofs").ProofVersion;
+      readonly outcome: import("@yielded/auth/Proofs").ProofDeliveryOutcome;
+      readonly nowMillis: number;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<void, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+    readonly cancel: <A_1>(input: {
+      readonly moduleId: string;
+      readonly purpose: import("@yielded/auth/Proofs").ProofPurpose;
+      readonly binding: import("@yielded/auth/Proofs").ProofBinding;
+      readonly nowMillis: number;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<void, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+    readonly cleanup: <A_1>(input: {
+      readonly moduleId: string;
+      readonly nowMillis: number;
+      readonly limit: number;
+    }, prepare: import("@yielded/auth/Proofs").PrepareProofCommit<import("@yielded/auth/Proofs").ProofCleanupResult, A_1>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A_1>, ProofUnavailable>;
+  };
+}, never, LifecycleHooks>;
+declare function coordinatePgProofPersistence<D extends Database, Rq extends AnyPgTable, S extends AnyPgTable, G extends AnyPgTable, Cn extends AnyPgTable, Rs extends AnyPgTable, Aev extends AnyPgTable, F extends AnyPgTable, C extends AnyPgTable, Sub extends AnyPgTable, I extends AnyPgTable, Cr extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;
+  readonly transaction?: never;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, ProofPersistence> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinatePgProofPersistence<D extends Database, Rq extends AnyPgTable, S extends AnyPgTable, G extends AnyPgTable, Cn extends AnyPgTable, Rs extends AnyPgTable, Aev extends AnyPgTable, F extends AnyPgTable, C extends AnyPgTable, Sub extends AnyPgTable, I extends AnyPgTable, Cr extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+  readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;
+  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, ProofPersistence | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinatePgProofPersistence, makePgProofPersistenceServices };
+//# sourceMappingURL=pg-proofs.d.mts.map

package/dist/drizzle/pg-proofs.mjs

@@ -0,0 +1,22 @@
+import { coordinateTargetProofPersistence, makeTargetProofPersistenceServices, sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+import { ProofPersistence } from "@yielded/auth/Proofs";
+//#region src/drizzle/pg-proofs.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientProofStandaloneGuard(database),
+	insertIfAbsent: (query) => query.onConflictDoNothing()
+});
+const makePgProofPersistenceServices = (database, mapping) => makeTargetProofPersistenceServices(database, mapping, configuration(database));
+function coordinatePgProofPersistence(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetProofPersistence(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(ProofPersistence, services.proofPersistence);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+//#endregion
+export { coordinatePgProofPersistence, makePgProofPersistenceServices };
+
+//# sourceMappingURL=pg-proofs.mjs.map