@yielded/auth-persistence 0.1.0-beta.24 → 0.1.0-beta.26

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

@@ -1,285 +1,56 @@
-import { PersistenceMappingError } from "../mapping-error.mjs";
-import { AnyTableModel, SqlExpression, TableModel } from "../query-operations.mjs";
+import { AnyTableModel, SqlExpression, TableModel } from "../table-model.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";
+import { ProofIssueRecord } 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>;
+type Column<T extends TableModel> = T["column"];
+/** One current code per canonical identifier and subject. Binding is canonical
+ * Schema JSON, and token comparisons are byte exact even on collated columns. */
+export interface ProofTable<Proof extends TableModel> {
+  readonly table: Proof["table"];
+  readonly moduleId: Column<Proof>;
+  readonly purpose: Column<Proof>;
+  readonly seriesKey: Column<Proof>;
+  readonly proofId: Column<Proof>;
+  readonly binding: Column<Proof>;
+  readonly verifierKeyId: Column<Proof>;
+  readonly verifierDigest: Column<Proof>;
+  readonly issuedAt: Column<Proof>;
+  readonly expiresAt: Column<Proof>;
+  readonly failedAttempts: Column<Proof>;
   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 record: ProofIssueRecord;
     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"];
+  }) => Proof["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 ProofClock<Expression extends SqlExpression = SqlExpression> {
+  readonly encodeInstant: (millis: number) => unknown;
+  readonly decodeInstant: (value: unknown) => number;
+  /** Integer engine wall-clock milliseconds; PostgreSQL uses clock_timestamp(). */
+  readonly engineNowMillis: Expression;
+  readonly toMillis: (expression: Expression) => Expression;
+  readonly fromMillis: (expression: Expression) => Expression;
 }
 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)";
+  readonly series: "unique(proof.moduleId,proof.purpose,proof.seriesKey)";
+  readonly proof: "unique(proof.moduleId,proof.proofId)";
 }
 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>;
+export interface ProofPersistenceMapping<Proof extends TableModel, Subject extends TableModel, NativeSubjectId, Expression extends SqlExpression = SqlExpression> {
+  readonly proof: ProofTable<Proof>;
+  /** Bare subject-bound redemption takes this lock before touching the proof.
+   * Protected mutation owners already holding it use the shared locked primitive. */
+  readonly subject: {
+    readonly table: Subject["table"];
+    readonly id: Column<Subject>;
+  };
+  readonly subjectId: SubjectIdCodec<NativeSubjectId>;
+  readonly clock: ProofClock<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;
-    };
+  /** D1 planning reads use the primary engine. */
+  readonly d1?: {
+    readonly primary: true;
   };
-};
-export type AnyProofPersistenceMapping<Expression extends SqlExpression = SqlExpression> = ProofPersistenceMapping<AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, AnyTableModel, unknown, Expression>;
+}
+export type AnyProofPersistenceMapping<Expression extends SqlExpression = SqlExpression> = ProofPersistenceMapping<AnyTableModel, AnyTableModel, unknown, Expression>;
 //#endregion
 //# sourceMappingURL=proof-model.d.mts.map

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

@@ -1,15 +1,7 @@
 //#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)"
+	series: "unique(proof.moduleId,proof.purpose,proof.seriesKey)",
+	proof: "unique(proof.moduleId,proof.proofId)"
 };
 //#endregion
 export { requiredProofConstraints };

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

@@ -1 +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"}
+{"version":3,"file":"proof-model.mjs","names":[],"sources":["../../../src/internal/models/proof-model.ts"],"sourcesContent":["import type { ProofIssueRecord } from \"@yielded/auth/Proofs\";\n\nimport type { AnyTableModel, TableModel as Table, SqlExpression } from \"../table-model\";\nimport type { SubjectIdCodec } from \"./common\";\n\ntype Column<T extends Table> = T[\"column\"];\n\n/** One current code per canonical identifier and subject. Binding is canonical\n * Schema JSON, and token comparisons are byte exact even on collated columns. */\nexport interface ProofTable<Proof extends Table> {\n  readonly table: Proof[\"table\"];\n  readonly moduleId: Column<Proof>;\n  readonly purpose: Column<Proof>;\n  readonly seriesKey: Column<Proof>;\n  readonly proofId: Column<Proof>;\n  readonly binding: Column<Proof>;\n  readonly verifierKeyId: Column<Proof>;\n  readonly verifierDigest: Column<Proof>;\n  readonly issuedAt: Column<Proof>;\n  readonly expiresAt: Column<Proof>;\n  readonly failedAttempts: Column<Proof>;\n  readonly encodeInsert: (input: {\n    readonly record: ProofIssueRecord;\n    readonly seriesKey: string;\n  }) => Proof[\"insert\"];\n}\n\nexport interface ProofClock<Expression extends SqlExpression = SqlExpression> {\n  readonly encodeInstant: (millis: number) => unknown;\n  readonly decodeInstant: (value: unknown) => number;\n  /** Integer engine wall-clock milliseconds; PostgreSQL uses clock_timestamp(). */\n  readonly engineNowMillis: Expression;\n  readonly toMillis: (expression: Expression) => Expression;\n  readonly fromMillis: (expression: Expression) => Expression;\n}\n\nexport interface RequiredProofConstraints {\n  readonly series: \"unique(proof.moduleId,proof.purpose,proof.seriesKey)\";\n  readonly proof: \"unique(proof.moduleId,proof.proofId)\";\n}\n\nexport const requiredProofConstraints: RequiredProofConstraints = {\n  series: \"unique(proof.moduleId,proof.purpose,proof.seriesKey)\",\n  proof: \"unique(proof.moduleId,proof.proofId)\",\n};\n\nexport interface ProofPersistenceMapping<\n  Proof extends Table,\n  Subject extends Table,\n  NativeSubjectId,\n  Expression extends SqlExpression = SqlExpression,\n> {\n  readonly proof: ProofTable<Proof>;\n  /** Bare subject-bound redemption takes this lock before touching the proof.\n   * Protected mutation owners already holding it use the shared locked primitive. */\n  readonly subject: {\n    readonly table: Subject[\"table\"];\n    readonly id: Column<Subject>;\n  };\n  readonly subjectId: SubjectIdCodec<NativeSubjectId>;\n  readonly clock: ProofClock<Expression>;\n  readonly constraints: RequiredProofConstraints;\n  /** D1 planning reads use the primary engine. */\n  readonly d1?: { readonly primary: true };\n}\n\nexport type AnyProofPersistenceMapping<Expression extends SqlExpression = SqlExpression> =\n  ProofPersistenceMapping<AnyTableModel, AnyTableModel, unknown, Expression>;\n"],"mappings":";AAyCA,MAAa,2BAAqD;CAChE,QAAQ;CACR,OAAO;AACT"}