@yielded/auth 0.1.0-beta.1

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

@@ -0,0 +1,102 @@
+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 { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { AnyMySqlTable } from "drizzle-orm/mysql-core";
+//#region src/drizzle/mysql-passwords.d.ts
+type Database = EffectMysql2Database<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+type Mapping<S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, A extends AnyMySqlTable, RS extends AnyMySqlTable, CE extends AnyMySqlTable, M extends AnyMySqlTable, NativeId> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+declare const makeMysqlPasswordPersistenceServices: <S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, A extends AnyMySqlTable, RS extends AnyMySqlTable, CE extends AnyMySqlTable, M extends AnyMySqlTable, NativeId>(database: Database, mapping: Mapping<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 coordinateMysqlPasswordPersistence<D extends Database, S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, A extends AnyMySqlTable, RS extends AnyMySqlTable, CE extends AnyMySqlTable, M extends AnyMySqlTable, 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: Mapping<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 coordinateMysqlPasswordPersistence<D extends Database, S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, A extends AnyMySqlTable, RS extends AnyMySqlTable, CE extends AnyMySqlTable, M extends AnyMySqlTable, 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: Mapping<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 makeMysqlPasswordRegistrationServices: <Registration, S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, Rq extends AnyMySqlTable, NativeId>(database: Database, mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>) => Effect.Effect<{
+  registrationAuthority: PasswordRegistrationAuthority<Registration>;
+}, never, LifecycleHooks>;
+declare function coordinateMysqlPasswordRegistration<TargetId, Registration, D extends Database, S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, Rq extends AnyMySqlTable, 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 coordinateMysqlPasswordRegistration<TargetId, Registration, D extends Database, S extends AnyMySqlTable, I extends AnyMySqlTable, C extends AnyMySqlTable, AC extends AnyMySqlTable, Rq extends AnyMySqlTable, 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 { coordinateMysqlPasswordPersistence, coordinateMysqlPasswordRegistration, makeMysqlPasswordPersistenceServices, makeMysqlPasswordRegistrationServices };
+//# sourceMappingURL=mysql-passwords.d.mts.map

package/dist/drizzle/mysql-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/mysql-passwords.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientPasswordStandaloneGuard(database),
+	insertIfAbsent: (query, selfKey, selfValue) => query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),
+	generatedSubjectRows: (query) => query.$returningId(),
+	proof: {
+		mode: "interactive",
+		locking: true,
+		standaloneGuard: sqlClientProofStandaloneGuard(database),
+		insertIfAbsent: (query, selfKey, selfValue) => query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } })
+	}
+});
+const makeMysqlPasswordPersistenceServices = (database, mapping, proofMapping) => makeTargetPasswordPersistenceServices(database, mapping, configuration(database), proofMapping);
+function coordinateMysqlPasswordPersistence(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 makeMysqlPasswordRegistrationServices = (database, mapping) => makeTargetPasswordRegistrationServices(database, mapping, configuration(database));
+function coordinateMysqlPasswordRegistration(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 { coordinateMysqlPasswordPersistence, coordinateMysqlPasswordRegistration, makeMysqlPasswordPersistenceServices, makeMysqlPasswordRegistrationServices, configuration as mysqlPasswordConfiguration };
+
+//# sourceMappingURL=mysql-passwords.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql-passwords.mjs","names":[],"sources":["../../src/drizzle/mysql-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 { EffectMysql2Database } from \"drizzle-orm/effect-mysql2\";\nimport type { AnyMySqlTable } from \"drizzle-orm/mysql-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 = EffectMysql2Database<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, selfKey: string, selfValue: unknown) =>\n    query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),\n  generatedSubjectRows: (query: PasswordSqlQuery) => query.$returningId(),\n  proof: {\n    mode: \"interactive\" as const,\n    locking: true,\n    standaloneGuard: sqlClientProofStandaloneGuard(database),\n    insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>\n      query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),\n  },\n});\n\ntype Mapping<\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  RS extends AnyMySqlTable,\n  CE extends AnyMySqlTable,\n  M extends AnyMySqlTable,\n  NativeId,\n> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;\n\nexport const makeMysqlPasswordPersistenceServices = <\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  RS extends AnyMySqlTable,\n  CE extends AnyMySqlTable,\n  M extends AnyMySqlTable,\n  NativeId,\n>(\n  database: Database,\n  mapping: Mapping<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 coordinateMysqlPasswordPersistence<\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  RS extends AnyMySqlTable,\n  CE extends AnyMySqlTable,\n  M extends AnyMySqlTable,\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: Mapping<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 coordinateMysqlPasswordPersistence<\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  RS extends AnyMySqlTable,\n  CE extends AnyMySqlTable,\n  M extends AnyMySqlTable,\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: Mapping<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 coordinateMysqlPasswordPersistence<\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  RS extends AnyMySqlTable,\n  CE extends AnyMySqlTable,\n  M extends AnyMySqlTable,\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: Mapping<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 makeMysqlPasswordRegistrationServices = <\n  Registration,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  Rq extends AnyMySqlTable,\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 coordinateMysqlPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  Rq extends AnyMySqlTable,\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 coordinateMysqlPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  Rq extends AnyMySqlTable,\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 coordinateMysqlPasswordRegistration<\n  TargetId,\n  Registration,\n  D extends Database,\n  S extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  AC extends AnyMySqlTable,\n  Rq extends AnyMySqlTable,\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 mysqlPasswordConfiguration };\n"],"mappings":";;;;;AA6BA,MAAM,iBAAiB,cAAwB;CAC7C,MAAM;CACN,SAAS;CACT,iBAAiB,iCAAiC,QAAQ;CAC1D,iBAAiB,OAAyB,SAAiB,cACzD,MAAM,qBAAqB,EAAE,KAAK,GAAG,UAAU,UAAU,EAAE,CAAC;CAC9D,uBAAuB,UAA4B,MAAM,aAAa;CACtE,OAAO;EACL,MAAM;EACN,SAAS;EACT,iBAAiB,8BAA8B,QAAQ;EACvD,iBAAiB,OAAsB,SAAiB,cACtD,MAAM,qBAAqB,EAAE,KAAK,GAAG,UAAU,UAAU,EAAE,CAAC;CAChE;AACF;AAcA,MAAa,wCAWX,UACA,SACA,iBAeA,sCAAsC,UAAU,SAAS,cAAc,QAAQ,GAAG,YAAY;AAsEhG,SAAgB,mCAsBd,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,yCASX,UACA,YAEA,uCAAqD,UAAU,SAAS,cAAc,QAAQ,CAAC;AA8DjG,SAAgB,oCAkBd,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/mysql-proofs.d.mts

@@ -0,0 +1,83 @@
+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 { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { AnyMySqlTable } from "drizzle-orm/mysql-core";
+//#region src/drizzle/mysql-proofs.d.ts
+type Database = EffectMysql2Database<AnyRelations>;
+type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
+type Mapping<Rq extends AnyMySqlTable, S extends AnyMySqlTable, G extends AnyMySqlTable, Cn extends AnyMySqlTable, Rs extends AnyMySqlTable, A extends AnyMySqlTable, F extends AnyMySqlTable, C extends AnyMySqlTable, Sub extends AnyMySqlTable, I extends AnyMySqlTable, Cr extends AnyMySqlTable, NativeId> = ProofPersistenceMapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>;
+declare const makeMysqlProofPersistenceServices: <Rq extends AnyMySqlTable, S extends AnyMySqlTable, G extends AnyMySqlTable, Cn extends AnyMySqlTable, Rs extends AnyMySqlTable, A extends AnyMySqlTable, F extends AnyMySqlTable, C extends AnyMySqlTable, Sub extends AnyMySqlTable, I extends AnyMySqlTable, Cr extends AnyMySqlTable, 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 coordinateMysqlProofPersistence<D extends Database, Rq extends AnyMySqlTable, S extends AnyMySqlTable, G extends AnyMySqlTable, Cn extends AnyMySqlTable, Rs extends AnyMySqlTable, Aev extends AnyMySqlTable, F extends AnyMySqlTable, C extends AnyMySqlTable, Sub extends AnyMySqlTable, I extends AnyMySqlTable, Cr extends AnyMySqlTable, 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 coordinateMysqlProofPersistence<D extends Database, Rq extends AnyMySqlTable, S extends AnyMySqlTable, G extends AnyMySqlTable, Cn extends AnyMySqlTable, Rs extends AnyMySqlTable, Aev extends AnyMySqlTable, F extends AnyMySqlTable, C extends AnyMySqlTable, Sub extends AnyMySqlTable, I extends AnyMySqlTable, Cr extends AnyMySqlTable, 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<Transaction>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, ProofPersistence | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinateMysqlProofPersistence, makeMysqlProofPersistenceServices };
+//# sourceMappingURL=mysql-proofs.d.mts.map

package/dist/drizzle/mysql-proofs.mjs

@@ -0,0 +1,23 @@
+import { updateValues } from "./model.mjs";
+import { ProofPersistence } from "../proofs/ProofPersistence.mjs";
+import { coordinateTargetProofPersistence, makeTargetProofPersistenceServices, sqlClientProofStandaloneGuard } from "./proof-target.mjs";
+import { Context, Effect } from "effect";
+//#region src/drizzle/mysql-proofs.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientProofStandaloneGuard(database),
+	insertIfAbsent: (query, selfKey, selfValue) => query.onDuplicateKeyUpdate({ set: updateValues([[selfKey, selfValue]]) })
+});
+const makeMysqlProofPersistenceServices = (database, mapping) => makeTargetProofPersistenceServices(database, mapping, configuration(database));
+function coordinateMysqlProofPersistence(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 { coordinateMysqlProofPersistence, makeMysqlProofPersistenceServices };
+
+//# sourceMappingURL=mysql-proofs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql-proofs.mjs","names":[],"sources":["../../src/drizzle/mysql-proofs.ts"],"sourcesContent":["import type { AnyRelations } from \"drizzle-orm\";\nimport type { EffectMysql2Database } from \"drizzle-orm/effect-mysql2\";\nimport type { AnyMySqlTable } from \"drizzle-orm/mysql-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 { updateValues } from \"./model\";\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 = EffectMysql2Database<AnyRelations>;\ntype Transaction = Parameters<Parameters<Database[\"transaction\"]>[0]>[0];\ntype Mapping<\n  Rq extends AnyMySqlTable,\n  S extends AnyMySqlTable,\n  G extends AnyMySqlTable,\n  Cn extends AnyMySqlTable,\n  Rs extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  F extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  Sub extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  Cr extends AnyMySqlTable,\n  NativeId,\n> = ProofPersistenceMapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>;\n\nconst configuration = (database: Database) => ({\n  mode: \"interactive\" as const,\n  locking: true,\n  standaloneGuard: sqlClientProofStandaloneGuard(database),\n  insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>\n    query.onDuplicateKeyUpdate({\n      set: updateValues([[selfKey, selfValue]]),\n    }),\n});\n\nexport const makeMysqlProofPersistenceServices = <\n  Rq extends AnyMySqlTable,\n  S extends AnyMySqlTable,\n  G extends AnyMySqlTable,\n  Cn extends AnyMySqlTable,\n  Rs extends AnyMySqlTable,\n  A extends AnyMySqlTable,\n  F extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  Sub extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  Cr extends AnyMySqlTable,\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 coordinateMysqlProofPersistence<\n  D extends Database,\n  Rq extends AnyMySqlTable,\n  S extends AnyMySqlTable,\n  G extends AnyMySqlTable,\n  Cn extends AnyMySqlTable,\n  Rs extends AnyMySqlTable,\n  Aev extends AnyMySqlTable,\n  F extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  Sub extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  Cr extends AnyMySqlTable,\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 coordinateMysqlProofPersistence<\n  D extends Database,\n  Rq extends AnyMySqlTable,\n  S extends AnyMySqlTable,\n  G extends AnyMySqlTable,\n  Cn extends AnyMySqlTable,\n  Rs extends AnyMySqlTable,\n  Aev extends AnyMySqlTable,\n  F extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  Sub extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  Cr extends AnyMySqlTable,\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<Transaction>, 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 coordinateMysqlProofPersistence<\n  D extends Database,\n  Rq extends AnyMySqlTable,\n  S extends AnyMySqlTable,\n  G extends AnyMySqlTable,\n  Cn extends AnyMySqlTable,\n  Rs extends AnyMySqlTable,\n  Aev extends AnyMySqlTable,\n  F extends AnyMySqlTable,\n  C extends AnyMySqlTable,\n  Sub extends AnyMySqlTable,\n  I extends AnyMySqlTable,\n  Cr extends AnyMySqlTable,\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<Transaction>, 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<Transaction, A, E, Exclude<R, ProofPersistence>>(\n      database,\n      options.mapping,\n      configuration(database),\n      (\n        transaction: Transaction,\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":";;;;;AAqCA,MAAM,iBAAiB,cAAwB;CAC7C,MAAM;CACN,SAAS;CACT,iBAAiB,8BAA8B,QAAQ;CACvD,iBAAiB,OAAsB,SAAiB,cACtD,MAAM,qBAAqB,EACzB,KAAK,aAAa,CAAC,CAAC,SAAS,SAAS,CAAC,CAAC,EAC1C,CAAC;AACL;AAEA,MAAa,qCAcX,UACA,YACG,mCAAmC,UAAU,SAAS,cAAc,QAAQ,CAAC;AAoElF,SAAgB,gCAsBd,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/mysql-sessions.d.mts

@@ -0,0 +1,250 @@
+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 { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { AnyMySqlTable } from "drizzle-orm/mysql-core";
+//#region src/drizzle/mysql-sessions.d.ts
+type Database = EffectMysql2Database<AnyRelations>;
+type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
+declare const makeMysqlAuthenticationAuthorityServices: <Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, NativeId>(database: Database, mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>) => 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 makeMysqlPendingAuthenticationServices: <Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, P extends AnyMySqlTable, F extends AnyMySqlTable, NativeId>(database: Database, mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>) => 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 makeMysqlStatefulSessionServices: <Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, Session extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, NativeId, NativeSessionId>(database: Database, mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, 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 makeMysqlSignedSessionValidityServices: <S extends AnyMySqlTable, T extends AnyMySqlTable, NativeId, NativeSessionId>(database: Database, mapping: SignedSessionValidityMapping<S, T, NativeId, 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 coordinateMysqlAuthenticationAuthority<D extends Database, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, 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 coordinateMysqlAuthenticationAuthority<D extends Database, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, 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<Transaction>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, AuthenticationAuthority | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinateMysqlPendingAuthentication<D extends Database, TargetId, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, P extends AnyMySqlTable, F extends AnyMySqlTable, 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 coordinateMysqlPendingAuthentication<D extends Database, TargetId, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, P extends AnyMySqlTable, F extends AnyMySqlTable, 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<Transaction>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinateMysqlStatefulSessions<D extends Database, PersistenceId, RepositoryId, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, Session extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, 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 coordinateMysqlStatefulSessions<D extends Database, PersistenceId, RepositoryId, Claims, S extends AnyMySqlTable, C extends AnyMySqlTable, Session extends AnyMySqlTable, F extends AnyMySqlTable, P extends AnyMySqlTable, 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<Transaction>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, PersistenceId | RepositoryId | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare function coordinateMysqlSignedSessionValidity<D extends Database, TargetId, S extends AnyMySqlTable, T extends AnyMySqlTable, 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 coordinateMysqlSignedSessionValidity<D extends Database, TargetId, S extends AnyMySqlTable, T extends AnyMySqlTable, 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<Transaction>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements>;
+declare const makeMysqlSessionStepUpServices: <Claims, Id, S extends AnyMySqlTable, C extends AnyMySqlTable, I extends AnyMySqlTable, Session extends AnyMySqlTable, T extends AnyMySqlTable, 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 coordinateMysqlSessionStepUp<Claims, Id, S extends AnyMySqlTable, C extends AnyMySqlTable, I extends AnyMySqlTable, Session extends AnyMySqlTable, T extends AnyMySqlTable, 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 coordinateMysqlSessionStepUp<Claims, Id, S extends AnyMySqlTable, C extends AnyMySqlTable, I extends AnyMySqlTable, Session extends AnyMySqlTable, T extends AnyMySqlTable, 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<Parameters<Parameters<D["transaction"]>[0]>[0]>, TxShape>;
+}, body: Effect.Effect<A, E, R>): Effect.Effect<A, E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError, Exclude<R, Id | TxId> | LifecycleHooks | DatabaseRequirements>;
+//#endregion
+export { coordinateMysqlAuthenticationAuthority, coordinateMysqlPendingAuthentication, coordinateMysqlSessionStepUp, coordinateMysqlSignedSessionValidity, coordinateMysqlStatefulSessions, makeMysqlAuthenticationAuthorityServices, makeMysqlPendingAuthenticationServices, makeMysqlSessionStepUpServices, makeMysqlSignedSessionValidityServices, makeMysqlStatefulSessionServices };
+//# sourceMappingURL=mysql-sessions.d.mts.map

package/dist/drizzle/mysql-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/mysql-sessions.ts
+const configuration = (database) => ({
+	mode: "interactive",
+	locking: true,
+	standaloneGuard: sqlClientSessionStandaloneGuard(database)
+});
+const makeMysqlAuthenticationAuthorityServices = (database, mapping) => makeTargetAuthenticationAuthorityServices(database, mapping, configuration(database));
+const makeMysqlPendingAuthenticationServices = (database, mapping) => makeTargetPendingAuthenticationServices(database, mapping, configuration(database));
+const makeMysqlStatefulSessionServices = (database, mapping) => makeTargetStatefulSessionServices(database, mapping, configuration(database));
+const makeMysqlSignedSessionValidityServices = (database, mapping) => makeTargetSignedSessionValidityServices(database, mapping, configuration(database));
+function coordinateMysqlAuthenticationAuthority(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 coordinateMysqlPendingAuthentication(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 coordinateMysqlStatefulSessions(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 coordinateMysqlSignedSessionValidity(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 makeMysqlSessionStepUpServices = (database, mapping, target) => makeTargetSessionStepUpServices(database, mapping, target, configuration(database));
+function coordinateMysqlSessionStepUp(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 { coordinateMysqlAuthenticationAuthority, coordinateMysqlPendingAuthentication, coordinateMysqlSessionStepUp, coordinateMysqlSignedSessionValidity, coordinateMysqlStatefulSessions, makeMysqlAuthenticationAuthorityServices, makeMysqlPendingAuthenticationServices, makeMysqlSessionStepUpServices, makeMysqlSignedSessionValidityServices, makeMysqlStatefulSessionServices };
+
+//# sourceMappingURL=mysql-sessions.mjs.map