@yielded/auth 0.1.0-beta.1

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

@@ -0,0 +1,103 @@
+import { SubjectId } from "../Schema.mjs";
+import { SecurityRevision } from "../sessions/models.mjs";
+import { LoginIdentifier } from "../identity/models.mjs";
+import { HookConfigurationError } from "../hooks/models.mjs";
+import { LifecycleHooks } from "../hooks/LifecycleHooks.mjs";
+import { PreparedCommit } from "../hooks/commit.mjs";
+import "../Hooks.mjs";
+import "../Sessions.mjs";
+import { PasswordUnavailable } from "../password/methods/errors.mjs";
+import { PasswordAttemptAdmission, PasswordAttemptDecision, PasswordAttemptId, PasswordCredentialSnapshot, PasswordMutationDecision } from "../password/methods/models.mjs";
+import { ProofCompletionInput } from "../proofs/ProofPersistence.mjs";
+import { ProofCompletionPlan } from "../proofs/completion.mjs";
+import "../Identity.mjs";
+import "../Proofs.mjs";
+import { EncodedPasswordHash } from "../password/models.mjs";
+import { PasswordAttemptPolicy } from "../password/methods/policy.mjs";
+import { PasswordMutationInput, PasswordPersistence, PreparePasswordCommit } from "../password/methods/PasswordPersistence.mjs";
+import { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model.mjs";
+import { ProofPersistenceMapping } from "./proof-model.mjs";
+import "./proof-sql.mjs";
+import "../Password.mjs";
+import "./password-sql.mjs";
+import { PasswordRegistrationAuthority } from "./password-registration.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { AnyRelations } from "drizzle-orm";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+//#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: LoginIdentifier;
+      readonly subjectId?: SubjectId;
+      readonly policy: PasswordAttemptPolicy;
+    }, prepare: PreparePasswordCommit<PasswordAttemptAdmission, A_1>) => Effect.Effect<PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly settleAttempt: <A_1>(input: {
+      readonly moduleId: string;
+      readonly attemptId: PasswordAttemptId;
+      readonly captured?: PasswordCredentialSnapshot;
+      readonly outcome: PasswordAttemptDecision;
+      readonly rehash?: {
+        readonly expectedVersion: SecurityRevision;
+        readonly expectedVerifier: import("effect/Redacted").Redacted<EncodedPasswordHash>;
+        readonly nextVerifier: import("effect/Redacted").Redacted<EncodedPasswordHash>;
+      };
+    }, prepare: PreparePasswordCommit<PasswordAttemptDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly readForSubject: (input: {
+      readonly moduleId: string;
+      readonly subjectId: SubjectId;
+    }) => Effect.Effect<import("effect/Option").Option<PasswordCredentialSnapshot>, PasswordUnavailable>;
+    readonly recoveryTarget: (input: {
+      readonly moduleId: string;
+      readonly identifier: LoginIdentifier;
+    }) => Effect.Effect<import("effect/Option").Option<PasswordCredentialSnapshot>, PasswordUnavailable>;
+    readonly addIfAbsent: <A_1>(input: PasswordMutationInput, prepare: PreparePasswordCommit<PasswordMutationDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly replaceIfCurrent: <A_1>(input: PasswordMutationInput, prepare: PreparePasswordCommit<PasswordMutationDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly checkReset: (input: ProofCompletionInput) => Effect.Effect<boolean, PasswordUnavailable>;
+    readonly resetWithProof: <A_1>(input: PasswordMutationInput & {
+      readonly completion: ProofCompletionPlan;
+    }, prepare: PreparePasswordCommit<PasswordMutationDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, PasswordUnavailable>;
+    readonly cleanupAttempts: <A_1>(input: {
+      readonly moduleId: string;
+      readonly limit: number;
+    }, prepare: PreparePasswordCommit<{
+      readonly removed: number;
+      readonly hasMore: boolean;
+    }, A_1>) => Effect.Effect<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 { PasswordPersistence } from "../password/methods/PasswordPersistence.mjs";
+import { coordinateTargetPasswordPersistence, coordinateTargetPasswordRegistration, makeTargetPasswordPersistenceServices, makeTargetPasswordRegistrationServices, sqlClientPasswordStandaloneGuard } from "./password-target.mjs";
+import { sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+//#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":["/* 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 { LifecycleHooks } from \"../hooks/LifecycleHooks\";\nimport type { HookConfigurationError } from \"../hooks/models\";\nimport type { PasswordUnavailable } from \"../password/methods/errors\";\nimport { PasswordPersistence } from \"../password/methods/PasswordPersistence\";\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":";;;;;AA8BA,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,84 @@
+import { TokenDigest } from "../Schema.mjs";
+import { HookConfigurationError } from "../hooks/models.mjs";
+import { LifecycleHooks } from "../hooks/LifecycleHooks.mjs";
+import { PreparedCommit } from "../hooks/commit.mjs";
+import "../Hooks.mjs";
+import { ProofAttemptDecision, ProofBinding, ProofCleanupResult, ProofCompletionDecision, ProofContinuationId, ProofDeliveryId, ProofDeliveryOutcome, ProofId, ProofPurpose, ProofVersion } from "../proofs/models.mjs";
+import { ProofRequestConflict, ProofUnavailable } from "../proofs/errors.mjs";
+import { ProofPolicy } from "../proofs/policy.mjs";
+import { PrepareProofCommit, ProofCompletionInput, ProofDeliveryClaim, ProofDigest, ProofIssueDecision, ProofPersistence, ProofRecord } from "../proofs/ProofPersistence.mjs";
+import "../Proofs.mjs";
+import { ProofPersistenceMapping } from "./proof-model.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Effect } from "effect";
+import { AnyRelations } from "drizzle-orm";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+//#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: ProofRecord;
+      readonly policy: ProofPolicy;
+      readonly eligible: boolean;
+      readonly supersedes?: ProofId;
+    }, prepare: PrepareProofCommit<ProofIssueDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofRequestConflict | ProofUnavailable>;
+    readonly attempt: <A_1>(input: {
+      readonly moduleId: string;
+      readonly purpose: ProofPurpose;
+      readonly proofId: ProofId;
+      readonly binding: ProofBinding;
+      readonly candidate?: ProofDigest;
+      readonly continuationId: ProofContinuationId;
+      readonly continuationDigest: TokenDigest;
+      readonly nowMillis: number;
+      readonly policy: ProofPolicy;
+    }, prepare: PrepareProofCommit<ProofAttemptDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofUnavailable>;
+    readonly complete: <A_1>(input: ProofCompletionInput, prepare: PrepareProofCommit<ProofCompletionDecision, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofUnavailable>;
+    readonly claimDelivery: <A_1>(input: {
+      readonly moduleId: string;
+      readonly proofId: ProofId;
+      readonly version: ProofVersion;
+      readonly deliveryId: ProofDeliveryId;
+      readonly nowMillis: number;
+      readonly policy: ProofPolicy;
+      readonly allowAmbiguousRetry: boolean;
+    }, prepare: PrepareProofCommit<ProofDeliveryClaim, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofUnavailable>;
+    readonly settleDelivery: <A_1>(input: {
+      readonly moduleId: string;
+      readonly proofId: ProofId;
+      readonly version: ProofVersion;
+      readonly deliveryId: ProofDeliveryId;
+      readonly claimVersion: ProofVersion;
+      readonly outcome: ProofDeliveryOutcome;
+      readonly nowMillis: number;
+    }, prepare: PrepareProofCommit<void, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofUnavailable>;
+    readonly cancel: <A_1>(input: {
+      readonly moduleId: string;
+      readonly purpose: ProofPurpose;
+      readonly binding: ProofBinding;
+      readonly nowMillis: number;
+    }, prepare: PrepareProofCommit<void, A_1>) => Effect.Effect<PreparedCommit<A_1>, ProofUnavailable>;
+    readonly cleanup: <A_1>(input: {
+      readonly moduleId: string;
+      readonly nowMillis: number;
+      readonly limit: number;
+    }, prepare: PrepareProofCommit<ProofCleanupResult, A_1>) => Effect.Effect<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 { ProofPersistence } from "../proofs/ProofPersistence.mjs";
+import { coordinateTargetProofPersistence, makeTargetProofPersistenceServices, sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+//#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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pg-proofs.mjs","names":[],"sources":["../../src/drizzle/pg-proofs.ts"],"sourcesContent":["import 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 { LifecycleHooks } from \"../hooks/LifecycleHooks\";\nimport type { HookConfigurationError } from \"../hooks/models\";\nimport type { ProofUnavailable } from \"../proofs/errors\";\nimport { ProofPersistence } from \"../proofs/ProofPersistence\";\nimport type { ProofPersistenceMapping } from \"./proof-model\";\nimport type { ProofSqlQuery } from \"./proof-sql\";\nimport {\n  coordinateTargetProofPersistence,\n  makeTargetProofPersistenceServices,\n  sqlClientProofStandaloneGuard,\n} 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 Mapping<\n  Request extends AnyPgTable,\n  Series extends AnyPgTable,\n  Generation extends AnyPgTable,\n  Continuation extends AnyPgTable,\n  RateScope extends AnyPgTable,\n  AbuseEvent extends AnyPgTable,\n  FailureEvent extends AnyPgTable,\n  Command extends AnyPgTable,\n  Subject extends AnyPgTable,\n  Identifier extends AnyPgTable,\n  Credential extends AnyPgTable,\n  NativeSubjectId,\n> = ProofPersistenceMapping<\n  Request,\n  Series,\n  Generation,\n  Continuation,\n  RateScope,\n  AbuseEvent,\n  FailureEvent,\n  Command,\n  Subject,\n  Identifier,\n  Credential,\n  NativeSubjectId\n>;\n\nconst configuration = (database: Database) => ({\n  mode: \"interactive\" as const,\n  locking: true,\n  standaloneGuard: sqlClientProofStandaloneGuard(database),\n  insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),\n});\n\nexport const makePgProofPersistenceServices = <\n  Rq extends AnyPgTable,\n  S extends AnyPgTable,\n  G extends AnyPgTable,\n  Cn extends AnyPgTable,\n  Rs extends AnyPgTable,\n  A extends AnyPgTable,\n  F extends AnyPgTable,\n  C extends AnyPgTable,\n  Sub extends AnyPgTable,\n  I extends AnyPgTable,\n  Cr extends AnyPgTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>,\n) => makeTargetProofPersistenceServices(database, mapping, configuration(database));\n\nexport function coordinatePgProofPersistence<\n  D extends Database,\n  Rq extends AnyPgTable,\n  S extends AnyPgTable,\n  G extends AnyPgTable,\n  Cn extends AnyPgTable,\n  Rs extends AnyPgTable,\n  Aev extends AnyPgTable,\n  F extends AnyPgTable,\n  C extends AnyPgTable,\n  Sub extends AnyPgTable,\n  I extends AnyPgTable,\n  Cr extends AnyPgTable,\n  NativeId,\n  A,\n  E,\n  R,\n  DatabaseError,\n  DatabaseRequirements,\n>(\n  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,\n  options: {\n    readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;\n    readonly transaction?: never;\n  },\n  body: Effect.Effect<A, E, R>,\n): Effect.Effect<\n  A,\n  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, ProofPersistence> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgProofPersistence<\n  D extends Database,\n  Rq extends AnyPgTable,\n  S extends AnyPgTable,\n  G extends AnyPgTable,\n  Cn extends AnyPgTable,\n  Rs extends AnyPgTable,\n  Aev extends AnyPgTable,\n  F extends AnyPgTable,\n  C extends AnyPgTable,\n  Sub extends AnyPgTable,\n  I extends AnyPgTable,\n  Cr extends AnyPgTable,\n  NativeId,\n  A,\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: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;\n    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<A, E, R>,\n): Effect.Effect<\n  A,\n  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, ProofPersistence | TxId> | LifecycleHooks | DatabaseRequirements\n>;\n\nexport function coordinatePgProofPersistence<\n  D extends Database,\n  Rq extends AnyPgTable,\n  S extends AnyPgTable,\n  G extends AnyPgTable,\n  Cn extends AnyPgTable,\n  Rs extends AnyPgTable,\n  Aev extends AnyPgTable,\n  F extends AnyPgTable,\n  C extends AnyPgTable,\n  Sub extends AnyPgTable,\n  I extends AnyPgTable,\n  Cr extends AnyPgTable,\n  NativeId,\n  A,\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: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;\n    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;\n  },\n  body: Effect.Effect<A, E, R>,\n): Effect.Effect<\n  A,\n  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,\n  Exclude<R, ProofPersistence> | LifecycleHooks | DatabaseRequirements\n> {\n  return Effect.flatMap(acquire, (database) =>\n    coordinateTargetProofPersistence<TransactionOf<D>, A, E, Exclude<R, ProofPersistence>>(\n      database,\n      options.mapping,\n      configuration(database),\n      (\n        transaction: TransactionOf<D>,\n        services: { readonly proofPersistence: ProofPersistence[\"Service\"] },\n      ) => {\n        const provided = Context.make(ProofPersistence, services.proofPersistence);\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":";;;;AAkDA,MAAM,iBAAiB,cAAwB;CAC7C,MAAM;CACN,SAAS;CACT,iBAAiB,8BAA8B,QAAQ;CACvD,iBAAiB,UAAyB,MAAM,oBAAoB;AACtE;AAEA,MAAa,kCAcX,UACA,YACG,mCAAmC,UAAU,SAAS,cAAc,QAAQ,CAAC;AAoElF,SAAgB,6BAsBd,SACA,SAIA,MAKA;CACA,OAAO,OAAO,QAAQ,UAAU,aAC9B,iCACE,UACA,QAAQ,SACR,cAAc,QAAQ,IAEpB,aACA,aACG;EACH,MAAM,WAAW,QAAQ,KAAK,kBAAkB,SAAS,gBAAgB;EACzE,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-sessions.d.mts

@@ -0,0 +1,251 @@
+import { SubjectId, TokenDigest } from "../Schema.mjs";
+import { AuthenticationAssurance } from "../operations/context.mjs";
+import { AuthenticationEvidence, PendingConsumption, SecurityRevision, SessionCredentialVersion, SessionId } from "../sessions/models.mjs";
+import { HookConfigurationError } from "../hooks/models.mjs";
+import { LifecycleHooks } from "../hooks/LifecycleHooks.mjs";
+import { PreparedCommit } from "../hooks/commit.mjs";
+import { PrepareSessionCommit } from "../sessions/commit.mjs";
+import { PendingAuthenticationInvalid, SessionConflict, SessionInvalid, SessionUnavailable, StaleAuthentication } from "../sessions/errors.mjs";
+import { AuthenticationAuthority } from "../sessions/AuthenticationAuthority.mjs";
+import { PendingAuthentication, PendingAuthenticationRecord } from "../sessions/PendingAuthentication.mjs";
+import "../Operations.mjs";
+import { SessionRepository, SignedSessionValidity, StatefulSessionPersistence, StatefulSessionRecord } from "../sessions/persistence.mjs";
+import { SessionStepUpPersistence } from "../sessions/SessionStepUpPersistence.mjs";
+import "../Hooks.mjs";
+import "../Sessions.mjs";
+import { AuthenticationAuthorityMapping, PendingAuthenticationMapping, SignedSessionValidityMapping, StatefulSessionMapping } from "./session-model.mjs";
+import { SessionStepUpMapping } from "./step-up-model.mjs";
+import { SuppliedService } from "./SuppliedService.mjs";
+import { Context, Effect } from "effect";
+import { AnyRelations } from "drizzle-orm";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
+import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
+//#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<{
+  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">;
+      securityRevision: SecurityRevision;
+      credentials: {
+        credentialId: any;
+        revision: any;
+      }[];
+    }, SessionUnavailable | StaleAuthentication, never>;
+    requirements: (evidence: {
+      readonly revision: {
+        readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+        readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        readonly credentials: readonly {
+          readonly credentialId: string;
+          readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        }[];
+      };
+      readonly flowId: string & import("effect/Brand").Brand<"effect-auth/AuthenticationFlowId">;
+      readonly bindingDigest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">;
+      readonly proofs: readonly [{
+        readonly method: string;
+        readonly credentialId: string;
+        readonly factors: readonly ("inherence" | "knowledge" | "possession")[];
+        readonly userVerified: boolean;
+        readonly phishingResistant: boolean;
+        readonly verifiedAt: import("effect/DateTime").Utc;
+      }, ...{
+        readonly method: string;
+        readonly credentialId: string;
+        readonly factors: readonly ("inherence" | "knowledge" | "possession")[];
+        readonly userVerified: boolean;
+        readonly phishingResistant: boolean;
+        readonly verifiedAt: import("effect/DateTime").Utc;
+      }[]];
+    }) => Effect.Effect<{
+      readonly alternatives: readonly [{
+        readonly factors: readonly ("inherence" | "knowledge" | "possession")[];
+        readonly userVerified: boolean;
+        readonly phishingResistant: boolean;
+        readonly minimumCredentials: number;
+      }, ...{
+        readonly factors: readonly ("inherence" | "knowledge" | "possession")[];
+        readonly userVerified: boolean;
+        readonly phishingResistant: boolean;
+        readonly minimumCredentials: number;
+      }[]];
+      readonly maximumAgeMillis: number;
+    }, SessionUnavailable | StaleAuthentication, never>;
+    approve: <A>(input: {
+      readonly evidence: AuthenticationEvidence;
+      readonly now: import("effect/DateTime").Utc;
+      readonly expiresAt: import("effect/DateTime").Utc;
+      readonly absoluteExpiresAt: import("effect/DateTime").Utc;
+      readonly pending?: PendingConsumption;
+    }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, PendingAuthenticationInvalid | SessionUnavailable | 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<{
+  pendingAuthentication: {
+    create: <A>(input: Omit<PendingAuthenticationRecord<Claims>, "version">, now: import("effect/DateTime").Utc, prepare: PrepareSessionCommit<PendingAuthenticationRecord<Claims>, A>) => Effect.Effect<PreparedCommit<A>, SessionConflict | SessionUnavailable | StaleAuthentication, never>;
+    context: (input: {
+      readonly digest: TokenDigest;
+      readonly now: import("effect/DateTime").Utc;
+    }) => Effect.Effect<Readonly<{
+      flowId: string & import("effect/Brand").Brand<"effect-auth/AuthenticationFlowId">;
+      bindingDigest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">;
+      expiresAtMillis: number;
+      revision: Readonly<{
+        subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+        securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        credentials: readonly Readonly<{
+          credentialId: string;
+          revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        }>[];
+      }>;
+    }>, PendingAuthenticationInvalid | SessionUnavailable, never>;
+    read: (input: {
+      readonly digest: TokenDigest;
+      readonly bindingDigest: TokenDigest;
+      readonly now: import("effect/DateTime").Utc;
+    }) => Effect.Effect<PendingAuthenticationRecord<Claims>, PendingAuthenticationInvalid | SessionUnavailable, never>;
+    reject: <A>(input: {
+      readonly digest: TokenDigest;
+      readonly bindingDigest: TokenDigest;
+      readonly now: import("effect/DateTime").Utc;
+    }, prepare: PrepareSessionCommit<{
+      readonly _tag: "Rejected";
+    }, A>) => Effect.Effect<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<{
+  statefulSessionPersistence: {
+    establish: <A>(input: {
+      readonly session: Omit<StatefulSessionRecord<Claims>, "sessionId" | "version">;
+      readonly evidence: AuthenticationEvidence;
+      readonly pending?: PendingConsumption;
+      readonly now: import("effect/DateTime").Utc;
+    }, prepare: PrepareSessionCommit<StatefulSessionRecord<Claims>, A>) => Effect.Effect<PreparedCommit<A>, PendingAuthenticationInvalid | SessionConflict | SessionUnavailable | StaleAuthentication, never>;
+    verify: (input: {
+      readonly digest: TokenDigest;
+      readonly now: import("effect/DateTime").Utc;
+    }) => Effect.Effect<StatefulSessionRecord<Claims>, SessionInvalid | SessionUnavailable, never>;
+    rotate: <A>(input: {
+      readonly sessionId: SessionId;
+      readonly expectedDigest: TokenDigest;
+      readonly expectedVersion: SecurityRevision;
+      readonly expectedSecurityRevision: SecurityRevision;
+      readonly nextDigest: TokenDigest;
+      readonly nextCredentialVersion: SessionCredentialVersion;
+      readonly nextExpiresAt: import("effect/DateTime").Utc;
+      readonly now: import("effect/DateTime").Utc;
+    }, prepare: PrepareSessionCommit<StatefulSessionRecord<Claims>, A>) => Effect.Effect<PreparedCommit<A>, SessionConflict | SessionUnavailable, never>;
+    revokeDigest: <A>(digest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">, prepare: PrepareSessionCommit<boolean, A>) => Effect.Effect<PreparedCommit<A>, SessionUnavailable, never>;
+    revoke: <A>(input: {
+      readonly subjectId: SubjectId;
+      readonly sessionId: SessionId;
+      readonly expectedSecurityRevision: SecurityRevision;
+    }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, SessionUnavailable | StaleAuthentication, never>;
+    revokeAll: <A>(input: {
+      readonly subjectId: SubjectId;
+      readonly expectedSecurityRevision: SecurityRevision;
+    }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, SessionUnavailable | StaleAuthentication, never>;
+  };
+  sessionRepository: {
+    list: (input: {
+      readonly subjectId: SubjectId;
+      readonly cursor?: string;
+      readonly limit: number;
+      readonly now: import("effect/DateTime").Utc;
+    }) => Effect.Effect<{
+      sessions: {
+        readonly sessionId: string & import("effect/Brand").Brand<"effect-auth/SessionId">;
+        readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+        readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        readonly assurance: AuthenticationAssurance;
+        readonly issuedAt: import("effect/DateTime").Utc;
+        readonly expiresAt: import("effect/DateTime").Utc;
+        readonly absoluteExpiresAt: import("effect/DateTime").Utc;
+      }[];
+      nextCursor?: (string & import("effect/Brand").Brand<"effect-auth/SessionId">) | undefined;
+    }, 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<{
+  signedSessionValidity: {
+    verify: (session: {
+      readonly sessionId: string & import("effect/Brand").Brand<"effect-auth/SessionId">;
+      readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+      readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      readonly assurance: AuthenticationAssurance;
+      readonly issuedAt: import("effect/DateTime").Utc;
+      readonly expiresAt: import("effect/DateTime").Utc;
+      readonly absoluteExpiresAt: import("effect/DateTime").Utc;
+    }, now: import("effect/DateTime").Utc) => Effect.Effect<undefined, SessionInvalid | SessionUnavailable, never>;
+    revoke: <A>(input: {
+      readonly subjectId: SubjectId;
+      readonly sessionId: SessionId;
+      readonly absoluteExpiresAt: import("effect/DateTime").Utc;
+      readonly expectedSecurityRevision: SecurityRevision;
+    }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, SessionUnavailable | StaleAuthentication, never>;
+    revokeAll: <A>(input: {
+      readonly subjectId: SubjectId;
+      readonly expectedSecurityRevision: SecurityRevision;
+    }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, SessionUnavailable | 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: {
+  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: {
+  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: {
+  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: {
+  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: {
+  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: {
+  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: {
+  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: {
+  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<{
+  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: {
+  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: {
+  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-sessions.mjs

@@ -0,0 +1,53 @@
+import { AuthenticationAuthority } from "../sessions/AuthenticationAuthority.mjs";
+import { coordinateTargetAuthenticationAuthority, coordinateTargetPendingAuthentication, coordinateTargetSessionStepUp, coordinateTargetSignedSessionValidity, coordinateTargetStatefulSessions, makeTargetAuthenticationAuthorityServices, makeTargetPendingAuthenticationServices, makeTargetSessionStepUpServices, makeTargetSignedSessionValidityServices, makeTargetStatefulSessionServices, sqlClientSessionStandaloneGuard } from "./session-target.mjs";
+import { Context, Effect } from "effect";
+//#region src/drizzle/pg-sessions.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientSessionStandaloneGuard(database)
+});
+const makePgAuthenticationAuthorityServices = (database, mapping) => makeTargetAuthenticationAuthorityServices(database, mapping, configuration(database));
+const makePgPendingAuthenticationServices = (database, mapping) => makeTargetPendingAuthenticationServices(database, mapping, configuration(database));
+const makePgStatefulSessionServices = (database, mapping) => makeTargetStatefulSessionServices(database, mapping, configuration(database));
+const makePgSignedSessionValidityServices = (database, mapping) => makeTargetSignedSessionValidityServices(database, mapping, configuration(database));
+function coordinatePgAuthenticationAuthority(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetAuthenticationAuthority(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(AuthenticationAuthority, services.authenticationAuthority);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+function coordinatePgPendingAuthentication(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetPendingAuthentication(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.target, services.pendingAuthentication);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+function coordinatePgStatefulSessions(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetStatefulSessions(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.persistence, services.statefulSessionPersistence).pipe(Context.add(options.repository, services.sessionRepository));
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+function coordinatePgSignedSessionValidity(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetSignedSessionValidity(database, options.mapping, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.target, services.signedSessionValidity);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+const makePgSessionStepUpServices = (database, mapping, target) => makeTargetSessionStepUpServices(database, mapping, target, configuration(database));
+function coordinatePgSessionStepUp(acquire, options, body) {
+	return Effect.flatMap(acquire, (database) => coordinateTargetSessionStepUp(database, options.mapping, options.target, configuration(database), (transaction, services) => {
+		const provided = Context.make(options.target, services.sessionStepUpPersistence);
+		const work = Effect.provideContext(body, provided);
+		return options.transaction === void 0 ? work : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+	}));
+}
+//#endregion
+export { coordinatePgAuthenticationAuthority, coordinatePgPendingAuthentication, coordinatePgSessionStepUp, coordinatePgSignedSessionValidity, coordinatePgStatefulSessions, makePgAuthenticationAuthorityServices, makePgPendingAuthenticationServices, makePgSessionStepUpServices, makePgSignedSessionValidityServices, makePgStatefulSessionServices };
+
+//# sourceMappingURL=pg-sessions.mjs.map