@yielded/auth-persistence 0.1.0-beta.10

package/dist/internal/models/proof-model.d.mts

@@ -0,0 +1,285 @@
+import { AnyTableModel, SqlExpression, TableModel } from "../query-operations.mjs";
+import { PersistenceMappingError } from "../mapping-error.mjs";
+import { SubjectIdCodec } from "./common.mjs";
+import { Effect } from "effect";
+import { TokenDigest } from "@yielded/auth/Schema";
+import { ProofBinding, ProofContinuationId, ProofId, ProofPolicy, ProofPurpose, ProofRecord, ProofRequestReceipt, ProofVersion } from "@yielded/auth/Proofs";
+//#region src/internal/models/proof-model.d.ts
+type ColumnKey<T extends TableModel> = T["column"];
+export type ProofAction = "issue" | "attempt";
+export type ProofScopeKind = "action" | "identifier" | "subject";
+export type ProofGenerationState = "active" | "consumed" | "cancelled" | "superseded";
+export type ProofDeliveryState = "new" | "claimed" | "accepted" | "failed" | "ambiguous";
+export type ProofCommandKind = "attempt" | "complete";
+export type ProofCommandDecision = "accepted" | "rejected" | "completed";
+export interface ProofScopeKeys {
+  /** Stable across flow/context/request changes and bounded by the consumer codec. */
+  readonly series: string;
+  readonly identifier: string;
+  /** A tagged non-null value; use a stable sentinel when the binding has no subject. */
+  readonly subject: string;
+}
+export interface ProofAuthorityInput<NativeSubjectId> {
+  readonly moduleId: string;
+  readonly purpose: ProofPurpose;
+  readonly binding: ProofBinding;
+  /** Resolved by Effect preplanning before an interactive check or D1 predicate compile. */
+  readonly nativeSubjectId?: NativeSubjectId;
+}
+export interface ProofAuthorityTables<Subject extends TableModel, Identifier extends TableModel, Credential extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> {
+  readonly identifier: {
+    readonly table: Identifier["table"];
+    readonly namespace: ColumnKey<Identifier>;
+    readonly value: ColumnKey<Identifier>;
+    /** Evaluate the consumer's explicit current-ownership/availability semantics. */
+    readonly isCurrent: (input: ProofAuthorityInput<NativeSubjectId>, rows: ReadonlyArray<Identifier["select"]>) => boolean;
+    /** Optional outside D1. Never infer this semantic predicate from eligibility. */
+    readonly d1CurrentCondition?: (input: ProofAuthorityInput<NativeSubjectId>) => Expression;
+  };
+  readonly subject?: {
+    readonly table: Subject["table"];
+    readonly id: ColumnKey<Subject>;
+    readonly status: ColumnKey<Subject>;
+    readonly securityRevision: ColumnKey<Subject>;
+    readonly isActiveStatus: (value: unknown) => boolean;
+    readonly d1ActiveStatusValue: unknown;
+  };
+  readonly credential?: {
+    readonly table: Credential["table"];
+    readonly subjectId: ColumnKey<Credential>;
+    readonly credentialId: ColumnKey<Credential>;
+    readonly revision: ColumnKey<Credential>;
+    readonly status?: ColumnKey<Credential>;
+    readonly isActiveStatus?: (value: unknown) => boolean;
+    readonly d1ActiveStatusValue?: unknown;
+  };
+  readonly subjectId?: SubjectIdCodec<NativeSubjectId>;
+}
+export interface ProofRequestTable<Request extends TableModel> {
+  readonly table: Request["table"];
+  readonly moduleId: ColumnKey<Request>;
+  readonly requestId: ColumnKey<Request>;
+  readonly fingerprint: ColumnKey<Request>;
+  readonly proofId: ColumnKey<Request>;
+  readonly purpose: ColumnKey<Request>;
+  readonly keyId: ColumnKey<Request>;
+  readonly createdAt: ColumnKey<Request>;
+  readonly retentionUntil: ColumnKey<Request>;
+  readonly encodeInsert: (input: {
+    readonly record: ProofRecord;
+    readonly createdAtMillis: number;
+    readonly retentionUntilMillis: number;
+  }) => Request["insert"];
+  readonly decodeReceipt: (row: Request["select"]) => Effect.Effect<ProofRequestReceipt, PersistenceMappingError>;
+}
+export interface ProofSeriesTable<Series extends TableModel> {
+  readonly table: Series["table"];
+  readonly moduleId: ColumnKey<Series>;
+  readonly purpose: ColumnKey<Series>;
+  readonly scopeKey: ColumnKey<Series>;
+  readonly activeProofId: ColumnKey<Series>;
+  readonly lastIssueAt: ColumnKey<Series>;
+  readonly version: ColumnKey<Series>;
+  readonly encodeInsert: (input: {
+    readonly moduleId: string;
+    readonly purpose: ProofPurpose;
+    readonly scopeKey: string;
+    readonly version: ProofVersion;
+  }) => Series["insert"];
+}
+export interface ProofGenerationTable<Generation extends TableModel> {
+  readonly table: Generation["table"];
+  readonly moduleId: ColumnKey<Generation>;
+  readonly purpose: ColumnKey<Generation>;
+  readonly proofId: ColumnKey<Generation>;
+  readonly requestId: ColumnKey<Generation>;
+  readonly seriesKey: ColumnKey<Generation>;
+  readonly deliveryId: ColumnKey<Generation>;
+  readonly binding: ColumnKey<Generation>;
+  readonly verifierKeyId: ColumnKey<Generation>;
+  readonly verifierDigest: ColumnKey<Generation>;
+  readonly issuedAt: ColumnKey<Generation>;
+  readonly expiresAt: ColumnKey<Generation>;
+  readonly version: ColumnKey<Generation>;
+  readonly state: ColumnKey<Generation>;
+  readonly sendCount: ColumnKey<Generation>;
+  readonly deliveryState: ColumnKey<Generation>;
+  readonly claimVersion: ColumnKey<Generation>;
+  readonly claimDeadline: ColumnKey<Generation>;
+  readonly retryAt: ColumnKey<Generation>;
+  readonly deliveryRetryMillis: ColumnKey<Generation>;
+  readonly retentionUntil: ColumnKey<Generation>;
+  readonly encodeInsert: (input: {
+    readonly record: ProofRecord;
+    readonly seriesKey: string;
+    readonly retentionUntilMillis: number;
+    readonly state: ProofGenerationState;
+    readonly deliveryState: ProofDeliveryState;
+    readonly policy: ProofPolicy;
+  }) => Generation["insert"];
+  readonly decodeRecord: (row: Generation["select"]) => Effect.Effect<ProofRecord, PersistenceMappingError>;
+  readonly decodeBinding: (row: Generation["select"]) => Effect.Effect<ProofBinding, PersistenceMappingError>;
+}
+export interface ProofContinuationRecord {
+  readonly moduleId: string;
+  readonly purpose: ProofPurpose;
+  readonly continuationId: ProofContinuationId;
+  readonly digest: TokenDigest;
+  readonly proofId: ProofId;
+  readonly seriesKey: string;
+  readonly binding: ProofBinding;
+  readonly expiresAtMillis: number;
+  readonly version: ProofVersion;
+}
+export interface ProofContinuationTable<Continuation extends TableModel> {
+  readonly table: Continuation["table"];
+  readonly moduleId: ColumnKey<Continuation>;
+  readonly purpose: ColumnKey<Continuation>;
+  readonly continuationId: ColumnKey<Continuation>;
+  readonly digest: ColumnKey<Continuation>;
+  readonly proofId: ColumnKey<Continuation>;
+  readonly seriesKey: ColumnKey<Continuation>;
+  readonly binding: ColumnKey<Continuation>;
+  readonly expiresAt: ColumnKey<Continuation>;
+  readonly consumed: ColumnKey<Continuation>;
+  readonly version: ColumnKey<Continuation>;
+  readonly retentionUntil: ColumnKey<Continuation>;
+  readonly encodeInsert: (record: ProofContinuationRecord & {
+    readonly retentionUntilMillis: number;
+  }) => Continuation["insert"];
+  readonly decode: (row: Continuation["select"]) => Effect.Effect<ProofContinuationRecord, PersistenceMappingError>;
+}
+export interface ProofRateScopeTable<RateScope extends TableModel> {
+  readonly table: RateScope["table"];
+  readonly moduleId: ColumnKey<RateScope>;
+  readonly purpose: ColumnKey<RateScope>;
+  readonly action: ColumnKey<RateScope>;
+  readonly scopeKind: ColumnKey<RateScope>;
+  readonly scopeKey: ColumnKey<RateScope>;
+  readonly encodeInsert: (input: {
+    readonly moduleId: string;
+    readonly purpose: ProofPurpose;
+    readonly action: ProofAction;
+    readonly scopeKind: ProofScopeKind;
+    readonly scopeKey: string;
+  }) => RateScope["insert"];
+}
+export interface ProofAbuseEventTable<AbuseEvent extends TableModel> {
+  readonly table: AbuseEvent["table"];
+  readonly moduleId: ColumnKey<AbuseEvent>;
+  readonly purpose: ColumnKey<AbuseEvent>;
+  readonly action: ColumnKey<AbuseEvent>;
+  readonly scopeKind: ColumnKey<AbuseEvent>;
+  readonly scopeKey: ColumnKey<AbuseEvent>;
+  readonly commandId: ColumnKey<AbuseEvent>;
+  readonly occurredAt: ColumnKey<AbuseEvent>;
+  readonly retentionUntil: ColumnKey<AbuseEvent>;
+  readonly encodeInsert: (input: {
+    readonly moduleId: string;
+    readonly purpose: ProofPurpose;
+    readonly action: ProofAction;
+    readonly scopeKind: ProofScopeKind;
+    readonly scopeKey: string;
+    readonly commandId: string;
+    readonly occurredAtMillis: number;
+    readonly retentionUntilMillis: number;
+  }) => AbuseEvent["insert"];
+}
+export interface ProofFailureEventTable<FailureEvent extends TableModel> {
+  readonly table: FailureEvent["table"];
+  readonly moduleId: ColumnKey<FailureEvent>;
+  readonly purpose: ColumnKey<FailureEvent>;
+  readonly seriesKey: ColumnKey<FailureEvent>;
+  readonly commandId: ColumnKey<FailureEvent>;
+  readonly occurredAt: ColumnKey<FailureEvent>;
+  readonly retentionUntil: ColumnKey<FailureEvent>;
+  readonly encodeInsert: (input: {
+    readonly moduleId: string;
+    readonly purpose: ProofPurpose;
+    readonly seriesKey: string;
+    readonly commandId: string;
+    readonly occurredAtMillis: number;
+    readonly retentionUntilMillis: number;
+  }) => FailureEvent["insert"];
+}
+export interface ProofCommandTable<Command extends TableModel> {
+  readonly table: Command["table"];
+  readonly moduleId: ColumnKey<Command>;
+  readonly commandId: ColumnKey<Command>;
+  readonly kind: ColumnKey<Command>;
+  readonly decision: ColumnKey<Command>;
+  readonly retentionUntil: ColumnKey<Command>;
+  readonly encodeInsert: (input: {
+    readonly moduleId: string;
+    readonly commandId: string;
+    readonly kind: ProofCommandKind;
+    readonly decision: ProofCommandDecision;
+    readonly retentionUntilMillis: number;
+  }) => Command["insert"];
+}
+export interface RequiredProofConstraints {
+  readonly request: "unique(request.moduleId,request.requestId)";
+  readonly series: "unique(series.moduleId,series.purpose,series.scopeKey)";
+  readonly proof: "unique(generation.moduleId,generation.proofId)";
+  readonly delivery: "unique(generation.moduleId,generation.deliveryId)";
+  readonly continuationId: "unique(continuation.moduleId,continuation.continuationId)";
+  readonly continuationDigest: "unique(continuation.moduleId,continuation.digest)";
+  readonly rateScope: "unique(rateScope.moduleId,rateScope.purpose,rateScope.action,rateScope.scopeKind,rateScope.scopeKey)";
+  readonly abuseEvent: "unique(abuseEvent.moduleId,abuseEvent.action,abuseEvent.scopeKind,abuseEvent.scopeKey,abuseEvent.commandId)";
+  readonly failureEvent: "unique(failureEvent.moduleId,failureEvent.seriesKey,failureEvent.commandId)";
+  readonly command: "unique(command.moduleId,command.commandId)";
+}
+export declare const requiredProofConstraints: RequiredProofConstraints;
+export interface ProofConstraintClassifier {
+  /** Match only the declared request uniqueness constraint, including wrapped driver errors. */
+  readonly isRequestConflict: (cause: unknown) => boolean;
+  /** Match only the declared series uniqueness constraint, including wrapped driver errors. */
+  readonly isSeriesConflict: (cause: unknown) => boolean;
+  /** Match only the declared command uniqueness constraint, including wrapped driver errors. */
+  readonly isCommandConflict: (cause: unknown) => boolean;
+}
+export interface ProofD1Clock<Expression extends SqlExpression = SqlExpression> {
+  /** Native instant expression evaluated by SQLite inside the submitted batch. */
+  readonly engineNow: Expression;
+  /** Integer Unix milliseconds expression evaluated inside the submitted batch. */
+  readonly engineNowMillis: Expression;
+  /** Native instant expression for an engine-time rolling-window cutoff. */
+  readonly engineInstantMinus: (millis: number) => Expression;
+  /** Native instant expression for a retention/lease deadline from engine time. */
+  readonly engineInstantPlus: (millis: number) => Expression;
+}
+export interface ProofPersistenceMapping<Request extends TableModel, Series extends TableModel, Generation extends TableModel, Continuation extends TableModel, RateScope extends TableModel, AbuseEvent extends TableModel, FailureEvent extends TableModel, Command extends TableModel, Subject extends TableModel, Identifier extends TableModel, Credential extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> extends ProofConstraintClassifier {
+  readonly request: ProofRequestTable<Request>;
+  readonly series: ProofSeriesTable<Series>;
+  readonly generation: ProofGenerationTable<Generation>;
+  readonly continuation: ProofContinuationTable<Continuation>;
+  readonly rateScope: ProofRateScopeTable<RateScope>;
+  readonly abuseEvent: ProofAbuseEventTable<AbuseEvent>;
+  readonly failureEvent: ProofFailureEventTable<FailureEvent>;
+  readonly command: ProofCommandTable<Command>;
+  readonly authority: ProofAuthorityTables<Subject, Identifier, Credential, NativeSubjectId, Expression>;
+  readonly constraints: RequiredProofConstraints;
+  readonly scopeKeys: (input: {
+    readonly moduleId: string;
+    readonly purpose: ProofPurpose;
+    readonly binding: ProofBinding;
+  }) => ProofScopeKeys;
+  readonly encodeInstant: (epochMillis: number) => unknown;
+  readonly decodeInstant: (native: unknown) => Effect.Effect<number, PersistenceMappingError>;
+  readonly allocateVersion?: Effect.Effect<ProofVersion, PersistenceMappingError>;
+  readonly allocateVersionSync?: () => ProofVersion;
+  /** Required by D1 mappings and ignored by interactive targets. */
+  readonly d1?: ProofD1Clock<Expression>;
+}
+export type D1ProofPersistenceMapping<Request extends TableModel, Series extends TableModel, Generation extends TableModel, Continuation extends TableModel, RateScope extends TableModel, AbuseEvent extends TableModel, FailureEvent extends TableModel, Command extends TableModel, Subject extends TableModel, Identifier extends TableModel, Credential extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> = ProofPersistenceMapping<Request, Series, Generation, Continuation, RateScope, AbuseEvent, FailureEvent, Command, Subject, Identifier, Credential, NativeSubjectId, Expression> & {
+  readonly d1: ProofD1Clock<Expression>;
+  readonly authority: ProofAuthorityTables<Subject, Identifier, Credential, NativeSubjectId, Expression> & {
+    readonly identifier: ProofAuthorityTables<Subject, Identifier, Credential, NativeSubjectId, Expression>["identifier"] & {
+      /** Synchronous SQL compiler; Effect-based ID conversion has already completed. */
+      readonly d1CurrentCondition: (input: ProofAuthorityInput<NativeSubjectId>) => Expression;
+    };
+  };
+};
+export type AnyProofPersistenceMapping<Expression extends SqlExpression = SqlExpression> = ProofPersistenceMapping<AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, unknown, Expression>;
+//#endregion
+//# sourceMappingURL=proof-model.d.mts.map

