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

package/dist/drizzle/d1-sessions.d.mts

@@ -16,7 +16,7 @@ import { Statement } from "effect/unstable/sql/Statement";
 type Database = D1PlanningDatabase;
 type D1DomainError = SessionStepUpInvalid | PendingAuthenticationInvalid | SessionConflict | SessionInvalid | SessionUnavailable | StaleAuthentication;
 type D1CoordinatorError<E> = E | D1DomainError | HookConfigurationError;
-declare const makeD1AuthenticationAuthorityServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId>(database: Database, mapping: D1AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId>) => Effect.Effect<{
+export declare const makeD1AuthenticationAuthorityServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId>(database: Database, mapping: D1AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId>) => Effect.Effect<{
   authenticationAuthority: {
     readonly capture: (subjectId: SubjectId, credentialIds: ReadonlyArray<string>) => Effect.Effect<AuthenticationRevision, StaleAuthentication | SessionUnavailable>;
     readonly requirements: (evidence: AuthenticationEvidence) => Effect.Effect<AuthenticationRequirement, StaleAuthentication | SessionUnavailable>;
@@ -29,39 +29,38 @@ declare const makeD1AuthenticationAuthorityServices: <Claims, Subject extends An
     }, prepare: PrepareSessionCommit<void, A>) => Effect.Effect<PreparedCommit<A>, StaleAuthentication | PendingAuthenticationInvalid | SessionUnavailable>;
   };
 }, never, LifecycleHooks>;
-declare const makeD1PendingAuthenticationServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Pending extends AnySQLiteTable, Flow extends AnySQLiteTable, NativeSubjectId>(database: Database, mapping: D1PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId>) => Effect.Effect<{
+export declare const makeD1PendingAuthenticationServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Pending extends AnySQLiteTable, Flow extends AnySQLiteTable, NativeSubjectId>(database: Database, mapping: D1PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId>) => Effect.Effect<{
   pendingAuthentication: PendingAuthentication<Claims>;
 }, never, LifecycleHooks>;
-declare const makeD1StatefulSessionServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Session extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: D1StatefulSessionMapping<Claims, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
+export declare const makeD1StatefulSessionServices: <Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Session extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: D1StatefulSessionMapping<Claims, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
   statefulSessionPersistence: StatefulSessionPersistence<Claims>;
   sessionRepository: SessionRepository;
 }, never, LifecycleHooks>;
-declare const makeD1SignedSessionValidityServices: <Subject extends AnySQLiteTable, Tombstone extends AnySQLiteTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: D1SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
+export declare const makeD1SignedSessionValidityServices: <Subject extends AnySQLiteTable, Tombstone extends AnySQLiteTable, NativeSubjectId, NativeSessionId>(database: Database, mapping: D1SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>) => Effect.Effect<{
   signedSessionValidity: SignedSessionValidity;
 }, never, LifecycleHooks>;
-declare function coordinateD1AuthenticationAuthority<Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinateD1AuthenticationAuthority<Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: D1AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, D1CoordinatorError<E> | DatabaseError, Exclude<R, AuthenticationAuthority | D1BatchStatements> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinateD1PendingAuthentication<TargetId, Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Pending extends AnySQLiteTable, Flow extends AnySQLiteTable, NativeSubjectId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinateD1PendingAuthentication<TargetId, Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Pending extends AnySQLiteTable, Flow extends AnySQLiteTable, NativeSubjectId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: D1PendingAuthenticationMapping<NoInfer<Claims>, Subject, Credential, Pending, Flow, NativeSubjectId>;
   readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, D1CoordinatorError<E> | DatabaseError, Exclude<R, TargetId | D1BatchStatements> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinateD1StatefulSessions<PersistenceId, RepositoryId, Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Session extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinateD1StatefulSessions<PersistenceId, RepositoryId, Claims, Subject extends AnySQLiteTable, Credential extends AnySQLiteTable, Session extends AnySQLiteTable, Flow extends AnySQLiteTable, Pending extends AnySQLiteTable, NativeSubjectId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: D1StatefulSessionMapping<NoInfer<Claims>, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId>;
   readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
   readonly repository: SuppliedService<RepositoryId, SessionRepository>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, D1CoordinatorError<E> | DatabaseError, Exclude<R, PersistenceId | RepositoryId | D1BatchStatements> | LifecycleHooks | DatabaseRequirements>;
-declare function coordinateD1SignedSessionValidity<TargetId, Subject extends AnySQLiteTable, Tombstone extends AnySQLiteTable, NativeSubjectId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinateD1SignedSessionValidity<TargetId, Subject extends AnySQLiteTable, Tombstone extends AnySQLiteTable, NativeSubjectId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: D1SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>;
   readonly target: SuppliedService<TargetId, SignedSessionValidity>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, D1CoordinatorError<E> | DatabaseError, Exclude<R, TargetId | D1BatchStatements> | LifecycleHooks | DatabaseRequirements>;
