@yielded/auth-persistence 0.1.0-beta.8 → 0.1.0-beta.9

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

@@ -7,10 +7,10 @@ import { PasswordPreparedReady, PasswordPreparedReservation, PasswordPreparedVer
 import { InferInsertModel, InferSelectModel, SQL, Table } from "drizzle-orm";
 //#region src/drizzle/password-prepared-model.d.ts
 type ColumnKey<T extends Table> = Extract<keyof T["_"]["columns"], string>;
-type PasswordPreparedState = "Preparing" | "Ready" | "Consumed" | "Cancelled" | "Expired";
+export type PasswordPreparedState = "Preparing" | "Ready" | "Consumed" | "Cancelled" | "Expired";
 /** The retained intent is also its nonrefundable admission charge. Scalar identity,
  * scope and timing columns survive sensitive snapshot/digest erasure. */
-interface PasswordPreparedIntentTable<Intent extends Table, NativeSubjectId> {
+export interface PasswordPreparedIntentTable<Intent extends Table, NativeSubjectId> {
   readonly table: Intent;
   readonly moduleId: ColumnKey<Intent>;
   readonly intentId: ColumnKey<Intent>;
@@ -49,7 +49,7 @@ interface PasswordPreparedIntentTable<Intent extends Table, NativeSubjectId> {
 /** One permanent row per configured module; never one row per attacker input.
  * Native owners lock this before subject → identifier → sorted credentials → intent.
  * It serializes admission and maintenance without process-local locks. */
-interface PasswordPreparedAdmissionTable<Admission extends Table> {
+export interface PasswordPreparedAdmissionTable<Admission extends Table> {
   readonly table: Admission;
   readonly moduleId: ColumnKey<Admission>;
   readonly intentId: ColumnKey<Admission>;
@@ -57,14 +57,14 @@ interface PasswordPreparedAdmissionTable<Admission extends Table> {
   readonly admissionRetainUntil: ColumnKey<Admission>;
   readonly encodeInsert: (moduleId: string) => InferInsertModel<Admission>;
 }
-declare const requiredPasswordPreparedConstraints: {
+export declare const requiredPasswordPreparedConstraints: {
   readonly admission: "unique(admission.moduleId)";
   readonly intent: "unique(intent.moduleId,intent.intentId)";
   readonly command: "unique(intent.moduleId,intent.commandId)";
   readonly digest: "unique(intent.digest)";
 };
-type RequiredPasswordPreparedConstraints = typeof requiredPasswordPreparedConstraints;
-interface PasswordPreparedPersistenceMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Attempt extends Table, RateScope extends Table, Charge extends Table, Command extends Table, Intent extends Table, Admission extends Table, NativeSubjectId> {
+export type RequiredPasswordPreparedConstraints = typeof requiredPasswordPreparedConstraints;
+export interface PasswordPreparedPersistenceMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Attempt extends Table, RateScope extends Table, Charge extends Table, Command extends Table, Intent extends Table, Admission extends Table, NativeSubjectId> {
   readonly password: PasswordPersistenceMapping<Subject, Identifier, Credential, AuthorityCredential, Attempt, RateScope, Charge, Command, NativeSubjectId>;
   readonly intent: PasswordPreparedIntentTable<Intent, NativeSubjectId>;
   readonly admission: PasswordPreparedAdmissionTable<Admission>;
@@ -73,7 +73,7 @@ interface PasswordPreparedPersistenceMapping<Subject extends Table, Identifier e
   /** Required by synchronous owners, invoked inside their actual transactionSync. */
   readonly allocateVersionSync?: () => PasswordPreparedVersion;
 }
-type D1PasswordPreparedPersistenceMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Attempt extends Table, RateScope extends Table, Charge extends Table, Command extends Table, Intent extends Table, Admission extends Table, NativeSubjectId> = PasswordPreparedPersistenceMapping<Subject, Identifier, Credential, AuthorityCredential, Attempt, RateScope, Charge, Command, Intent, Admission, NativeSubjectId> & {
+export type D1PasswordPreparedPersistenceMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Attempt extends Table, RateScope extends Table, Charge extends Table, Command extends Table, Intent extends Table, Admission extends Table, NativeSubjectId> = PasswordPreparedPersistenceMapping<Subject, Identifier, Credential, AuthorityCredential, Attempt, RateScope, Charge, Command, Intent, Admission, NativeSubjectId> & {
   /** Convert a stored native instant to epoch milliseconds in the same SQL engine. */
   readonly admissionClock: {
     readonly toMillis: (instant: SQL) => SQL;
@@ -82,13 +82,12 @@ type D1PasswordPreparedPersistenceMapping<Subject extends Table, Identifier exte
 };
 /** Optional real proof completion authority. Request/delivery/abuse capabilities
  * are not required to complete the original continuation. */
-type PasswordPreparedProofMapping<Series extends Table, Continuation extends Table, Command extends Table, Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> = Pick<ProofPersistenceMapping<Table, Series, Table, Continuation, Table, Table, Table, Command, Subject, Identifier, Credential, NativeSubjectId>, "series" | "continuation" | "command" | "authority" | "scopeKeys" | "encodeInstant" | "decodeInstant" | "allocateVersion" | "allocateVersionSync" | "isSeriesConflict" | "isCommandConflict" | "d1"> & {
+export type PasswordPreparedProofMapping<Series extends Table, Continuation extends Table, Command extends Table, Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> = Pick<ProofPersistenceMapping<Table, Series, Table, Continuation, Table, Table, Table, Command, Subject, Identifier, Credential, NativeSubjectId>, "series" | "continuation" | "command" | "authority" | "scopeKeys" | "encodeInstant" | "decodeInstant" | "allocateVersion" | "allocateVersionSync" | "isSeriesConflict" | "isCommandConflict" | "d1"> & {
   readonly constraints: Pick<RequiredProofConstraints, "series" | "continuationId" | "continuationDigest" | "command">;
 };
-type D1PasswordPreparedProofMapping<Series extends Table, Continuation extends Table, Command extends Table, Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> = Pick<D1ProofPersistenceMapping<Table, Series, Table, Continuation, Table, Table, Table, Command, Subject, Identifier, Credential, NativeSubjectId>, Exclude<keyof PasswordPreparedProofMapping<Series, Continuation, Command, Subject, Identifier, Credential, NativeSubjectId>, "constraints">> & {
+export type D1PasswordPreparedProofMapping<Series extends Table, Continuation extends Table, Command extends Table, Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> = Pick<D1ProofPersistenceMapping<Table, Series, Table, Continuation, Table, Table, Table, Command, Subject, Identifier, Credential, NativeSubjectId>, Exclude<keyof PasswordPreparedProofMapping<Series, Continuation, Command, Subject, Identifier, Credential, NativeSubjectId>, "constraints">> & {
   readonly constraints: PasswordPreparedProofMapping<Series, Continuation, Command, Subject, Identifier, Credential, NativeSubjectId>["constraints"];
 };
-type AnyPasswordPreparedPersistenceMapping = PasswordPreparedPersistenceMapping<Table, Table, Table, Table, Table, Table, Table, Table, Table, Table, unknown>;
+export type AnyPasswordPreparedPersistenceMapping = PasswordPreparedPersistenceMapping<Table, Table, Table, Table, Table, Table, Table, Table, Table, Table, unknown>;
 //#endregion
-export { AnyPasswordPreparedPersistenceMapping, D1PasswordPreparedPersistenceMapping, D1PasswordPreparedProofMapping, PasswordPreparedAdmissionTable, PasswordPreparedIntentTable, PasswordPreparedPersistenceMapping, PasswordPreparedProofMapping, PasswordPreparedState, RequiredPasswordPreparedConstraints, requiredPasswordPreparedConstraints };
 //# sourceMappingURL=password-prepared-model.d.mts.map

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

@@ -4,9 +4,8 @@ import { LifecycleHooks } from "@yielded/auth/Hooks";
 import { PasswordPreparedPersistence } from "@yielded/auth/Password";
 import "effect/unstable/sql/SqlError";
 //#region src/drizzle/password-prepared-target.d.ts
-declare const passwordPreparedPersistenceLayer: <Id>(tag: Context.Key<Id, PasswordPreparedPersistence>, services: Effect.Effect<{
+export declare const passwordPreparedPersistenceLayer: <Id>(tag: Context.Key<Id, PasswordPreparedPersistence>, services: Effect.Effect<{
   readonly passwordPreparedPersistence: PasswordPreparedPersistence;
 }, never, LifecycleHooks>) => Layer.Layer<Id, never, LifecycleHooks>;
 //#endregion
-export { passwordPreparedPersistenceLayer };
 //# sourceMappingURL=password-prepared-target.d.mts.map

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

@@ -5,7 +5,7 @@ import { LifecycleHooks, PreparedCommit } from "@yielded/auth/Hooks";
 import { PasswordRegistrationDecision, PasswordReplacement, PasswordUnavailable, PreparePasswordCommit } from "@yielded/auth/Password";
 import { LoginIdentifier } from "@yielded/auth/Identity";
 //#region src/drizzle/password-registration.d.ts
-interface PasswordRegistrationAuthority<Registration> {
+export interface PasswordRegistrationAuthority<Registration> {
   readonly register: <A>(input: {
     readonly moduleId: string;
     readonly requestId: string;
@@ -15,5 +15,4 @@ interface PasswordRegistrationAuthority<Registration> {
   }, prepare: PreparePasswordCommit<PasswordRegistrationDecision, A>) => Effect.Effect<PreparedCommit<A>, PasswordUnavailable>;
 }
 //#endregion
-export { PasswordRegistrationAuthority };
 //# sourceMappingURL=password-registration.d.mts.map

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

@@ -6,12 +6,11 @@ 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<{
+export 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<{
+export 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/pg-emails.d.mts

@@ -14,7 +14,7 @@ import { SqlError } from "effect/unstable/sql/SqlError";
 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<{
+export 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;
@@ -22,7 +22,7 @@ declare const makePgEmailSignInServices: <S extends AnyPgTable, I extends AnyPgT
     }) => 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<{
+export 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;
@@ -42,31 +42,30 @@ declare const makePgEmailAddressServices: <S extends AnyPgTable, I extends AnyPg
     }, 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: {
+export 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: {
+export 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<{
+export 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: {
+export 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: {
+export 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-password-prepared.d.mts

@@ -11,21 +11,20 @@ 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<{
+export 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: {
+export 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: {
+export 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-passwords.d.mts

@@ -16,7 +16,7 @@ import { SqlError } from "effect/unstable/sql/SqlError";
 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<{
+export 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;
@@ -59,29 +59,28 @@ declare const makePgPasswordPersistenceServices: <S extends AnyPgTable, I extend
     }, 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: {
+export 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: {
+export 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<{
+export 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: {
+export 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: {
+export 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-proofs.d.mts

@@ -12,7 +12,7 @@ import { SqlError } from "effect/unstable/sql/SqlError";
 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<{
+export 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;
@@ -63,14 +63,13 @@ declare const makePgProofPersistenceServices: <Rq extends AnyPgTable, S extends
     }, 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: {
+export 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: {
+export 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-sessions.d.mts

@@ -12,7 +12,7 @@ import { SqlError } from "effect/unstable/sql/SqlError";
 //#region src/drizzle/pg-sessions.d.ts
 type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
 type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
-declare const makePgAuthenticationAuthorityServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Flow extends AnyPgTable, Pending extends AnyPgTable, NativeSubjectId>(database: Database, mapping: AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId>) => Effect.Effect<{
+export declare const makePgAuthenticationAuthorityServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Flow extends AnyPgTable, Pending extends AnyPgTable, NativeSubjectId>(database: Database, mapping: AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId>) => Effect.Effect<{
   authenticationAuthority: {
     capture: (subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">, credentialIds: readonly string[]) => Effect.Effect<{
       subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
@@ -71,7 +71,7 @@ declare const makePgAuthenticationAuthorityServices: <Claims, Subject extends An
     }, prepare: import("@yielded/auth/Sessions").PrepareSessionCommit<void, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, import("@yielded/auth/Sessions").PendingAuthenticationInvalid | SessionUnavailable | import("@yielded/auth/Sessions").StaleAuthentication, never>;
   };
 }, never, LifecycleHooks>;
-declare const makePgPendingAuthenticationServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Pending extends AnyPgTable, Flow extends AnyPgTable, NativeSubjectId>(database: Database, mapping: PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId>) => Effect.Effect<{
+export declare const makePgPendingAuthenticationServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Pending extends AnyPgTable, Flow extends AnyPgTable, NativeSubjectId>(database: Database, mapping: PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId>) => Effect.Effect<{
   pendingAuthentication: {
     create: <A>(input: Omit<import("@yielded/auth/Sessions").PendingAuthenticationRecord<Claims>, "version">, now: import("effect/DateTime").Utc, prepare: import("@yielded/auth/Sessions").PrepareSessionCommit<import("@yielded/auth/Sessions").PendingAuthenticationRecord<Claims>, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, import("@yielded/auth/Sessions").SessionConflict | SessionUnavailable | import("@yielded/auth/Sessions").StaleAuthentication, never>;
     context: (input: {
@@ -104,7 +104,7 @@ declare const makePgPendingAuthenticationServices: <Claims, Subject extends AnyP
     }, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, SessionUnavailable, never>;
   };
 }, never, LifecycleHooks>;
-declare const makePgStatefulSessionServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Session extends AnyPgTable, Flow extends AnyPgTable, Pending extends AnyPgTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: StatefulSessionMapping<Claims, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
+export declare const makePgStatefulSessionServices: <Claims, Subject extends AnyPgTable, Credential extends AnyPgTable, Session extends AnyPgTable, Flow extends AnyPgTable, Pending extends AnyPgTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: StatefulSessionMapping<Claims, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
   statefulSessionPersistence: {
     establish: <A>(input: {
       readonly session: Omit<import("@yielded/auth/Sessions").StatefulSessionRecord<Claims>, "sessionId" | "version">;
@@ -157,7 +157,7 @@ declare const makePgStatefulSessionServices: <Claims, Subject extends AnyPgTable
     }, SessionUnavailable, never>;
   };
 }, never, LifecycleHooks>;
-declare const makePgSignedSessionValidityServices: <Subject extends AnyPgTable, Tombstone extends AnyPgTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
+export declare const makePgSignedSessionValidityServices: <Subject extends AnyPgTable, Tombstone extends AnyPgTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
   signedSessionValidity: {
     verify: (session: {
       readonly sessionId: string & import("effect/Brand").Brand<"effect-auth/SessionId">;
@@ -180,59 +180,58 @@ declare const makePgSignedSessionValidityServices: <Subject extends AnyPgTable,
     }, prepare: import("@yielded/auth/Sessions").PrepareSessionCommit<void, A>) => Effect.Effect<import("@yielded/auth/Hooks").PreparedCommit<A>, SessionUnavailable | import("@yielded/auth/Sessions").StaleAuthentication, never>;
   };
 }, never, LifecycleHooks>;
-declare function coordinatePgAuthenticationAuthority<Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthenticationAuthority<Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, AuthenticationAuthority> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgAuthenticationAuthority<Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthenticationAuthority<Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, AuthenticationAuthority | TxId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgPendingAuthentication<TargetId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, P extends AnyPgTable, F extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgPendingAuthentication<TargetId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, P extends AnyPgTable, F extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: PendingAuthenticationMapping<NoInfer<Claims>, S, C, P, F, NativeId>;
   readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgPendingAuthentication<TargetId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, P extends AnyPgTable, F extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgPendingAuthentication<TargetId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, P extends AnyPgTable, F extends AnyPgTable, NativeId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: PendingAuthenticationMapping<NoInfer<Claims>, S, C, P, F, NativeId>;
   readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgStatefulSessions<PersistenceId, RepositoryId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, Session extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgStatefulSessions<PersistenceId, RepositoryId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, Session extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: StatefulSessionMapping<NoInfer<Claims>, S, C, Session, F, P, NativeId, NativeSessionId>;
   readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
   readonly repository: SuppliedService<RepositoryId, SessionRepository>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, PersistenceId | RepositoryId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgStatefulSessions<PersistenceId, RepositoryId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, Session extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgStatefulSessions<PersistenceId, RepositoryId, Claims, D extends Database, S extends AnyPgTable, C extends AnyPgTable, Session extends AnyPgTable, F extends AnyPgTable, P extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: StatefulSessionMapping<NoInfer<Claims>, S, C, Session, F, P, NativeId, NativeSessionId>;
   readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
   readonly repository: SuppliedService<RepositoryId, SessionRepository>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, PersistenceId | RepositoryId | TxId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgSignedSessionValidity<TargetId, D extends Database, S extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgSignedSessionValidity<TargetId, D extends Database, S extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>;
   readonly target: SuppliedService<TargetId, SignedSessionValidity>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgSignedSessionValidity<TargetId, D extends Database, S extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgSignedSessionValidity<TargetId, D extends Database, S extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>;
   readonly target: SuppliedService<TargetId, SignedSessionValidity>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
-declare const makePgSessionStepUpServices: <Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId>(database: Database, mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>, target: Context.Service<Id, SessionStepUpPersistence<Claims>>) => Effect.Effect<{
+export declare const makePgSessionStepUpServices: <Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId>(database: Database, mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>, target: Context.Service<Id, SessionStepUpPersistence<Claims>>) => Effect.Effect<{
   sessionStepUpPersistence: SessionStepUpPersistence<Claims>;
 }, never, LifecycleHooks>;
-declare function coordinatePgSessionStepUp<Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, D extends Database, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgSessionStepUp<Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, D extends Database, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>;
   readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, Id> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinatePgSessionStepUp<Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, D extends Database, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgSessionStepUp<Claims, Id, S extends AnyPgTable, C extends AnyPgTable, I extends AnyPgTable, Session extends AnyPgTable, T extends AnyPgTable, NativeId, NativeSessionId, D extends Database, A, E, R, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>;
   readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, Id | TxId> | LifecycleHooks | DatabaseRequirements>;
 //#endregion
-export { coordinatePgAuthenticationAuthority, coordinatePgPendingAuthentication, coordinatePgSessionStepUp, coordinatePgSignedSessionValidity, coordinatePgStatefulSessions, makePgAuthenticationAuthorityServices, makePgPendingAuthenticationServices, makePgSessionStepUpServices, makePgSignedSessionValidityServices, makePgStatefulSessionServices };
 //# sourceMappingURL=pg-sessions.d.mts.map

package/dist/drizzle/pg.d.mts

@@ -15,7 +15,7 @@ import { SqlError } from "effect/unstable/sql/SqlError";
 //#region src/drizzle/pg.d.ts
 type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
 type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
-declare const makePgAuthStoreServices: <C extends AnyPgTable, R extends AnyPgTable>(database: Database, mapping: AuthStoreTables<C, R>) => {
+export declare const makePgAuthStoreServices: <C extends AnyPgTable, R extends AnyPgTable>(database: Database, mapping: AuthStoreTables<C, R>) => {
   readonly authStore: {
     readonly issueChallenge: (input: NewChallenge) => Effect.Effect<void, import("@yielded/auth/AuthStore").IssueChallengeError>;
     readonly consumeChallenge: (input: ConsumeChallenge) => Effect.Effect<VerifiedEmail, EmailOtpRejected | AuthStoreError>;
@@ -28,7 +28,7 @@ declare const makePgAuthStoreServices: <C extends AnyPgTable, R extends AnyPgTab
     readonly consumeRegistration: (input: ConsumeRegistration) => Effect.Effect<ConsumeDecision<void>, AuthStoreError, never>;
   };
 };
-declare const makePgOAuthStateServices: <S extends AnyPgTable>(database: Database, mapping: OAuthStateTables<S>) => {
+export declare const makePgOAuthStateServices: <S extends AnyPgTable>(database: Database, mapping: OAuthStateTables<S>) => {
   readonly oauthStateStore: {
     readonly issue: (state: OAuthState) => Effect.Effect<void, AuthStoreError>;
     readonly consume: (stateDigest: TokenDigest) => Effect.Effect<OAuthState, InvalidOAuthState | AuthStoreError>;
@@ -42,40 +42,39 @@ declare const makePgOAuthStateServices: <S extends AnyPgTable>(database: Databas
  * owner; interruption before commit rolls back. Retry an unknown commit outcome
  * only with the same stable request identity.
  */
-declare function coordinatePgAuthStoreTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthStoreTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthStoreTables<C, R>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions> | DatabaseRequirements>;
-declare function coordinatePgAuthStoreTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthStoreTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthStoreTables<C, R>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | TxId> | DatabaseRequirements>;
-declare function coordinatePgOAuthStateTransaction<D extends Database, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgOAuthStateTransaction<D extends Database, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: OAuthStateTables<S>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, OAuthStateDecisions> | DatabaseRequirements>;
-declare function coordinatePgOAuthStateTransaction<D extends Database, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgOAuthStateTransaction<D extends Database, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: OAuthStateTables<S>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, OAuthStateDecisions | TxId> | DatabaseRequirements>;
-declare function coordinatePgAuthTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthTables<C, R, S>;
   readonly transaction?: never;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | OAuthStateDecisions> | DatabaseRequirements>;
-declare function coordinatePgAuthTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinatePgAuthTransaction<D extends Database, C extends AnyPgTable, R extends AnyPgTable, S extends AnyPgTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: AuthTables<C, R, S>;
   readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
 }, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | OAuthStateDecisions | TxId> | DatabaseRequirements>;
-declare const makePgSubjectProvisioningServices: <Subject extends AnyPgTable, Identifier extends AnyPgTable, Request extends AnyPgTable, NativeId>(database: Database, mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>) => {
+export declare const makePgSubjectProvisioningServices: <Subject extends AnyPgTable, Identifier extends AnyPgTable, Request extends AnyPgTable, NativeId>(database: Database, mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>) => {
   readonly subjectProvisioner: {
     readonly provision: (input: SubjectProvisioningInput) => Effect.Effect<import("@yielded/auth/Identity").ProvisioningResult, IdentityConflict | IdentityUnavailable>;
   };
 };
-declare const makePgExternalIdentityServices: <Subject extends AnyPgTable, External extends AnyPgTable, NativeId>(database: Database, mapping: ExternalIdentityTables<Subject, External, NativeId>) => {
+export declare const makePgExternalIdentityServices: <Subject extends AnyPgTable, External extends AnyPgTable, NativeId>(database: Database, mapping: ExternalIdentityTables<Subject, External, NativeId>) => {
   readonly externalIdentityMutation: {
     readonly bind: (subjectId: SubjectId, identity: ExternalIdentity) => Effect.Effect<void, IdentityConflict | IdentityUnavailable>;
   };
 };
 //#endregion
-export { coordinatePgAuthStoreTransaction, coordinatePgAuthTransaction, coordinatePgOAuthStateTransaction, makePgAuthStoreServices, makePgExternalIdentityServices, makePgOAuthStateServices, makePgSubjectProvisioningServices };
 //# sourceMappingURL=pg.d.mts.map

package/dist/drizzle/phone-model.d.mts

@@ -9,13 +9,13 @@ import { InferInsertModel, InferSelectModel, SQL, Table } from "drizzle-orm";
 //#region src/drizzle/phone-model.d.ts
 declare const proofMapping: unique symbol;
 /** Opaque same-owner proof mapping. The builder preserves the consumer's table codecs. */
-interface PhoneProofCompletionMapping {
+export interface PhoneProofCompletionMapping {
   readonly [proofMapping]: AnyProofPersistenceMapping;
 }
-declare const phoneProofCompletionMapping: <Rq extends Table, S extends Table, G extends Table, Cn extends Table, Rs extends Table, A extends Table, F extends Table, C extends Table, Sub extends Table, I extends Table, Cr extends Table, N>(mapping: ProofPersistenceMapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, N>) => PhoneProofCompletionMapping;
-type PhoneColumn<T extends Table> = Extract<keyof T["_"]["columns"], string>;
-type PhoneMappingSource<M, R = never> = M | Effect.Effect<M, PersistenceMappingError, R>;
-declare const requiredPhoneConstraints: {
+export declare const phoneProofCompletionMapping: <Rq extends Table, S extends Table, G extends Table, Cn extends Table, Rs extends Table, A extends Table, F extends Table, C extends Table, Sub extends Table, I extends Table, Cr extends Table, N>(mapping: ProofPersistenceMapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, N>) => PhoneProofCompletionMapping;
+export type PhoneColumn<T extends Table> = Extract<keyof T["_"]["columns"], string>;
+export type PhoneMappingSource<M, R = never> = M | Effect.Effect<M, PersistenceMappingError, R>;
+export declare const requiredPhoneConstraints: {
   readonly subject: "unique(id)";
   readonly identifier: "unique(namespace,value)";
   readonly credential: "unique(credentialId)";
@@ -26,7 +26,7 @@ declare const requiredPhoneConstraints: {
  * counters. Never delete custody rows to make a recycled number eligible. A consumer's
  * explicit recovery workflow may resolve custody only after independent authentication.
  * Subject defaults own account provisioning; no email/profile schema is prescribed. */
-interface PhoneMapping<S extends Table, I extends Table, C extends Table, T extends Table, N> {
+export interface PhoneMapping<S extends Table, I extends Table, C extends Table, T extends Table, N> {
   readonly moduleId: string;
   readonly policy: PhoneLifecyclePolicy;
   readonly admission: PhoneAdmissionPolicy;
@@ -98,18 +98,17 @@ interface PhoneMapping<S extends Table, I extends Table, C extends Table, T exte
   readonly encodeInstant: (millis: number) => unknown;
   readonly engineNowMillis: SQL;
 }
-interface D1PhoneMapping {
+export interface D1PhoneMapping {
   readonly d1: {
     readonly primary: true;
   };
 }
-interface PhonePersistenceServices {
+export interface PhonePersistenceServices {
   readonly phonePersistence: PhonePersistence["Service"];
   readonly phoneAdmission: PhoneAdmission["Service"];
   readonly phoneSignInTargets: PhoneSignInTargets["Service"];
 }
 /** Bundle phone storage, admission, and lookup with overridable crypto and hook defaults. */
-declare const phonePersistenceLayer: <E, R>(services: Effect.Effect<PhonePersistenceServices, E, R>) => Layer.Layer<PhoneAdmission | PhonePersistence | PhoneSignInTargets, E, Exclude<Exclude<R, import("effect/Scope").Scope>, import("effect/Crypto").Crypto | import("@yielded/auth/Hooks").LifecycleHooks | import("@yielded/auth/WebCrypto").SubtleCrypto>>;
+export declare const phonePersistenceLayer: <E, R>(services: Effect.Effect<PhonePersistenceServices, E, R>) => Layer.Layer<PhoneAdmission | PhonePersistence | PhoneSignInTargets, E, Exclude<Exclude<R, import("effect/Scope").Scope>, import("effect/Crypto").Crypto | import("@yielded/auth/Hooks").LifecycleHooks | import("@yielded/auth/WebCrypto").SubtleCrypto>>;
 //#endregion
-export { D1PhoneMapping, PhoneColumn, PhoneMapping, PhoneMappingSource, PhonePersistenceServices, PhoneProofCompletionMapping, phonePersistenceLayer, phoneProofCompletionMapping, requiredPhoneConstraints };
 //# sourceMappingURL=phone-model.d.mts.map

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

@@ -11,7 +11,6 @@ import { PhoneAdmission, PhoneConfigurationError, PhoneOtpUnavailable, PhonePers
 import { Table } from "drizzle-orm";
 import { Statement } from "effect/unstable/sql/Statement";
 //#region src/drizzle/phone-target.d.ts
-type PhoneCoordinatorError<E> = TransactionCoordinatorError<E, PhoneOtpUnavailable> | PhoneConfigurationError | PersistenceMappingError;
+export type PhoneCoordinatorError<E> = TransactionCoordinatorError<E, PhoneOtpUnavailable> | PhoneConfigurationError | PersistenceMappingError;
 //#endregion
-export { PhoneCoordinatorError };
 //# sourceMappingURL=phone-target.d.mts.map