package/dist/internal/models/proof-model.mjs

@@ -0,0 +1,17 @@
+//#region src/internal/models/proof-model.ts
+const requiredProofConstraints = {
+	request: "unique(request.moduleId,request.requestId)",
+	series: "unique(series.moduleId,series.purpose,series.scopeKey)",
+	proof: "unique(generation.moduleId,generation.proofId)",
+	delivery: "unique(generation.moduleId,generation.deliveryId)",
+	continuationId: "unique(continuation.moduleId,continuation.continuationId)",
+	continuationDigest: "unique(continuation.moduleId,continuation.digest)",
+	rateScope: "unique(rateScope.moduleId,rateScope.purpose,rateScope.action,rateScope.scopeKind,rateScope.scopeKey)",
+	abuseEvent: "unique(abuseEvent.moduleId,abuseEvent.action,abuseEvent.scopeKind,abuseEvent.scopeKey,abuseEvent.commandId)",
+	failureEvent: "unique(failureEvent.moduleId,failureEvent.seriesKey,failureEvent.commandId)",
+	command: "unique(command.moduleId,command.commandId)"
+};
+//#endregion
+export { requiredProofConstraints };
+
+//# sourceMappingURL=proof-model.mjs.map

package/dist/internal/models/proof-model.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-model.mjs","names":[],"sources":["../../../src/internal/models/proof-model.ts"],"sourcesContent":["import type {\n  ProofBinding,\n  ProofContinuationId,\n  ProofId,\n  ProofPurpose,\n  ProofRequestReceipt,\n  ProofVersion,\n  ProofPolicy,\n  ProofRecord,\n} from \"@yielded/auth/Proofs\";\nimport type { TokenDigest } from \"@yielded/auth/Schema\";\nimport type { Effect } from \"effect\";\n\nimport type { AnyTableModel, TableModel as Table, SqlExpression } from \"../query-operations\";\nimport type { PersistenceMappingError, SubjectIdCodec } from \"./common\";\n\ntype ColumnKey<T extends Table> = T[\"column\"];\n\nexport type ProofAction = \"issue\" | \"attempt\";\n\nexport type ProofScopeKind = \"action\" | \"identifier\" | \"subject\";\n\nexport type ProofGenerationState = \"active\" | \"consumed\" | \"cancelled\" | \"superseded\";\n\nexport type ProofDeliveryState = \"new\" | \"claimed\" | \"accepted\" | \"failed\" | \"ambiguous\";\n\nexport type ProofCommandKind = \"attempt\" | \"complete\";\n\nexport type ProofCommandDecision = \"accepted\" | \"rejected\" | \"completed\";\n\nexport interface ProofScopeKeys {\n  /** Stable across flow/context/request changes and bounded by the consumer codec. */\n  readonly series: string;\n  readonly identifier: string;\n  /** A tagged non-null value; use a stable sentinel when the binding has no subject. */\n  readonly subject: string;\n}\n\nexport interface ProofAuthorityInput<NativeSubjectId> {\n  readonly moduleId: string;\n  readonly purpose: ProofPurpose;\n  readonly binding: ProofBinding;\n  /** Resolved by Effect preplanning before an interactive check or D1 predicate compile. */\n  readonly nativeSubjectId?: NativeSubjectId;\n}\n\nexport interface ProofAuthorityTables<\n  Subject extends Table,\n  Identifier extends Table,\n  Credential extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> {\n  readonly identifier: {\n    readonly table: Identifier[\"table\"];\n    readonly namespace: ColumnKey<Identifier>;\n    readonly value: ColumnKey<Identifier>;\n    /** Evaluate the consumer's explicit current-ownership/availability semantics. */\n    readonly isCurrent: (\n      input: ProofAuthorityInput<NativeSubjectId>,\n      rows: ReadonlyArray<Identifier[\"select\"]>,\n    ) => boolean;\n    /** Optional outside D1. Never infer this semantic predicate from eligibility. */\n    readonly d1CurrentCondition?: (input: ProofAuthorityInput<NativeSubjectId>) => Expression;\n  };\n  readonly subject?: {\n    readonly table: Subject[\"table\"];\n    readonly id: ColumnKey<Subject>;\n    readonly status: ColumnKey<Subject>;\n    readonly securityRevision: ColumnKey<Subject>;\n    readonly isActiveStatus: (value: unknown) => boolean;\n    readonly d1ActiveStatusValue: unknown;\n  };\n  readonly credential?: {\n    readonly table: Credential[\"table\"];\n    readonly subjectId: ColumnKey<Credential>;\n    readonly credentialId: ColumnKey<Credential>;\n    readonly revision: ColumnKey<Credential>;\n    readonly status?: ColumnKey<Credential>;\n    readonly isActiveStatus?: (value: unknown) => boolean;\n    readonly d1ActiveStatusValue?: unknown;\n  };\n  readonly subjectId?: SubjectIdCodec<NativeSubjectId>;\n}\n\nexport interface ProofRequestTable<Request extends Table> {\n  readonly table: Request[\"table\"];\n  readonly moduleId: ColumnKey<Request>;\n  readonly requestId: ColumnKey<Request>;\n  readonly fingerprint: ColumnKey<Request>;\n  readonly proofId: ColumnKey<Request>;\n  readonly purpose: ColumnKey<Request>;\n  readonly keyId: ColumnKey<Request>;\n  readonly createdAt: ColumnKey<Request>;\n  readonly retentionUntil: ColumnKey<Request>;\n  readonly encodeInsert: (input: {\n    readonly record: ProofRecord;\n    readonly createdAtMillis: number;\n    readonly retentionUntilMillis: number;\n  }) => Request[\"insert\"];\n  readonly decodeReceipt: (\n    row: Request[\"select\"],\n  ) => Effect.Effect<ProofRequestReceipt, PersistenceMappingError>;\n}\n\nexport interface ProofSeriesTable<Series extends Table> {\n  readonly table: Series[\"table\"];\n  readonly moduleId: ColumnKey<Series>;\n  readonly purpose: ColumnKey<Series>;\n  readonly scopeKey: ColumnKey<Series>;\n  readonly activeProofId: ColumnKey<Series>;\n  readonly lastIssueAt: ColumnKey<Series>;\n  readonly version: ColumnKey<Series>;\n  readonly encodeInsert: (input: {\n    readonly moduleId: string;\n    readonly purpose: ProofPurpose;\n    readonly scopeKey: string;\n    readonly version: ProofVersion;\n  }) => Series[\"insert\"];\n}\n\nexport interface ProofGenerationTable<Generation extends Table> {\n  readonly table: Generation[\"table\"];\n  readonly moduleId: ColumnKey<Generation>;\n  readonly purpose: ColumnKey<Generation>;\n  readonly proofId: ColumnKey<Generation>;\n  readonly requestId: ColumnKey<Generation>;\n  readonly seriesKey: ColumnKey<Generation>;\n  readonly deliveryId: ColumnKey<Generation>;\n  readonly binding: ColumnKey<Generation>;\n  readonly verifierKeyId: ColumnKey<Generation>;\n  readonly verifierDigest: ColumnKey<Generation>;\n  readonly issuedAt: ColumnKey<Generation>;\n  readonly expiresAt: ColumnKey<Generation>;\n  readonly version: ColumnKey<Generation>;\n  readonly state: ColumnKey<Generation>;\n  readonly sendCount: ColumnKey<Generation>;\n  readonly deliveryState: ColumnKey<Generation>;\n  readonly claimVersion: ColumnKey<Generation>;\n  readonly claimDeadline: ColumnKey<Generation>;\n  readonly retryAt: ColumnKey<Generation>;\n  readonly deliveryRetryMillis: ColumnKey<Generation>;\n  readonly retentionUntil: ColumnKey<Generation>;\n  readonly encodeInsert: (input: {\n    readonly record: ProofRecord;\n    readonly seriesKey: string;\n    readonly retentionUntilMillis: number;\n    readonly state: ProofGenerationState;\n    readonly deliveryState: ProofDeliveryState;\n    readonly policy: ProofPolicy;\n  }) => Generation[\"insert\"];\n  readonly decodeRecord: (\n    row: Generation[\"select\"],\n  ) => Effect.Effect<ProofRecord, PersistenceMappingError>;\n  readonly decodeBinding: (\n    row: Generation[\"select\"],\n  ) => Effect.Effect<ProofBinding, PersistenceMappingError>;\n}\n\nexport interface ProofContinuationRecord {\n  readonly moduleId: string;\n  readonly purpose: ProofPurpose;\n  readonly continuationId: ProofContinuationId;\n  readonly digest: TokenDigest;\n  readonly proofId: ProofId;\n  readonly seriesKey: string;\n  readonly binding: ProofBinding;\n  readonly expiresAtMillis: number;\n  readonly version: ProofVersion;\n}\n\nexport interface ProofContinuationTable<Continuation extends Table> {\n  readonly table: Continuation[\"table\"];\n  readonly moduleId: ColumnKey<Continuation>;\n  readonly purpose: ColumnKey<Continuation>;\n  readonly continuationId: ColumnKey<Continuation>;\n  readonly digest: ColumnKey<Continuation>;\n  readonly proofId: ColumnKey<Continuation>;\n  readonly seriesKey: ColumnKey<Continuation>;\n  readonly binding: ColumnKey<Continuation>;\n  readonly expiresAt: ColumnKey<Continuation>;\n  readonly consumed: ColumnKey<Continuation>;\n  readonly version: ColumnKey<Continuation>;\n  readonly retentionUntil: ColumnKey<Continuation>;\n  readonly encodeInsert: (\n    record: ProofContinuationRecord & {\n      readonly retentionUntilMillis: number;\n    },\n  ) => Continuation[\"insert\"];\n  readonly decode: (\n    row: Continuation[\"select\"],\n  ) => Effect.Effect<ProofContinuationRecord, PersistenceMappingError>;\n}\n\nexport interface ProofRateScopeTable<RateScope extends Table> {\n  readonly table: RateScope[\"table\"];\n  readonly moduleId: ColumnKey<RateScope>;\n  readonly purpose: ColumnKey<RateScope>;\n  readonly action: ColumnKey<RateScope>;\n  readonly scopeKind: ColumnKey<RateScope>;\n  readonly scopeKey: ColumnKey<RateScope>;\n  readonly encodeInsert: (input: {\n    readonly moduleId: string;\n    readonly purpose: ProofPurpose;\n    readonly action: ProofAction;\n    readonly scopeKind: ProofScopeKind;\n    readonly scopeKey: string;\n  }) => RateScope[\"insert\"];\n}\n\nexport interface ProofAbuseEventTable<AbuseEvent extends Table> {\n  readonly table: AbuseEvent[\"table\"];\n  readonly moduleId: ColumnKey<AbuseEvent>;\n  readonly purpose: ColumnKey<AbuseEvent>;\n  readonly action: ColumnKey<AbuseEvent>;\n  readonly scopeKind: ColumnKey<AbuseEvent>;\n  readonly scopeKey: ColumnKey<AbuseEvent>;\n  readonly commandId: ColumnKey<AbuseEvent>;\n  readonly occurredAt: ColumnKey<AbuseEvent>;\n  readonly retentionUntil: ColumnKey<AbuseEvent>;\n  readonly encodeInsert: (input: {\n    readonly moduleId: string;\n    readonly purpose: ProofPurpose;\n    readonly action: ProofAction;\n    readonly scopeKind: ProofScopeKind;\n    readonly scopeKey: string;\n    readonly commandId: string;\n    readonly occurredAtMillis: number;\n    readonly retentionUntilMillis: number;\n  }) => AbuseEvent[\"insert\"];\n}\n\nexport interface ProofFailureEventTable<FailureEvent extends Table> {\n  readonly table: FailureEvent[\"table\"];\n  readonly moduleId: ColumnKey<FailureEvent>;\n  readonly purpose: ColumnKey<FailureEvent>;\n  readonly seriesKey: ColumnKey<FailureEvent>;\n  readonly commandId: ColumnKey<FailureEvent>;\n  readonly occurredAt: ColumnKey<FailureEvent>;\n  readonly retentionUntil: ColumnKey<FailureEvent>;\n  readonly encodeInsert: (input: {\n    readonly moduleId: string;\n    readonly purpose: ProofPurpose;\n    readonly seriesKey: string;\n    readonly commandId: string;\n    readonly occurredAtMillis: number;\n    readonly retentionUntilMillis: number;\n  }) => FailureEvent[\"insert\"];\n}\n\nexport interface ProofCommandTable<Command extends Table> {\n  readonly table: Command[\"table\"];\n  readonly moduleId: ColumnKey<Command>;\n  readonly commandId: ColumnKey<Command>;\n  readonly kind: ColumnKey<Command>;\n  readonly decision: ColumnKey<Command>;\n  readonly retentionUntil: ColumnKey<Command>;\n  readonly encodeInsert: (input: {\n    readonly moduleId: string;\n    readonly commandId: string;\n    readonly kind: ProofCommandKind;\n    readonly decision: ProofCommandDecision;\n    readonly retentionUntilMillis: number;\n  }) => Command[\"insert\"];\n}\n\nexport interface RequiredProofConstraints {\n  readonly request: \"unique(request.moduleId,request.requestId)\";\n  readonly series: \"unique(series.moduleId,series.purpose,series.scopeKey)\";\n  readonly proof: \"unique(generation.moduleId,generation.proofId)\";\n  readonly delivery: \"unique(generation.moduleId,generation.deliveryId)\";\n  readonly continuationId: \"unique(continuation.moduleId,continuation.continuationId)\";\n  readonly continuationDigest: \"unique(continuation.moduleId,continuation.digest)\";\n  readonly rateScope: \"unique(rateScope.moduleId,rateScope.purpose,rateScope.action,rateScope.scopeKind,rateScope.scopeKey)\";\n  readonly abuseEvent: \"unique(abuseEvent.moduleId,abuseEvent.action,abuseEvent.scopeKind,abuseEvent.scopeKey,abuseEvent.commandId)\";\n  readonly failureEvent: \"unique(failureEvent.moduleId,failureEvent.seriesKey,failureEvent.commandId)\";\n  readonly command: \"unique(command.moduleId,command.commandId)\";\n}\n\nexport const requiredProofConstraints: RequiredProofConstraints = {\n  request: \"unique(request.moduleId,request.requestId)\",\n  series: \"unique(series.moduleId,series.purpose,series.scopeKey)\",\n  proof: \"unique(generation.moduleId,generation.proofId)\",\n  delivery: \"unique(generation.moduleId,generation.deliveryId)\",\n  continuationId: \"unique(continuation.moduleId,continuation.continuationId)\",\n  continuationDigest: \"unique(continuation.moduleId,continuation.digest)\",\n  rateScope:\n    \"unique(rateScope.moduleId,rateScope.purpose,rateScope.action,rateScope.scopeKind,rateScope.scopeKey)\",\n  abuseEvent:\n    \"unique(abuseEvent.moduleId,abuseEvent.action,abuseEvent.scopeKind,abuseEvent.scopeKey,abuseEvent.commandId)\",\n  failureEvent: \"unique(failureEvent.moduleId,failureEvent.seriesKey,failureEvent.commandId)\",\n  command: \"unique(command.moduleId,command.commandId)\",\n};\n\nexport interface ProofConstraintClassifier {\n  /** Match only the declared request uniqueness constraint, including wrapped driver errors. */\n  readonly isRequestConflict: (cause: unknown) => boolean;\n  /** Match only the declared series uniqueness constraint, including wrapped driver errors. */\n  readonly isSeriesConflict: (cause: unknown) => boolean;\n  /** Match only the declared command uniqueness constraint, including wrapped driver errors. */\n  readonly isCommandConflict: (cause: unknown) => boolean;\n}\n\nexport interface ProofD1Clock<Expression extends SqlExpression = SqlExpression> {\n  /** Native instant expression evaluated by SQLite inside the submitted batch. */\n  readonly engineNow: Expression;\n  /** Integer Unix milliseconds expression evaluated inside the submitted batch. */\n  readonly engineNowMillis: Expression;\n  /** Native instant expression for an engine-time rolling-window cutoff. */\n  readonly engineInstantMinus: (millis: number) => Expression;\n  /** Native instant expression for a retention/lease deadline from engine time. */\n  readonly engineInstantPlus: (millis: number) => Expression;\n}\n\nexport interface ProofPersistenceMapping<\n  Request extends Table,\n  Series extends Table,\n  Generation extends Table,\n  Continuation extends Table,\n  RateScope extends Table,\n  AbuseEvent extends Table,\n  FailureEvent extends Table,\n  Command extends Table,\n  Subject extends Table,\n  Identifier extends Table,\n  Credential extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> extends ProofConstraintClassifier {\n  readonly request: ProofRequestTable<Request>;\n  readonly series: ProofSeriesTable<Series>;\n  readonly generation: ProofGenerationTable<Generation>;\n  readonly continuation: ProofContinuationTable<Continuation>;\n  readonly rateScope: ProofRateScopeTable<RateScope>;\n  readonly abuseEvent: ProofAbuseEventTable<AbuseEvent>;\n  readonly failureEvent: ProofFailureEventTable<FailureEvent>;\n  readonly command: ProofCommandTable<Command>;\n  readonly authority: ProofAuthorityTables<\n    Subject,\n    Identifier,\n    Credential,\n    NativeSubjectId,\n    Expression\n  >;\n  readonly constraints: RequiredProofConstraints;\n  readonly scopeKeys: (input: {\n    readonly moduleId: string;\n    readonly purpose: ProofPurpose;\n    readonly binding: ProofBinding;\n  }) => ProofScopeKeys;\n  readonly encodeInstant: (epochMillis: number) => unknown;\n  readonly decodeInstant: (native: unknown) => Effect.Effect<number, PersistenceMappingError>;\n  readonly allocateVersion?: Effect.Effect<ProofVersion, PersistenceMappingError>;\n  readonly allocateVersionSync?: () => ProofVersion;\n  /** Required by D1 mappings and ignored by interactive targets. */\n  readonly d1?: ProofD1Clock<Expression>;\n}\n\nexport type D1ProofPersistenceMapping<\n  Request extends Table,\n  Series extends Table,\n  Generation extends Table,\n  Continuation extends Table,\n  RateScope extends Table,\n  AbuseEvent extends Table,\n  FailureEvent extends Table,\n  Command extends Table,\n  Subject extends Table,\n  Identifier extends Table,\n  Credential extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> = ProofPersistenceMapping<\n  Request,\n  Series,\n  Generation,\n  Continuation,\n  RateScope,\n  AbuseEvent,\n  FailureEvent,\n  Command,\n  Subject,\n  Identifier,\n  Credential,\n  NativeSubjectId,\n  Expression\n> & {\n  readonly d1: ProofD1Clock<Expression>;\n  readonly authority: ProofAuthorityTables<\n    Subject,\n    Identifier,\n    Credential,\n    NativeSubjectId,\n    Expression\n  > & {\n    readonly identifier: ProofAuthorityTables<\n      Subject,\n      Identifier,\n      Credential,\n      NativeSubjectId,\n      Expression\n    >[\"identifier\"] & {\n      /** Synchronous SQL compiler; Effect-based ID conversion has already completed. */\n      readonly d1CurrentCondition: (input: ProofAuthorityInput<NativeSubjectId>) => Expression;\n    };\n  };\n};\n\nexport type AnyProofPersistenceMapping<Expression extends SqlExpression = SqlExpression> =\n  ProofPersistenceMapping<\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    AnyTableModel,\n    unknown,\n    Expression\n  >;\n"],"mappings":";AAuRA,MAAa,2BAAqD;CAChE,SAAS;CACT,QAAQ;CACR,OAAO;CACP,UAAU;CACV,gBAAgB;CAChB,oBAAoB;CACpB,WACE;CACF,YACE;CACF,cAAc;CACd,SAAS;AACX"}