-declare const makeD1SessionStepUpServices: <Claims, Id, S extends AnySQLiteTable, C extends AnySQLiteTable, I extends AnySQLiteTable, Session extends AnySQLiteTable, T extends AnySQLiteTable, NativeId, NativeSessionId>(database: Database, mapping: D1SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>, target: Context.Service<Id, SessionStepUpPersistence<Claims>>) => Effect.Effect<{
+export declare const makeD1SessionStepUpServices: <Claims, Id, S extends AnySQLiteTable, C extends AnySQLiteTable, I extends AnySQLiteTable, Session extends AnySQLiteTable, T extends AnySQLiteTable, NativeId, NativeSessionId>(database: Database, mapping: D1SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>, target: Context.Service<Id, SessionStepUpPersistence<Claims>>) => Effect.Effect<{
   sessionStepUpPersistence: SessionStepUpPersistence<Claims>;
 }, never, LifecycleHooks>;
-declare function coordinateD1SessionStepUp<Claims, Id, S extends AnySQLiteTable, C extends AnySQLiteTable, I extends AnySQLiteTable, Session extends AnySQLiteTable, T extends AnySQLiteTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
+export declare function coordinateD1SessionStepUp<Claims, Id, S extends AnySQLiteTable, C extends AnySQLiteTable, I extends AnySQLiteTable, Session extends AnySQLiteTable, T extends AnySQLiteTable, NativeId, NativeSessionId, A, E, R, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: D1SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>;
   readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
 }, body: Effect.Effect<A, E, R>): Effect.Effect<A, D1CoordinatorError<E> | DatabaseError, Exclude<R, Id | D1BatchStatements> | LifecycleHooks | DatabaseRequirements>;
 //#endregion
-export { coordinateD1AuthenticationAuthority, coordinateD1PendingAuthentication, coordinateD1SessionStepUp, coordinateD1SignedSessionValidity, coordinateD1StatefulSessions, makeD1AuthenticationAuthorityServices, makeD1PendingAuthenticationServices, makeD1SessionStepUpServices, makeD1SignedSessionValidityServices, makeD1StatefulSessionServices };
 //# sourceMappingURL=d1-sessions.d.mts.map

package/dist/drizzle/d1-totp.d.mts

@@ -15,12 +15,11 @@ type Database = EffectSQLiteD1Database<AnyRelations> & {
   readonly $client: D1Client;
 };
 type Table$1 = AnySQLiteTable;
-declare const makeTotpPersistenceServices: <Database extends EffectSQLiteD1Database<import("drizzle-orm").TablesRelationalConfig> & {
+export declare const makeTotpPersistenceServices: <Database extends EffectSQLiteD1Database<import("drizzle-orm").TablesRelationalConfig> & {
   readonly $client: D1Client;
 }, S extends Table$1, F extends Table$1, C extends Table$1, N, RSetup = never>(database: Database, mapping: TotpMappingSource<TotpMapping<S, F, C, N> & D1TotpMapping, RSetup>) => Effect.Effect<TotpPersistenceServices, PersistenceMappingError | import("@yielded/auth/Totp").TotpConfigurationError, RSetup | LifecycleHooks>;
-declare const coordinateTotpPersistence: <D extends Database, S extends Table$1, F extends Table$1, C extends Table$1, N, A, E, R, RSetup = never, DatabaseError = never, DatabaseRequirements = never>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
+export declare const coordinateTotpPersistence: <D extends Database, S extends Table$1, F extends Table$1, C extends Table$1, N, A, E, R, RSetup = never, DatabaseError = never, DatabaseRequirements = never>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
   readonly mapping: TotpMappingSource<TotpMapping<S, F, C, N> & D1TotpMapping, RSetup>;
 }, body: Effect.Effect<A, E, R>) => Effect.Effect<A, TotpCoordinatorError<E> | DatabaseError, Exclude<R, TotpPersistence | D1BatchStatements> | LifecycleHooks | RSetup | DatabaseRequirements>;
 //#endregion
-export { coordinateTotpPersistence, makeTotpPersistenceServices };
 //# sourceMappingURL=d1-totp.d.mts.map

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

@@ -9,7 +9,7 @@ import { LoginIdentifier } from "@yielded/auth/Identity";
 import { InferInsertModel, InferSelectModel, SQL, Table } from "drizzle-orm";
 //#region src/drizzle/email-model.d.ts
 type ColumnKey<T extends Table> = Extract<keyof T["_"]["columns"], string>;