package/dist/internal/models/session-model.d.mts

@@ -0,0 +1,199 @@
+import { SqlExpression, TableModel } from "../query-operations.mjs";
+import { PersistenceMappingError } from "../mapping-error.mjs";
+import { SubjectIdCodec } from "./common.mjs";
+import { DateTime, Effect } from "effect";
+import { TokenDigest } from "@yielded/auth/Schema";
+import { AuthenticationEvidence, AuthenticationRequirement, PendingAuthenticationRecord, PendingAuthenticationState, SecurityRevision, SessionId, StatefulSessionRecord } from "@yielded/auth/Sessions";
+//#region src/internal/models/session-model.d.ts
+type ColumnKey<T extends TableModel> = T["column"];
+export interface SessionIdCodec<NativeId> {
+  readonly toNative: (id: SessionId) => Effect.Effect<NativeId, PersistenceMappingError>;
+  readonly toSession: (id: NativeId) => Effect.Effect<SessionId, PersistenceMappingError>;
+  readonly equals: (left: NativeId, right: NativeId) => boolean;
+}
+export interface SessionSubjectTables<Subject extends TableModel, NativeId> {
+  readonly subject: {
+    readonly table: Subject["table"];
+    readonly id: ColumnKey<Subject>;
+    readonly status: ColumnKey<Subject>;
+    readonly securityRevision: ColumnKey<Subject>;
+    readonly isActiveStatus: (value: unknown) => boolean;
+    readonly decodeRequirement: (row: Subject["select"]) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;
+    readonly nextSecurityRevision?: (current: SecurityRevision) => Effect.Effect<SecurityRevision, PersistenceMappingError>;
+    readonly nextSecurityRevisionSync?: (current: SecurityRevision) => SecurityRevision;
+  };
+  readonly subjectId: SubjectIdCodec<NativeId>;
+}
+export interface SessionAuthorityTables<Subject extends TableModel, Credential extends TableModel, NativeId> extends SessionSubjectTables<Subject, NativeId> {
+  readonly credential: {
+    readonly table: Credential["table"];
+    readonly subjectId: ColumnKey<Credential>;
+    readonly credentialId: ColumnKey<Credential>;
+    readonly revision: ColumnKey<Credential>;
+    /** Optional consumer status predicate; omitted means every stored credential row is active. */
+    readonly status?: ColumnKey<Credential>;
+    readonly isActiveStatus?: (value: unknown) => boolean;
+  };
+}
+export interface SessionFlowTables<Flow extends TableModel, NativeSubjectId> {
+  readonly flow: {
+    readonly table: Flow["table"];
+    readonly flowId: ColumnKey<Flow>;
+    readonly subjectId: ColumnKey<Flow>;
+    readonly state: ColumnKey<Flow>;
+    readonly pendingDigest: ColumnKey<Flow>;
+    readonly dedupUntil: ColumnKey<Flow>;
+    readonly pendingStateValue: unknown;
+    readonly establishedStateValue: unknown;
+    readonly encodeInstant: (instant: DateTime.Utc) => unknown;
+    readonly decodeInstant: (native: unknown) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;
+    readonly encodePendingInsert: (input: {
+      readonly evidence: AuthenticationEvidence;
+      readonly subjectId: NativeSubjectId;
+      readonly pendingDigest: TokenDigest;
+      readonly dedupUntil: DateTime.Utc;
+    }) => Flow["insert"];
+    readonly encodeEstablishedInsert: (input: {
+      readonly evidence: AuthenticationEvidence;
+      readonly subjectId: NativeSubjectId;
+      readonly dedupUntil: DateTime.Utc;
+    }) => Flow["insert"];
+  };
+}
+export interface StatefulSessionTables<Claims, Session extends TableModel, Flow extends TableModel, NativeSubjectId, NativeSessionId> extends SessionFlowTables<Flow, NativeSubjectId> {
+  readonly session: {
+    readonly table: Session["table"];
+    readonly sessionId: ColumnKey<Session>;
+    readonly subjectId: ColumnKey<Session>;
+    readonly digest: ColumnKey<Session>;
+    readonly version: ColumnKey<Session>;
+    readonly securityRevision: ColumnKey<Session>;
+    readonly issuedAt: ColumnKey<Session>;
+    readonly expiresAt: ColumnKey<Session>;
+    readonly absoluteExpiresAt: ColumnKey<Session>;
+    readonly encodeInstant: (instant: DateTime.Utc) => unknown;
+    readonly encodeInsert: (record: StatefulSessionRecord<Claims>, ids: {
+      readonly subjectId: NativeSubjectId;
+      readonly sessionId: NativeSessionId;
+    }) => Session["insert"];
+    /** Persist the prepared credentialVersion and retain exact private provenance. */
+    readonly encodeRotation: (record: StatefulSessionRecord<Claims>) => Partial<Session["insert"]>;
+    readonly decode: (row: Session["select"]) => Effect.Effect<StatefulSessionRecord<Claims>, PersistenceMappingError>;
+    readonly allocateId?: Effect.Effect<NativeSessionId, PersistenceMappingError>;
+    readonly allocateIdSync?: () => NativeSessionId;
+    readonly allocateVersion?: Effect.Effect<SecurityRevision, PersistenceMappingError>;
+    readonly allocateVersionSync?: () => SecurityRevision;
+  };
+  readonly sessionId: SessionIdCodec<NativeSessionId>;
+}
+export interface PendingAuthenticationTables<Claims, Pending extends TableModel, Flow extends TableModel, NativeSubjectId> extends SessionFlowTables<Flow, NativeSubjectId> {
+  readonly pending: {
+    readonly table: Pending["table"];
+    readonly digest: ColumnKey<Pending>;
+    readonly version: ColumnKey<Pending>;
+    readonly flowId: ColumnKey<Pending>;
+    readonly subjectId: ColumnKey<Pending>;
+    readonly bindingDigest: ColumnKey<Pending>;
+    readonly expiresAt: ColumnKey<Pending>;
+    readonly attemptLimit: ColumnKey<Pending>;
+    readonly failedAttempts: ColumnKey<Pending>;
+    readonly consumed: ColumnKey<Pending>;
+    readonly encodeInstant: (instant: DateTime.Utc) => unknown;
+    readonly encodeInsert: (record: PendingAuthenticationRecord<Claims>, input: {
+      readonly subjectId: NativeSubjectId;
+      readonly failedAttempts: 0;
+      readonly consumed: false;
+    }) => Pending["insert"];
+    readonly decode: (row: Pending["select"]) => Effect.Effect<PendingAuthenticationRecord<Claims>, PersistenceMappingError>;
+    /** Decodes original evidence and storage guards only. The internal pending
+     * context lookup must not execute unrelated consumer Claims transforms. */
+    readonly decodeContext: (row: Pending["select"]) => Effect.Effect<PendingAuthenticationState, PersistenceMappingError>;
+    readonly allocateVersion?: Effect.Effect<SecurityRevision, PersistenceMappingError>;
+    readonly allocateVersionSync?: () => SecurityRevision;
+  };
+}
+export interface SignedSessionValidityTables<Tombstone extends TableModel, NativeSubjectId, NativeSessionId> {
+  readonly tombstone: {
+    readonly table: Tombstone["table"];
+    readonly subjectId: ColumnKey<Tombstone>;
+    readonly sessionId: ColumnKey<Tombstone>;
+    readonly absoluteExpiresAt: ColumnKey<Tombstone>;
+    readonly encodeInstant: (instant: DateTime.Utc) => unknown;
+    readonly decodeInstant: (native: unknown) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;
+    readonly encodeInsert: (input: {
+      readonly subjectId: NativeSubjectId;
+      readonly sessionId: NativeSessionId;
+      readonly absoluteExpiresAt: DateTime.Utc;
+    }) => Tombstone["insert"];
+  };
+  readonly sessionId: SessionIdCodec<NativeSessionId>;
+}
+export interface RequiredSessionConstraints {
+  readonly sessionDigest: "unique(session.digest)";
+  readonly flowId: "unique(flow.flowId)";
+}
+export interface RequiredPendingAuthenticationConstraints {
+  readonly pendingDigest: "unique(pending.digest)";
+  readonly pendingFlow: "unique(pending.flowId)";
+  readonly flowId: "unique(flow.flowId)";
+}
+export interface RequiredStatefulPendingConstraints extends RequiredSessionConstraints, RequiredPendingAuthenticationConstraints {}
+export interface RequiredSignedValidityConstraints {
+  readonly tombstoneOwner: "unique(tombstone.subjectId,tombstone.sessionId)";
+}
+export declare const requiredSessionConstraints: RequiredSessionConstraints;
+export declare const requiredPendingAuthenticationConstraints: RequiredPendingAuthenticationConstraints;
+export declare const requiredStatefulPendingConstraints: RequiredStatefulPendingConstraints;
+export declare const requiredSignedValidityConstraints: RequiredSignedValidityConstraints;
+export interface SessionConstraintClassifier {
+  /**
+   * Match only the named unique constraints declared by this mapping. Broad
+   * SQL/constraint classifiers can relabel application or NOT NULL failures as
+   * a domain conflict.
+   */
+  readonly isConstraintConflict: (cause: unknown) => boolean;
+}
+export type AuthenticationAuthorityMapping<Claims, Subject extends TableModel, Credential extends TableModel, Flow extends TableModel, Pending extends TableModel, NativeSubjectId> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> & SessionConstraintClassifier & ({
+  /** Omit for single-factor authority installations. Pending input then fails closed. */
+  readonly pending?: undefined;
+} | {
+  readonly pending: PendingAuthenticationTables<Claims, Pending, Flow, NativeSubjectId>;
+  readonly constraints: RequiredPendingAuthenticationConstraints;
+});
+export type StatefulSessionMapping<Claims, Subject extends TableModel, Credential extends TableModel, Session extends TableModel, Flow extends TableModel, Pending extends TableModel, NativeSubjectId, NativeSessionId> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> & StatefulSessionTables<Claims, Session, Flow, NativeSubjectId, NativeSessionId> & SessionConstraintClassifier & ({
+  /** Omit when this session module does not support pending MFA completion. */
+  readonly pending?: undefined;
+  readonly constraints: RequiredSessionConstraints;
+} | {
+  readonly pending: PendingAuthenticationTables<Claims, Pending, Flow, NativeSubjectId>["pending"];
+  readonly constraints: RequiredStatefulPendingConstraints;
+});
+export type PendingAuthenticationMapping<Claims, Subject extends TableModel, Credential extends TableModel, Pending extends TableModel, Flow extends TableModel, NativeSubjectId> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> & PendingAuthenticationTables<Claims, Pending, Flow, NativeSubjectId> & SessionConstraintClassifier & {
+  readonly constraints: RequiredPendingAuthenticationConstraints;
+};
+export type SignedSessionValidityMapping<Subject extends TableModel, Tombstone extends TableModel, NativeSubjectId, NativeSessionId> = SessionSubjectTables<Subject, NativeSubjectId> & SignedSessionValidityTables<Tombstone, NativeSubjectId, NativeSessionId> & SessionConstraintClassifier & {
+  readonly constraints: RequiredSignedValidityConstraints;
+};
+/** D1 evaluates these expressions inside the atomic batch, after queueing delay.
+ * `engineNow` must use the exact native representation of every mapped instant
+ * column. `engineNowMillis` is Unix epoch milliseconds for proof freshness.
+ * Changes to the consumer's factor policy MUST bump subject.securityRevision.
+ * Supply the authoritative primary D1 database, never a replica-affined
+ * `withSession` handle, because verification and security revision reads must
+ * observe completed revocation writes across clients.
+ */
+export interface D1SessionClockMapping<Expression extends SqlExpression = SqlExpression> {
+  readonly d1: {
+    readonly engineNow: Expression;
+    readonly engineNowMillis: Expression;
+    readonly activeSubjectStatusValue: unknown;
+    /** Required when `credential.status` is mapped. */
+    readonly activeCredentialStatusValue?: unknown;
+  };
+}
+export type D1AuthenticationAuthorityMapping<Claims, Subject extends TableModel, Credential extends TableModel, Flow extends TableModel, Pending extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> = AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId> & D1SessionClockMapping<Expression>;
+export type D1PendingAuthenticationMapping<Claims, Subject extends TableModel, Credential extends TableModel, Pending extends TableModel, Flow extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> = PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId> & D1SessionClockMapping<Expression>;
+export type D1StatefulSessionMapping<Claims, Subject extends TableModel, Credential extends TableModel, Session extends TableModel, Flow extends TableModel, Pending extends TableModel, NativeSubjectId, NativeSessionId, Expression extends SqlExpression = SqlExpression> = StatefulSessionMapping<Claims, Subject, Credential, Session, Flow, Pending, NativeSubjectId, NativeSessionId> & D1SessionClockMapping<Expression>;
+export type D1SignedSessionValidityMapping<Subject extends TableModel, Tombstone extends TableModel, NativeSubjectId, NativeSessionId, Expression extends SqlExpression = SqlExpression> = SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId> & D1SessionClockMapping<Expression>;
+//#endregion
+//# sourceMappingURL=session-model.d.mts.map

package/dist/internal/models/session-model.mjs

@@ -0,0 +1,20 @@
+import "@yielded/auth/Sessions";
+//#region src/internal/models/session-model.ts
+const requiredSessionConstraints = {
+	sessionDigest: "unique(session.digest)",
+	flowId: "unique(flow.flowId)"
+};
+const requiredPendingAuthenticationConstraints = {
+	pendingDigest: "unique(pending.digest)",
+	pendingFlow: "unique(pending.flowId)",
+	flowId: "unique(flow.flowId)"
+};
+const requiredStatefulPendingConstraints = {
+	...requiredSessionConstraints,
+	...requiredPendingAuthenticationConstraints
+};
+const requiredSignedValidityConstraints = { tombstoneOwner: "unique(tombstone.subjectId,tombstone.sessionId)" };
+//#endregion
+export { requiredPendingAuthenticationConstraints, requiredSessionConstraints, requiredSignedValidityConstraints, requiredStatefulPendingConstraints };
+
+//# sourceMappingURL=session-model.mjs.map

package/dist/internal/models/session-model.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-model.mjs","names":[],"sources":["../../../src/internal/models/session-model.ts"],"sourcesContent":["import type { TokenDigest } from \"@yielded/auth/Schema\";\nimport {\n  type AuthenticationRequirement,\n  type AuthenticationEvidence,\n  type SecurityRevision,\n  type SessionId,\n  type PendingAuthenticationRecord,\n  type PendingAuthenticationState,\n  type StatefulSessionRecord,\n} from \"@yielded/auth/Sessions\";\nimport type { DateTime, Effect } from \"effect\";\n\nimport type { TableModel as Table, SqlExpression } from \"../query-operations\";\nimport type { PersistenceMappingError, SubjectIdCodec } from \"./common\";\n\ntype ColumnKey<T extends Table> = T[\"column\"];\n\nexport interface SessionIdCodec<NativeId> {\n  readonly toNative: (id: SessionId) => Effect.Effect<NativeId, PersistenceMappingError>;\n  readonly toSession: (id: NativeId) => Effect.Effect<SessionId, PersistenceMappingError>;\n  readonly equals: (left: NativeId, right: NativeId) => boolean;\n}\n\nexport interface SessionSubjectTables<Subject extends Table, NativeId> {\n  readonly subject: {\n    readonly table: Subject[\"table\"];\n    readonly id: ColumnKey<Subject>;\n    readonly status: ColumnKey<Subject>;\n    readonly securityRevision: ColumnKey<Subject>;\n    readonly isActiveStatus: (value: unknown) => boolean;\n    readonly decodeRequirement: (\n      row: Subject[\"select\"],\n    ) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;\n    readonly nextSecurityRevision?: (\n      current: SecurityRevision,\n    ) => Effect.Effect<SecurityRevision, PersistenceMappingError>;\n    readonly nextSecurityRevisionSync?: (current: SecurityRevision) => SecurityRevision;\n  };\n  readonly subjectId: SubjectIdCodec<NativeId>;\n}\n\nexport interface SessionAuthorityTables<\n  Subject extends Table,\n  Credential extends Table,\n  NativeId,\n> extends SessionSubjectTables<Subject, NativeId> {\n  readonly credential: {\n    readonly table: Credential[\"table\"];\n    readonly subjectId: ColumnKey<Credential>;\n    readonly credentialId: ColumnKey<Credential>;\n    readonly revision: ColumnKey<Credential>;\n    /** Optional consumer status predicate; omitted means every stored credential row is active. */\n    readonly status?: ColumnKey<Credential>;\n    readonly isActiveStatus?: (value: unknown) => boolean;\n  };\n}\n\nexport interface SessionFlowTables<Flow extends Table, NativeSubjectId> {\n  readonly flow: {\n    readonly table: Flow[\"table\"];\n    readonly flowId: ColumnKey<Flow>;\n    readonly subjectId: ColumnKey<Flow>;\n    readonly state: ColumnKey<Flow>;\n    readonly pendingDigest: ColumnKey<Flow>;\n    readonly dedupUntil: ColumnKey<Flow>;\n    readonly pendingStateValue: unknown;\n    readonly establishedStateValue: unknown;\n    readonly encodeInstant: (instant: DateTime.Utc) => unknown;\n    readonly decodeInstant: (\n      native: unknown,\n    ) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;\n    readonly encodePendingInsert: (input: {\n      readonly evidence: AuthenticationEvidence;\n      readonly subjectId: NativeSubjectId;\n      readonly pendingDigest: TokenDigest;\n      readonly dedupUntil: DateTime.Utc;\n    }) => Flow[\"insert\"];\n    readonly encodeEstablishedInsert: (input: {\n      readonly evidence: AuthenticationEvidence;\n      readonly subjectId: NativeSubjectId;\n      readonly dedupUntil: DateTime.Utc;\n    }) => Flow[\"insert\"];\n  };\n}\n\nexport interface StatefulSessionTables<\n  Claims,\n  Session extends Table,\n  Flow extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n> extends SessionFlowTables<Flow, NativeSubjectId> {\n  readonly session: {\n    readonly table: Session[\"table\"];\n    readonly sessionId: ColumnKey<Session>;\n    readonly subjectId: ColumnKey<Session>;\n    readonly digest: ColumnKey<Session>;\n    readonly version: ColumnKey<Session>;\n    readonly securityRevision: ColumnKey<Session>;\n    readonly issuedAt: ColumnKey<Session>;\n    readonly expiresAt: ColumnKey<Session>;\n    readonly absoluteExpiresAt: ColumnKey<Session>;\n    readonly encodeInstant: (instant: DateTime.Utc) => unknown;\n    readonly encodeInsert: (\n      record: StatefulSessionRecord<Claims>,\n      ids: {\n        readonly subjectId: NativeSubjectId;\n        readonly sessionId: NativeSessionId;\n      },\n    ) => Session[\"insert\"];\n    /** Persist the prepared credentialVersion and retain exact private provenance. */\n    readonly encodeRotation: (record: StatefulSessionRecord<Claims>) => Partial<Session[\"insert\"]>;\n    readonly decode: (\n      row: Session[\"select\"],\n    ) => Effect.Effect<StatefulSessionRecord<Claims>, PersistenceMappingError>;\n    readonly allocateId?: Effect.Effect<NativeSessionId, PersistenceMappingError>;\n    readonly allocateIdSync?: () => NativeSessionId;\n    readonly allocateVersion?: Effect.Effect<SecurityRevision, PersistenceMappingError>;\n    readonly allocateVersionSync?: () => SecurityRevision;\n  };\n  readonly sessionId: SessionIdCodec<NativeSessionId>;\n}\n\nexport interface PendingAuthenticationTables<\n  Claims,\n  Pending extends Table,\n  Flow extends Table,\n  NativeSubjectId,\n> extends SessionFlowTables<Flow, NativeSubjectId> {\n  readonly pending: {\n    readonly table: Pending[\"table\"];\n    readonly digest: ColumnKey<Pending>;\n    readonly version: ColumnKey<Pending>;\n    readonly flowId: ColumnKey<Pending>;\n    readonly subjectId: ColumnKey<Pending>;\n    readonly bindingDigest: ColumnKey<Pending>;\n    readonly expiresAt: ColumnKey<Pending>;\n    readonly attemptLimit: ColumnKey<Pending>;\n    readonly failedAttempts: ColumnKey<Pending>;\n    readonly consumed: ColumnKey<Pending>;\n    readonly encodeInstant: (instant: DateTime.Utc) => unknown;\n    readonly encodeInsert: (\n      record: PendingAuthenticationRecord<Claims>,\n      input: {\n        readonly subjectId: NativeSubjectId;\n        readonly failedAttempts: 0;\n        readonly consumed: false;\n      },\n    ) => Pending[\"insert\"];\n    readonly decode: (\n      row: Pending[\"select\"],\n    ) => Effect.Effect<PendingAuthenticationRecord<Claims>, PersistenceMappingError>;\n    /** Decodes original evidence and storage guards only. The internal pending\n     * context lookup must not execute unrelated consumer Claims transforms. */\n    readonly decodeContext: (\n      row: Pending[\"select\"],\n    ) => Effect.Effect<PendingAuthenticationState, PersistenceMappingError>;\n    readonly allocateVersion?: Effect.Effect<SecurityRevision, PersistenceMappingError>;\n    readonly allocateVersionSync?: () => SecurityRevision;\n  };\n}\n\nexport interface SignedSessionValidityTables<\n  Tombstone extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n> {\n  readonly tombstone: {\n    readonly table: Tombstone[\"table\"];\n    readonly subjectId: ColumnKey<Tombstone>;\n    readonly sessionId: ColumnKey<Tombstone>;\n    readonly absoluteExpiresAt: ColumnKey<Tombstone>;\n    readonly encodeInstant: (instant: DateTime.Utc) => unknown;\n    readonly decodeInstant: (\n      native: unknown,\n    ) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;\n    readonly encodeInsert: (input: {\n      readonly subjectId: NativeSubjectId;\n      readonly sessionId: NativeSessionId;\n      readonly absoluteExpiresAt: DateTime.Utc;\n    }) => Tombstone[\"insert\"];\n  };\n  readonly sessionId: SessionIdCodec<NativeSessionId>;\n}\n\nexport interface RequiredSessionConstraints {\n  readonly sessionDigest: \"unique(session.digest)\";\n  readonly flowId: \"unique(flow.flowId)\";\n}\n\nexport interface RequiredPendingAuthenticationConstraints {\n  readonly pendingDigest: \"unique(pending.digest)\";\n  readonly pendingFlow: \"unique(pending.flowId)\";\n  readonly flowId: \"unique(flow.flowId)\";\n}\n\nexport interface RequiredStatefulPendingConstraints\n  extends RequiredSessionConstraints, RequiredPendingAuthenticationConstraints {}\n\nexport interface RequiredSignedValidityConstraints {\n  readonly tombstoneOwner: \"unique(tombstone.subjectId,tombstone.sessionId)\";\n}\n\nexport const requiredSessionConstraints: RequiredSessionConstraints = {\n  sessionDigest: \"unique(session.digest)\",\n  flowId: \"unique(flow.flowId)\",\n};\n\nexport const requiredPendingAuthenticationConstraints: RequiredPendingAuthenticationConstraints = {\n  pendingDigest: \"unique(pending.digest)\",\n  pendingFlow: \"unique(pending.flowId)\",\n  flowId: \"unique(flow.flowId)\",\n};\n\nexport const requiredStatefulPendingConstraints: RequiredStatefulPendingConstraints = {\n  ...requiredSessionConstraints,\n  ...requiredPendingAuthenticationConstraints,\n};\n\nexport const requiredSignedValidityConstraints: RequiredSignedValidityConstraints = {\n  tombstoneOwner: \"unique(tombstone.subjectId,tombstone.sessionId)\",\n};\n\nexport interface SessionConstraintClassifier {\n  /**\n   * Match only the named unique constraints declared by this mapping. Broad\n   * SQL/constraint classifiers can relabel application or NOT NULL failures as\n   * a domain conflict.\n   */\n  readonly isConstraintConflict: (cause: unknown) => boolean;\n}\n\nexport type AuthenticationAuthorityMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Flow extends Table,\n  Pending extends Table,\n  NativeSubjectId,\n> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> &\n  SessionConstraintClassifier &\n  (\n    | {\n        /** Omit for single-factor authority installations. Pending input then fails closed. */\n        readonly pending?: undefined;\n      }\n    | {\n        readonly pending: PendingAuthenticationTables<Claims, Pending, Flow, NativeSubjectId>;\n        readonly constraints: RequiredPendingAuthenticationConstraints;\n      }\n  );\n\nexport type StatefulSessionMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Session extends Table,\n  Flow extends Table,\n  Pending extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> &\n  StatefulSessionTables<Claims, Session, Flow, NativeSubjectId, NativeSessionId> &\n  SessionConstraintClassifier &\n  (\n    | {\n        /** Omit when this session module does not support pending MFA completion. */\n        readonly pending?: undefined;\n        readonly constraints: RequiredSessionConstraints;\n      }\n    | {\n        readonly pending: PendingAuthenticationTables<\n          Claims,\n          Pending,\n          Flow,\n          NativeSubjectId\n        >[\"pending\"];\n        readonly constraints: RequiredStatefulPendingConstraints;\n      }\n  );\n\nexport type PendingAuthenticationMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Pending extends Table,\n  Flow extends Table,\n  NativeSubjectId,\n> = SessionAuthorityTables<Subject, Credential, NativeSubjectId> &\n  PendingAuthenticationTables<Claims, Pending, Flow, NativeSubjectId> &\n  SessionConstraintClassifier & {\n    readonly constraints: RequiredPendingAuthenticationConstraints;\n  };\n\nexport type SignedSessionValidityMapping<\n  Subject extends Table,\n  Tombstone extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n> = SessionSubjectTables<Subject, NativeSubjectId> &\n  SignedSessionValidityTables<Tombstone, NativeSubjectId, NativeSessionId> &\n  SessionConstraintClassifier & {\n    readonly constraints: RequiredSignedValidityConstraints;\n  };\n\n/** D1 evaluates these expressions inside the atomic batch, after queueing delay.\n * `engineNow` must use the exact native representation of every mapped instant\n * column. `engineNowMillis` is Unix epoch milliseconds for proof freshness.\n * Changes to the consumer's factor policy MUST bump subject.securityRevision.\n * Supply the authoritative primary D1 database, never a replica-affined\n * `withSession` handle, because verification and security revision reads must\n * observe completed revocation writes across clients.\n */\nexport interface D1SessionClockMapping<Expression extends SqlExpression = SqlExpression> {\n  readonly d1: {\n    readonly engineNow: Expression;\n    readonly engineNowMillis: Expression;\n    readonly activeSubjectStatusValue: unknown;\n    /** Required when `credential.status` is mapped. */\n    readonly activeCredentialStatusValue?: unknown;\n  };\n}\n\nexport type D1AuthenticationAuthorityMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Flow extends Table,\n  Pending extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> = AuthenticationAuthorityMapping<Claims, Subject, Credential, Flow, Pending, NativeSubjectId> &\n  D1SessionClockMapping<Expression>;\n\nexport type D1PendingAuthenticationMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Pending extends Table,\n  Flow extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> = PendingAuthenticationMapping<Claims, Subject, Credential, Pending, Flow, NativeSubjectId> &\n  D1SessionClockMapping<Expression>;\n\nexport type D1StatefulSessionMapping<\n  Claims,\n  Subject extends Table,\n  Credential extends Table,\n  Session extends Table,\n  Flow extends Table,\n  Pending extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n  Expression extends SqlExpression = SqlExpression,\n> = StatefulSessionMapping<\n  Claims,\n  Subject,\n  Credential,\n  Session,\n  Flow,\n  Pending,\n  NativeSubjectId,\n  NativeSessionId\n> &\n  D1SessionClockMapping<Expression>;\n\nexport type D1SignedSessionValidityMapping<\n  Subject extends Table,\n  Tombstone extends Table,\n  NativeSubjectId,\n  NativeSessionId,\n  Expression extends SqlExpression = SqlExpression,\n> = SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId> &\n  D1SessionClockMapping<Expression>;\n"],"mappings":";;AA2MA,MAAa,6BAAyD;CACpE,eAAe;CACf,QAAQ;AACV;AAEA,MAAa,2CAAqF;CAChG,eAAe;CACf,aAAa;CACb,QAAQ;AACV;AAEA,MAAa,qCAAyE;CACpF,GAAG;CACH,GAAG;AACL;AAEA,MAAa,oCAAuE,EAClF,gBAAgB,kDAClB"}