-interface EmailSubjectReadTable<Subject extends Table> {
+export interface EmailSubjectReadTable<Subject extends Table> {
   readonly table: Subject;
   readonly id: ColumnKey<Subject>;
   readonly status: ColumnKey<Subject>;
@@ -17,13 +17,13 @@ interface EmailSubjectReadTable<Subject extends Table> {
   readonly isActiveStatus: (value: unknown) => boolean;
   readonly d1ActiveStatusValue?: unknown;
 }
-interface EmailSubjectTable<Subject extends Table> extends EmailSubjectReadTable<Subject> {
+export interface EmailSubjectTable<Subject extends Table> extends EmailSubjectReadTable<Subject> {
   readonly decodeActionRequirement: (row: InferSelectModel<Subject>, action: EmailAction) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;
   readonly nextSecurityRevision?: (current: SecurityRevision) => Effect.Effect<SecurityRevision, PersistenceMappingError>;
   readonly nextSecurityRevisionSync?: (current: SecurityRevision) => SecurityRevision;
   readonly d1ActiveStatusValue?: unknown;
 }
-interface EmailIdentifierReadTable<Identifier extends Table> {
+export interface EmailIdentifierReadTable<Identifier extends Table> {
   readonly table: Identifier;
   readonly namespace: ColumnKey<Identifier>;
   readonly value: ColumnKey<Identifier>;
@@ -32,7 +32,7 @@ interface EmailIdentifierReadTable<Identifier extends Table> {
   readonly bindingRevision: ColumnKey<Identifier>;
   readonly isCurrent: (row: InferSelectModel<Identifier>) => boolean;
 }
-interface EmailIdentifierTable<Identifier extends Table, NativeSubjectId> extends EmailIdentifierReadTable<Identifier> {
+export interface EmailIdentifierTable<Identifier extends Table, NativeSubjectId> extends EmailIdentifierReadTable<Identifier> {
   /** True only for an active, unverified binding. Confirming it preserves existing sessions. */
   readonly isMutableTarget: (row: InferSelectModel<Identifier>) => boolean;
   readonly encodeVerifiedInsert: (input: {
@@ -60,7 +60,7 @@ interface EmailIdentifierTable<Identifier extends Table, NativeSubjectId> extend
     readonly nativeSubjectId: NativeSubjectId;
   }) => SQL;
 }
-interface EmailCredentialReadTable<Subject extends Table, Identifier extends Table, Credential extends Table, _NativeSubjectId> {
+export interface EmailCredentialReadTable<Subject extends Table, Identifier extends Table, Credential extends Table, _NativeSubjectId> {
   readonly table: Credential;
   readonly moduleId: ColumnKey<Credential>;
   readonly subjectId: ColumnKey<Credential>;
@@ -77,7 +77,7 @@ interface EmailCredentialReadTable<Subject extends Table, Identifier extends Tab
     readonly credential: InferSelectModel<Credential>;
   }) => Effect.Effect<import("@yielded/auth/Email").EmailCredentialSnapshot, PersistenceMappingError>;
 }
-interface EmailCredentialTable<Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> extends EmailCredentialReadTable<Subject, Identifier, Credential, NativeSubjectId> {
+export interface EmailCredentialTable<Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> extends EmailCredentialReadTable<Subject, Identifier, Credential, NativeSubjectId> {
   readonly encodeVerifiedInsert: (input: {
     readonly moduleId: string;
     readonly subjectId: NativeSubjectId;
@@ -95,7 +95,7 @@ interface EmailCredentialTable<Subject extends Table, Identifier extends Table,
   }) => Partial<InferInsertModel<Credential>>;
   readonly d1ActiveStatusValue?: unknown;
 }
-interface EmailAuthorityCredentialTable<Credential extends Table, NativeSubjectId> {
+export interface EmailAuthorityCredentialTable<Credential extends Table, NativeSubjectId> {
   readonly table: Credential;
   readonly subjectId: ColumnKey<Credential>;
   readonly credentialId: ColumnKey<Credential>;
@@ -111,7 +111,7 @@ interface EmailAuthorityCredentialTable<Credential extends Table, NativeSubjectI
   readonly encodeRetirement: (revision: SecurityRevision) => Partial<InferInsertModel<Credential>>;
   readonly d1ActiveStatusValue?: unknown;
 }
-interface EmailCommandTable<Command extends Table> {
+export interface EmailCommandTable<Command extends Table> {
   readonly table: Command;
   readonly moduleId: ColumnKey<Command>;
   readonly commandId: ColumnKey<Command>;
@@ -126,13 +126,13 @@ interface EmailCommandTable<Command extends Table> {
     readonly retentionUntilMillis: number;
   }) => InferInsertModel<Command>;
 }
-interface RequiredEmailSignInConstraints {
+export interface RequiredEmailSignInConstraints {
   readonly identifier: "unique(identifier.namespace,identifier.value)";
   readonly credentialId: "unique(emailCredential.moduleId,emailCredential.credentialId)";
   readonly credentialIdentifier: "unique(emailCredential.moduleId,emailCredential.identifierNamespace,emailCredential.identifierValue)";
 }
-declare const requiredEmailSignInConstraints: RequiredEmailSignInConstraints;
-interface EmailSignInMapping<Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> {
+export declare const requiredEmailSignInConstraints: RequiredEmailSignInConstraints;
+export interface EmailSignInMapping<Subject extends Table, Identifier extends Table, Credential extends Table, NativeSubjectId> {
   readonly subject: EmailSubjectReadTable<Subject>;
   readonly identifier: EmailIdentifierReadTable<Identifier>;
   readonly credential: EmailCredentialReadTable<Subject, Identifier, Credential, NativeSubjectId>;
@@ -140,17 +140,17 @@ interface EmailSignInMapping<Subject extends Table, Identifier extends Table, Cr
   readonly constraints: RequiredEmailSignInConstraints;
   readonly decodeInstant: (native: unknown) => Effect.Effect<number, PersistenceMappingError>;
 }
-interface RequiredEmailAddressConstraints extends RequiredEmailSignInConstraints {
+export interface RequiredEmailAddressConstraints extends RequiredEmailSignInConstraints {
   readonly authorityCredential: "unique(authorityCredential.subjectId,authorityCredential.credentialId)";
   readonly command: "unique(emailCommand.moduleId,emailCommand.commandId)";
 }
-declare const requiredEmailAddressConstraints: RequiredEmailAddressConstraints;
-interface EmailD1Clock {
+export declare const requiredEmailAddressConstraints: RequiredEmailAddressConstraints;
+export interface EmailD1Clock {
   readonly engineNow: SQL;
   readonly engineNowMillis: SQL;
   readonly engineInstantPlus: (millis: number) => SQL;
 }
-interface EmailAddressMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Command extends Table, NativeSubjectId> extends EmailSignInMapping<Subject, Identifier, Credential, NativeSubjectId> {
+export interface EmailAddressMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Command extends Table, NativeSubjectId> extends EmailSignInMapping<Subject, Identifier, Credential, NativeSubjectId> {
   readonly subject: EmailSubjectTable<Subject>;
   readonly identifier: EmailIdentifierTable<Identifier, NativeSubjectId>;
   readonly credential: EmailCredentialTable<Subject, Identifier, Credential, NativeSubjectId>;
@@ -171,7 +171,7 @@ interface EmailAddressMapping<Subject extends Table, Identifier extends Table, C
   readonly isCredentialConflict: (cause: unknown) => boolean;
   readonly d1?: EmailD1Clock;
 }
-type D1EmailAddressMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Command extends Table, NativeSubjectId> = EmailAddressMapping<Subject, Identifier, Credential, AuthorityCredential, Command, NativeSubjectId> & {
+export type D1EmailAddressMapping<Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Command extends Table, NativeSubjectId> = EmailAddressMapping<Subject, Identifier, Credential, AuthorityCredential, Command, NativeSubjectId> & {
   readonly d1: EmailD1Clock;
   readonly subject: EmailSubjectTable<Subject> & {
     readonly d1ActiveStatusValue: unknown;
@@ -187,8 +187,8 @@ type D1EmailAddressMapping<Subject extends Table, Identifier extends Table, Cred
     readonly d1ActiveStatusValue: unknown;
   };
 };
-type EmailRegistrationState = "pending" | "registered";
-interface EmailRegistrationIntent<Registration> {
+export type EmailRegistrationState = "pending" | "registered";
+export interface EmailRegistrationIntent<Registration> {
   readonly moduleId: string;
   readonly commandId: string;
   readonly identifier: LoginIdentifier;
@@ -201,7 +201,7 @@ interface EmailRegistrationIntent<Registration> {
     readonly binding: ProofBinding;
   };
 }
-interface EmailRegistrationTable<Registration, Request extends Table, NativeSubjectId> {
+export interface EmailRegistrationTable<Registration, Request extends Table, NativeSubjectId> {
   readonly table: Request;
   readonly moduleId: ColumnKey<Request>;
   readonly commandId: ColumnKey<Request>;
@@ -220,7 +220,7 @@ interface EmailRegistrationTable<Registration, Request extends Table, NativeSubj
     readonly _tag: "Registered";
   }>, PersistenceMappingError>;
 }
-interface EmailRegistrationProvisioning<Registration, Subject extends Table, NativeSubjectId> {
+export interface EmailRegistrationProvisioning<Registration, Subject extends Table, NativeSubjectId> {
   readonly encodeSubjectInsert: (input: EmailRegistrationIntent<Registration>, values: {
     readonly nativeSubjectId: NativeSubjectId | undefined;
     readonly securityRevision: SecurityRevision;
@@ -229,7 +229,7 @@ interface EmailRegistrationProvisioning<Registration, Subject extends Table, Nat
   readonly allocateSubjectIdSync?: () => NativeSubjectId;
   readonly decodeGeneratedId?: (rows: ReadonlyArray<unknown>) => Effect.Effect<NativeSubjectId, PersistenceMappingError>;
 }
-interface EmailRegistrationIdentifierTable<Identifier extends Table, NativeSubjectId> {
+export interface EmailRegistrationIdentifierTable<Identifier extends Table, NativeSubjectId> {
   readonly table: Identifier;
   readonly namespace: ColumnKey<Identifier>;
   readonly value: ColumnKey<Identifier>;
@@ -249,7 +249,7 @@ interface EmailRegistrationIdentifierTable<Identifier extends Table, NativeSubje
     readonly bindingRevision: SecurityRevision;
   }) => InferInsertModel<Identifier>;
 }
-interface EmailRegistrationCredentialTable<Credential extends Table, NativeSubjectId> {
+export interface EmailRegistrationCredentialTable<Credential extends Table, NativeSubjectId> {
   readonly table: Credential;
   readonly moduleId: ColumnKey<Credential>;
   readonly subjectId: ColumnKey<Credential>;
@@ -268,7 +268,7 @@ interface EmailRegistrationCredentialTable<Credential extends Table, NativeSubje
     readonly credentialRevision: SecurityRevision;
   }) => InferInsertModel<Credential>;
 }
-interface EmailRegistrationAuthorityCredentialTable<Credential extends Table, NativeSubjectId> {
+export interface EmailRegistrationAuthorityCredentialTable<Credential extends Table, NativeSubjectId> {
   readonly table: Credential;
   readonly subjectId: ColumnKey<Credential>;
   readonly credentialId: ColumnKey<Credential>;
@@ -282,12 +282,12 @@ interface EmailRegistrationAuthorityCredentialTable<Credential extends Table, Na
     readonly revision: SecurityRevision;
   }) => InferInsertModel<Credential>;
 }
-interface RequiredEmailRegistrationConstraints extends RequiredEmailSignInConstraints {
+export interface RequiredEmailRegistrationConstraints extends RequiredEmailSignInConstraints {
   readonly authorityCredential: "unique(authorityCredential.subjectId,authorityCredential.credentialId)";
   readonly request: "unique(emailRegistration.moduleId,emailRegistration.commandId)";
   readonly pendingReference: "unique(emailRegistration.pendingReference)";
 }
-declare const requiredEmailRegistrationConstraints: RequiredEmailRegistrationConstraints;
+export declare const requiredEmailRegistrationConstraints: RequiredEmailRegistrationConstraints;
 type EmailRegistrationBase<Registration, Request extends Table, NativeSubjectId> = {
   readonly registration: EmailRegistrationTable<Registration, Request, NativeSubjectId>;
   readonly constraints: Pick<RequiredEmailRegistrationConstraints, "request" | "pendingReference">;
@@ -316,7 +316,7 @@ type EmailRegistrationBase<Registration, Request extends Table, NativeSubjectId>
   readonly retentionMillis: number;
   readonly isRequestConflict: (cause: unknown) => boolean;
 };
-type EmailRegistrationMapping<Registration, Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Request extends Table, NativeSubjectId> = EmailRegistrationBase<Registration, Request, NativeSubjectId> & ({
+export type EmailRegistrationMapping<Registration, Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Request extends Table, NativeSubjectId> = EmailRegistrationBase<Registration, Request, NativeSubjectId> & ({
   readonly mode: "atomic";
   readonly subject: EmailSubjectReadTable<Subject>;
   readonly identifier: EmailRegistrationIdentifierTable<Identifier, NativeSubjectId>;
@@ -343,12 +343,11 @@ type EmailRegistrationMapping<Registration, Subject extends Table, Identifier ex
 } | {
   readonly mode: "pending";
 });
-type AnyEmailSignInMapping = EmailSignInMapping<Table, Table, Table, unknown>;
-type AnyEmailAddressMapping = EmailAddressMapping<Table, Table, Table, Table, Table, unknown>;
-type AnyEmailRegistrationMapping<Registration = unknown> = EmailRegistrationMapping<Registration, Table, Table, Table, Table, Table, unknown>;
-type D1EmailRegistrationMapping<Registration, Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Request extends Table, NativeSubjectId> = EmailRegistrationMapping<Registration, Subject, Identifier, Credential, AuthorityCredential, Request, NativeSubjectId> & {
+export type AnyEmailSignInMapping = EmailSignInMapping<Table, Table, Table, unknown>;
+export type AnyEmailAddressMapping = EmailAddressMapping<Table, Table, Table, Table, Table, unknown>;
+export type AnyEmailRegistrationMapping<Registration = unknown> = EmailRegistrationMapping<Registration, Table, Table, Table, Table, Table, unknown>;
+export type D1EmailRegistrationMapping<Registration, Subject extends Table, Identifier extends Table, Credential extends Table, AuthorityCredential extends Table, Request extends Table, NativeSubjectId> = EmailRegistrationMapping<Registration, Subject, Identifier, Credential, AuthorityCredential, Request, NativeSubjectId> & {
   readonly d1: EmailD1Clock;
 };
 //#endregion
-export { AnyEmailAddressMapping, AnyEmailRegistrationMapping, AnyEmailSignInMapping, D1EmailAddressMapping, D1EmailRegistrationMapping, EmailAddressMapping, EmailAuthorityCredentialTable, EmailCommandTable, EmailCredentialReadTable, EmailCredentialTable, EmailD1Clock, EmailIdentifierReadTable, EmailIdentifierTable, EmailRegistrationAuthorityCredentialTable, EmailRegistrationCredentialTable, EmailRegistrationIdentifierTable, EmailRegistrationIntent, EmailRegistrationMapping, EmailRegistrationProvisioning, EmailRegistrationState, EmailRegistrationTable, EmailSignInMapping, EmailSubjectReadTable, EmailSubjectTable, RequiredEmailAddressConstraints, RequiredEmailRegistrationConstraints, RequiredEmailSignInConstraints, requiredEmailAddressConstraints, requiredEmailRegistrationConstraints, requiredEmailSignInConstraints };
 //# sourceMappingURL=email-model.d.mts.map

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

@@ -8,7 +8,7 @@ import { EmailCommandId, EmailRegistrationDecision, EmailUnavailable, PrepareEma
 import { ProofCompletionPlan } from "@yielded/auth/Proofs";
 import { LoginIdentifier } from "@yielded/auth/Identity";
 //#region src/drizzle/email-registration.d.ts
-interface EmailRegistrationAuthority<Registration> {
+export interface EmailRegistrationAuthority<Registration> {
   readonly inspect: (input: {
     readonly identifier: LoginIdentifier;
     readonly registration: Registration;
@@ -26,5 +26,4 @@ interface EmailRegistrationAuthority<Registration> {
   }, prepare: PrepareEmailCommit<EmailRegistrationDecision, A>) => Effect.Effect<PreparedCommit<A>, EmailUnavailable>;
 }
 //#endregion
-export { EmailRegistrationAuthority };
 //# sourceMappingURL=email-registration.d.mts.map

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

@@ -6,15 +6,14 @@ import { HookConfigurationError, LifecycleHooks } from "@yielded/auth/Hooks";
 import { EmailAddressPersistence, EmailSignInTargets, EmailUnavailable } from "@yielded/auth/Email";
 import "effect/unstable/sql/SqlError";
 //#region src/drizzle/email-target.d.ts
-declare const emailSignInTargetsLayer: (services: Effect.Effect<{
+export declare const emailSignInTargetsLayer: (services: Effect.Effect<{
   readonly emailSignInTargets: EmailSignInTargets["Service"];
 }>) => Layer.Layer<EmailSignInTargets, never, never>;
-declare const emailAddressPersistenceLayer: (services: Effect.Effect<{
+export declare const emailAddressPersistenceLayer: (services: Effect.Effect<{
   readonly emailAddressPersistence: EmailAddressPersistence["Service"];
 }, never, LifecycleHooks>) => Layer.Layer<EmailAddressPersistence, never, LifecycleHooks>;
-declare const emailRegistrationLayer: <Id, Registration>(tag: Context.Key<Id, EmailRegistrationAuthority<Registration>>, services: Effect.Effect<{
+export declare const emailRegistrationLayer: <Id, Registration>(tag: Context.Key<Id, EmailRegistrationAuthority<Registration>>, services: Effect.Effect<{
   readonly registrationAuthority: EmailRegistrationAuthority<Registration>;
 }, never, LifecycleHooks>) => Layer.Layer<Id, never, LifecycleHooks>;
 //#endregion
-export { emailAddressPersistenceLayer, emailRegistrationLayer, emailSignInTargetsLayer };
 //# sourceMappingURL=email-target.d.mts.map

package/dist/drizzle/model.d.mts

@@ -9,40 +9,40 @@ import { AuthStoreError } from "@yielded/auth/Errors";
 import { AnyColumn, InferInsertModel, InferSelectModel, Table } from "drizzle-orm";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 //#region src/drizzle/model.d.ts
-type CommitMode = "interactive" | "synchronous" | "batch";
+export type CommitMode = "interactive" | "synchronous" | "batch";
 /**
  * Ordinary error-channel consumes must own their commit. Coordinated callers
  * use the decision methods inside their outer transaction and translate only
  * after that owner commits.
  */
-interface SqlClientTransactionDatabase {
+export interface SqlClientTransactionDatabase {
   readonly $client: Pick<SqlClient.SqlClient, "transactionService">;
 }
-declare const requireStandaloneConsume: (database: SqlClientTransactionDatabase) => Effect.Effect<void, AuthStoreError>;
-interface InstantCodec<NativeInstant> {
+export declare const requireStandaloneConsume: (database: SqlClientTransactionDatabase) => Effect.Effect<void, AuthStoreError>;
+export interface InstantCodec<NativeInstant> {
   readonly encode: (instant: DateTime.Utc) => NativeInstant;
   readonly decode: (native: NativeInstant) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;
 }
-interface RequiredAuthStoreConstraints {
+export interface RequiredAuthStoreConstraints {
   readonly series: "unique(namespace,value,purpose)";
   readonly challengeDigest: "unique(tokenDigest)";
   readonly registrationDigest: "unique(tokenDigest)";
 }
-interface RequiredOAuthStateConstraints {
+export interface RequiredOAuthStateConstraints {
   readonly oauthStateDigest: "unique(stateDigest)";
 }
-interface RequiredAuthConstraints extends RequiredAuthStoreConstraints, RequiredOAuthStateConstraints {}
-declare const requiredAuthConstraints: RequiredAuthConstraints;
-declare const requiredAuthStoreConstraints: RequiredAuthStoreConstraints;
-declare const requiredOAuthStateConstraints: RequiredOAuthStateConstraints;
+export interface RequiredAuthConstraints extends RequiredAuthStoreConstraints, RequiredOAuthStateConstraints {}
+export declare const requiredAuthConstraints: RequiredAuthConstraints;
+export declare const requiredAuthStoreConstraints: RequiredAuthStoreConstraints;
+export declare const requiredOAuthStateConstraints: RequiredOAuthStateConstraints;
 type ColumnKey<T extends Table> = Extract<keyof T["_"]["columns"], string>;
-interface ChallengeRecord {
+export interface ChallengeRecord {
   readonly challenge: NewChallenge;
   readonly namespace: string;
   readonly failedAttempts: number;
   readonly consumed: boolean;
 }
-interface ChallengeColumns<T extends Table> {
+export interface ChallengeColumns<T extends Table> {
   readonly challengeId: ColumnKey<T>;
   readonly tokenDigest: ColumnKey<T>;
   readonly namespace: ColumnKey<T>;
@@ -63,7 +63,7 @@ interface ChallengeColumns<T extends Table> {
  * issuance watermark until every previously accepted issuance has expired;
  * current-row expiry alone is insufficient if historical lifetimes were longer.
  */
-interface ChallengeTableMapping<T extends Table> {
+export interface ChallengeTableMapping<T extends Table> {
   readonly table: T;
   readonly columns: ChallengeColumns<T>;
   readonly identifierNamespace: string;
@@ -80,29 +80,29 @@ interface ChallengeTableMapping<T extends Table> {
   }) => Readonly<Record<string, unknown>>;
   readonly decode: (row: InferSelectModel<T>) => Effect.Effect<ChallengeRecord, PersistenceMappingError>;
 }
-interface RegistrationRecord {
+export interface RegistrationRecord {
   readonly registration: PendingRegistration;
   readonly consumed: boolean;
 }
-interface RegistrationColumns<T extends Table> {
+export interface RegistrationColumns<T extends Table> {
   readonly registrationId: ColumnKey<T>;
   readonly tokenDigest: ColumnKey<T>;
   readonly expiresAt: ColumnKey<T>;
   readonly consumed: ColumnKey<T>;
 }
-interface RegistrationTableMapping<T extends Table> {
+export interface RegistrationTableMapping<T extends Table> {
   readonly table: T;
   readonly columns: RegistrationColumns<T>;
   readonly encodeInstant: (instant: DateTime.Utc) => unknown;
   readonly encodeInsert: (input: NewRegistration, consumed: false) => InferInsertModel<T>;
   readonly decode: (row: InferSelectModel<T>) => Effect.Effect<RegistrationRecord, PersistenceMappingError>;
 }
-interface OAuthStateColumns<T extends Table> {
+export interface OAuthStateColumns<T extends Table> {
   readonly stateDigest: ColumnKey<T>;
   readonly expiresAt: ColumnKey<T>;
   readonly consumed: ColumnKey<T>;
 }
-interface OAuthStateTableMapping<T extends Table> {
+export interface OAuthStateTableMapping<T extends Table> {
   readonly table: T;
   readonly columns: OAuthStateColumns<T>;
   readonly encodeInstant: (instant: DateTime.Utc) => unknown;
@@ -112,44 +112,44 @@ interface OAuthStateTableMapping<T extends Table> {
     readonly consumed: boolean;
   }, PersistenceMappingError>;
 }
-interface AuthStoreTables<Challenge extends Table, Registration extends Table> {
+export interface AuthStoreTables<Challenge extends Table, Registration extends Table> {
   readonly constraints: RequiredAuthStoreConstraints;
   readonly challenge: ChallengeTableMapping<Challenge>;
   readonly registration: RegistrationTableMapping<Registration>;
 }
-interface OAuthStateTables<State extends Table> {
+export interface OAuthStateTables<State extends Table> {
   readonly constraints: RequiredOAuthStateConstraints;
   readonly oauthState: OAuthStateTableMapping<State>;
 }
-interface AuthTables<Challenge extends Table, Registration extends Table, State extends Table> {
+export interface AuthTables<Challenge extends Table, Registration extends Table, State extends Table> {
   readonly constraints: RequiredAuthConstraints;
   readonly challenge: ChallengeTableMapping<Challenge>;
   readonly registration: RegistrationTableMapping<Registration>;
   readonly oauthState: OAuthStateTableMapping<State>;
 }
-interface RequiredIdentityConstraints {
+export interface RequiredIdentityConstraints {
   readonly identifier: "unique(namespace,value)";
   readonly externalIdentity: "unique(provider,issuer,subject)";
   readonly provisioningRequest: "unique(requestId)";
   readonly provisioningSubject: "notNull(provisioningRequest.subjectId)";
 }
-interface RequiredSubjectProvisioningConstraints {
+export interface RequiredSubjectProvisioningConstraints {
   readonly identifier: "unique(namespace,value)";
   readonly provisioningRequest: "unique(requestId)";
   readonly provisioningSubject: "notNull(provisioningRequest.subjectId)";
 }
-interface RequiredExternalIdentityConstraints {
+export interface RequiredExternalIdentityConstraints {
   readonly externalIdentity: "unique(provider,issuer,subject)";
 }
-declare const requiredIdentityConstraints: RequiredIdentityConstraints;
-declare const requiredSubjectProvisioningConstraints: RequiredSubjectProvisioningConstraints;
-declare const requiredExternalIdentityConstraints: RequiredExternalIdentityConstraints;
-interface SubjectIdCodec<NativeId> {
+export declare const requiredIdentityConstraints: RequiredIdentityConstraints;
+export declare const requiredSubjectProvisioningConstraints: RequiredSubjectProvisioningConstraints;
+export declare const requiredExternalIdentityConstraints: RequiredExternalIdentityConstraints;
+export interface SubjectIdCodec<NativeId> {
   readonly toNative: (id: SubjectId) => Effect.Effect<NativeId, PersistenceMappingError>;
   readonly toSubject: (id: NativeId) => Effect.Effect<SubjectId, PersistenceMappingError>;
   readonly equals: (left: NativeId, right: NativeId) => boolean;
 }
-interface SubjectProvisioningTables<Subject extends Table, Identifier extends Table, Request extends Table, NativeId> {
+export interface SubjectProvisioningTables<Subject extends Table, Identifier extends Table, Request extends Table, NativeId> {
   readonly constraints: RequiredSubjectProvisioningConstraints;
   readonly subject: {
     readonly table: Subject;
@@ -181,7 +181,7 @@ interface SubjectProvisioningTables<Subject extends Table, Identifier extends Ta
   /** Narrows only database constraint failures; every other cause is unavailable. */
   readonly isConstraintConflict: (cause: unknown) => boolean;
 }
-interface ExternalIdentityTables<Subject extends Table, External extends Table, NativeId> {
+export interface ExternalIdentityTables<Subject extends Table, External extends Table, NativeId> {
   readonly constraints: RequiredExternalIdentityConstraints;
   readonly subject: {
     readonly table: Subject;
@@ -200,7 +200,7 @@ interface ExternalIdentityTables<Subject extends Table, External extends Table,
   readonly subjectId: SubjectIdCodec<NativeId>;
   readonly isConstraintConflict: (cause: unknown) => boolean;
 }
-interface IdentityTables<Subject extends Table, Identifier extends Table, External extends Table, Request extends Table, NativeId> {
+export interface IdentityTables<Subject extends Table, Identifier extends Table, External extends Table, Request extends Table, NativeId> {
   readonly constraints: RequiredIdentityConstraints;
   readonly subject: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>["subject"];
   readonly identifier: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>["identifier"];
@@ -210,7 +210,7 @@ interface IdentityTables<Subject extends Table, Identifier extends Table, Extern
   readonly isConstraintConflict: (cause: unknown) => boolean;
 }
 /** Extra encoders used by D1's ordered batch when the subject id is database-generated. */
-interface D1SubjectProvisioningMapping<Subject extends Table, Identifier extends Table, Request extends Table, NativeId> extends SubjectProvisioningTables<Subject, Identifier, Request, NativeId> {
+export interface D1SubjectProvisioningMapping<Subject extends Table, Identifier extends Table, Request extends Table, NativeId> extends SubjectProvisioningTables<Subject, Identifier, Request, NativeId> {
   readonly d1: {
     readonly requestInsertWithoutSubject: (requestId: string, fingerprint: string) => Partial<InferInsertModel<Request>>;
     readonly identifierInsertWithoutSubject: (identifier: LoginIdentifier, verifiedAt: DateTime.Utc | undefined) => Partial<InferInsertModel<Identifier>>;
@@ -218,33 +218,33 @@ interface D1SubjectProvisioningMapping<Subject extends Table, Identifier extends
     readonly generatedRowIdAlias?: "rowid" | "_rowid_" | "oid";
   };
 }
-interface D1ExternalIdentityMapping<Subject extends Table, External extends Table, NativeId> extends ExternalIdentityTables<Subject, External, NativeId> {
+export interface D1ExternalIdentityMapping<Subject extends Table, External extends Table, NativeId> extends ExternalIdentityTables<Subject, External, NativeId> {
   readonly d1: {
     readonly activeStatusValue: unknown;
   };
 }
-interface D1GeneratedIdentityMapping<Subject extends Table, Identifier extends Table, External extends Table, Request extends Table, NativeId> extends IdentityTables<Subject, Identifier, External, Request, NativeId> {
+export interface D1GeneratedIdentityMapping<Subject extends Table, Identifier extends Table, External extends Table, Request extends Table, NativeId> extends IdentityTables<Subject, Identifier, External, Request, NativeId> {
   readonly d1: D1SubjectProvisioningMapping<Subject, Identifier, Request, NativeId>["d1"] & D1ExternalIdentityMapping<Subject, External, NativeId>["d1"];
 }
-declare const provisioningFingerprint: (input: SubjectProvisioningInput) => string;
+export declare const provisioningFingerprint: (input: SubjectProvisioningInput) => string;
 /**
  * Drizzle wraps Effect SQL failures before adapters observe them. Give the
  * consumer classifier each semantic wrapper in the short `cause`/`reason`
  * chain without exposing query text or bound parameters through public errors.
  */
-declare const column: <T extends Table>(table: T, key: ColumnKey<T>) => AnyColumn;
-declare const updateValues: <T extends Table>(entries: ReadonlyArray<readonly [ColumnKey<T>, unknown]>) => Partial<InferInsertModel<T>>;
-type ChallengeInput = ConsumeChallenge;
+export declare const column: <T extends Table>(table: T, key: ColumnKey<T>) => AnyColumn;
+export declare const updateValues: <T extends Table>(entries: ReadonlyArray<readonly [ColumnKey<T>, unknown]>) => Partial<InferInsertModel<T>>;
+export type ChallengeInput = ConsumeChallenge;
 /** Acquire an application database in Effect and expose the auth stores as one layer. */
-declare const authServicesLayer: <E, R>(acquire: Effect.Effect<{
+export declare const authServicesLayer: <E, R>(acquire: Effect.Effect<{
   readonly authStore: AuthStore["Service"];
   readonly oauthStateStore: OAuthStateStore["Service"];
 }, E, R>) => Layer.Layer<AuthStore | OAuthStateStore, E, Exclude<R, import("effect/Scope").Scope>>;
 /** Acquire an application database in Effect and expose the identity services as one layer. */
-declare const identityServicesLayer: <E, R>(acquire: Effect.Effect<{
+export declare const identityServicesLayer: <E, R>(acquire: Effect.Effect<{
   readonly subjectProvisioner: SubjectProvisioner["Service"];
   readonly externalIdentityMutation: ExternalIdentityMutation["Service"];
 }, E, R>) => Layer.Layer<ExternalIdentityMutation | SubjectProvisioner, E, Exclude<R, import("effect/Scope").Scope>>;
 //#endregion
-export { AuthStoreTables, AuthTables, ChallengeColumns, type ChallengeConsumeDecision, ChallengeInput, ChallengeRecord, ChallengeTableMapping, CommitMode, type ConsumeDecision, D1ExternalIdentityMapping, D1GeneratedIdentityMapping, D1SubjectProvisioningMapping, ExternalIdentityTables, IdentityTables, InstantCodec, OAuthStateColumns, OAuthStateTableMapping, OAuthStateTables, PersistenceMappingError, RegistrationColumns, RegistrationRecord, RegistrationTableMapping, RequiredAuthConstraints, RequiredAuthStoreConstraints, RequiredExternalIdentityConstraints, RequiredIdentityConstraints, RequiredOAuthStateConstraints, RequiredSubjectProvisioningConstraints, SqlClientTransactionDatabase, SubjectIdCodec, SubjectProvisioningTables, authServicesLayer, column, identityServicesLayer, isMappedConstraintConflict, provisioningFingerprint, requireStandaloneConsume, requiredAuthConstraints, requiredAuthStoreConstraints, requiredExternalIdentityConstraints, requiredIdentityConstraints, requiredOAuthStateConstraints, requiredSubjectProvisioningConstraints, updateValues };
+export { type ChallengeConsumeDecision, type ConsumeDecision, PersistenceMappingError, isMappedConstraintConflict };
 //# sourceMappingURL=model.d.mts.map

package/dist/drizzle/model.mjs

@@ -1,5 +1,6 @@
 import { PersistenceMappingError, isMappedConstraintConflict } from "../internal/mapping-error.mjs";
-import { Context, DateTime, Effect, Layer, Option } from "effect";
+import { requireStandalone } from "../internal/standalone.mjs";
+import { Context, DateTime, Effect, Layer } from "effect";
 import "@yielded/auth/Schema";
 import { ExternalIdentityMutation, SubjectProvisioner } from "@yielded/auth/Identity";
 import { OAuthStateStore } from "@yielded/auth/OAuth";
@@ -7,10 +8,7 @@ import { AuthStore } from "@yielded/auth/AuthStore";
 import { AuthStoreError } from "@yielded/auth/Errors";
 import { getTableColumns } from "drizzle-orm";
 //#region src/drizzle/model.ts
-const requireStandaloneConsume = (database) => Effect.serviceOption(database.$client.transactionService).pipe(Effect.flatMap(Option.match({
-	onNone: () => Effect.void,
-	onSome: () => AuthStoreError.make({ message: "Use the decision consume API inside an outer database transaction" })
-})));
+const requireStandaloneConsume = (database) => requireStandalone(() => AuthStoreError.make({ message: "Use the decision consume API inside an outer database transaction" }), database.$client);
 const requiredAuthConstraints = {
 	series: "unique(namespace,value,purpose)",
 	challengeDigest: "unique(tokenDigest)",