@rulvar/store-postgres 1.104.0 → 1.106.0

package/dist/index.d.ts

@@ -147,17 +147,56 @@ declare class QuotaDeadlineError extends Error {
   readonly deadlineMs: number;
   /** The schema whose admission missed it. */
   readonly schema: string;
-  /** Where the path stood: acquiring a connection, or mid-transaction. */
-  readonly phase: "acquire" | "transaction";
-  constructor(deadlineMs: number, schema: string, phase: "acquire" | "transaction");
+  /**
+  * Where the path stood: inside the schema bootstrap transaction,
+  * waiting for a pooled connection, or mid-admission-transaction. The
+  * message narrates only what actually happened to a connection in
+  * that phase (RV608): a refusal while WAITING held nothing, so it
+  * destroyed nothing.
+  */
+  readonly phase: "bootstrap" | "acquire" | "transaction";
+  constructor(deadlineMs: number, schema: string, phase: "bootstrap" | "acquire" | "transaction");
+}
+/**
+* Thrown by an admission whose booted rule identity no longer matches
+* the schema's (RV608): another deployment rotated the recorded rules
+* fingerprint and generation after this host booted, so admitting under
+* the retired rules would silently split the budget across mismatched
+* bucket keys. The refused host must restart with the current rule set;
+* its outstanding reservations age out with their window (the same
+* bounded residue a crashed process leaves), and the rotation carried
+* current-window consumption conservatively. Like every limiter throw,
+* it lands in the engine's `onLimiterError` policy.
+*/
+declare class QuotaGenerationError extends Error {
+  /** The schema whose recorded identity moved. */
+  readonly schema: string;
+  /** What this instance booted with. */
+  readonly booted: {
+    fingerprint: string;
+    generation: number;
+  };
+  /** What the schema records now (absent fields mean a wiped meta row). */
+  readonly recorded: {
+    fingerprint: string | undefined;
+    generation: number | undefined;
+  };
+  constructor(schema: string, booted: {
+    fingerprint: string;
+    generation: number;
+  }, recorded: {
+    fingerprint: string | undefined;
+    generation: number | undefined;
+  });
 }
 /**
 * The canonical fingerprint of one rule SET (RV506): sha256 hex over
-* the sorted canonical rule keys. Order-insensitive on purpose,
-* matching bucket semantics (equal rules land on the same bucket
-* regardless of array position), so reordering a config never reads as
-* a rules change. Exported so a deployment can precompute the value it
-* expects a schema to have recorded.
+* the sorted canonical rule keys (the core's `quotaRuleKey`, the same
+* encoding both store references bucket on). Order-insensitive on
+* purpose, matching bucket semantics (equal rules land on the same
+* bucket regardless of array position), so reordering a config never
+* reads as a rules change. Exported so a deployment can precompute the
+* value it expects a schema to have recorded.
 */
 declare function quotaRulesFingerprint(rules: readonly QuotaRule[]): string;
 interface PostgresQuotaLimiterOptions {
@@ -234,10 +273,24 @@ declare class PostgresQuotaLimiter implements QuotaLimiter {
   private readonly pool;
   private readonly schema;
   private readonly rules;
+  /** Matching order for the denial fold: canonical rule-key order
+  * (RV608), so permuted identical sets produce byte-identical
+  * refusals. Telemetry keeps the declared order. */
+  private readonly ordered;
+  /** Computed ONCE from the immutable snapshot at construction (RV608):
+  * what boot records and every admission re-verifies. */
+  private readonly fingerprint;
+  /** The schema generation this instance booted at; admissions re-read
+  * the schema's and are fenced typed on a mismatch (RV608). */
+  private generation;
   private readonly admissionDeadlineMs;
   private readonly acceptRulesUpdate;
   private readonly now;
   private boot;
+  /** The bootstrap transaction's connection while one is in flight, so
+  * a deadline can destroy it instead of letting an abandoned bootstrap
+  * commit DDL or a rotation late (RV608). */
+  private bootClient;
   constructor(options: PostgresQuotaLimiterOptions);
   /** `"schema".rulvar_<name>`, always schema-qualified. */
   private table;
@@ -268,6 +321,16 @@ declare class PostgresQuotaLimiter implements QuotaLimiter {
   * timeouts).
   */
   private withQuotaLock;
+  /**
+  * The generation fence (RV608), run INSIDE every admission
+  * transaction after the lock is taken: the schema's recorded rule
+  * identity is re-read and compared to what this instance booted, so a
+  * host whose rules were rotated away admits NOTHING under retired
+  * bucket keys. The refusal is typed, and the boot memo is cleared so
+  * the host's next call re-boots into the honest boot-time refusal
+  * naming both fingerprints.
+  */
+  private assertCurrentIdentity;
   reserve(request: QuotaReservationRequest): Promise<QuotaDecision>;
   reconcile(reservationId: string, usage: Usage): Promise<void>;
   /** Current-window counters per rule, for telemetry and referees. */
@@ -282,4 +345,4 @@ declare class PostgresQuotaLimiter implements QuotaLimiter {
   private prune;
 }
 //#endregion
-export { DEFAULT_LEASE_TTL_MS, DEFAULT_POOL_MAX, PostgresQuotaLimiter, type PostgresQuotaLimiterOptions, PostgresStore, type PostgresStoreOptions, type PostgresTranscriptStore, QUOTA_ADMISSION_DEADLINE_MS, QUOTA_LOCK_TIMEOUT_MS, QuotaDeadlineError, quotaRulesFingerprint };
+export { DEFAULT_LEASE_TTL_MS, DEFAULT_POOL_MAX, PostgresQuotaLimiter, type PostgresQuotaLimiterOptions, PostgresStore, type PostgresStoreOptions, type PostgresTranscriptStore, QUOTA_ADMISSION_DEADLINE_MS, QUOTA_LOCK_TIMEOUT_MS, QuotaDeadlineError, QuotaGenerationError, quotaRulesFingerprint };

package/dist/index.js

@@ -1,5 +1,5 @@
 import pg from "pg";
-import { ConfigError, JournalOrderViolation, LeaseHeldError, QUOTA_WINDOW_MS, mergeQuotaDenial, metaMatchesFilter, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, validateQuotaRules } from "@rulvar/core";
+import { ConfigError, JournalOrderViolation, LeaseHeldError, MAX_TIMER_DELAY_MS, QUOTA_WINDOW_MS, mergeQuotaDenial, metaMatchesFilter, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, snapshotQuotaRules } from "@rulvar/core";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/store.ts
 /**
@@ -495,43 +495,72 @@ var QuotaDeadlineError = class extends Error {
 	deadlineMs;
 	/** The schema whose admission missed it. */
 	schema;
-	/** Where the path stood: acquiring a connection, or mid-transaction. */
+	/**
+	* Where the path stood: inside the schema bootstrap transaction,
+	* waiting for a pooled connection, or mid-admission-transaction. The
+	* message narrates only what actually happened to a connection in
+	* that phase (RV608): a refusal while WAITING held nothing, so it
+	* destroyed nothing.
+	*/
 	phase;
 	constructor(deadlineMs, schema, phase) {
-		super(`PostgresQuotaLimiter admission over schema "${schema}" missed its ${String(deadlineMs)}ms deadline ` + (phase === "acquire" ? "while waiting for bootstrap or a pooled connection" : "inside the admission transaction") + "; the in-flight admission was abandoned and its connection destroyed");
+		super(`PostgresQuotaLimiter admission over schema "${schema}" missed its ${String(deadlineMs)}ms deadline ` + (phase === "bootstrap" ? "during schema bootstrap; the bootstrap transaction was abandoned and its connection destroyed, so nothing it staged (DDL, fingerprint, generation) was committed" : phase === "acquire" ? "while waiting for a pooled connection; the admission was abandoned before it held one" : "inside the admission transaction; the admission was abandoned and its connection destroyed"));
 		this.name = "QuotaDeadlineError";
 		this.deadlineMs = deadlineMs;
 		this.schema = schema;
 		this.phase = phase;
 	}
 };
-const wallClock = Date.now.bind(globalThis);
 /**
-* The canonical bucket key of one rule: a fixed-field-order JSON of
-* its content, identical across hosts for identical rules (and
-* identical to the SqliteQuotaLimiter encoding).
+* Thrown by an admission whose booted rule identity no longer matches
+* the schema's (RV608): another deployment rotated the recorded rules
+* fingerprint and generation after this host booted, so admitting under
+* the retired rules would silently split the budget across mismatched
+* bucket keys. The refused host must restart with the current rule set;
+* its outstanding reservations age out with their window (the same
+* bounded residue a crashed process leaves), and the rotation carried
+* current-window consumption conservatively. Like every limiter throw,
+* it lands in the engine's `onLimiterError` policy.
 */
-function ruleKey(rule) {
-	return JSON.stringify({
-		provider: rule.provider ?? null,
-		model: rule.model ?? null,
-		tenant: rule.tenant ?? null,
-		requestsPerMinute: rule.requestsPerMinute ?? null,
-		tokensPerMinute: rule.tokensPerMinute ?? null
-	});
-}
+var QuotaGenerationError = class extends Error {
+	/** The schema whose recorded identity moved. */
+	schema;
+	/** What this instance booted with. */
+	booted;
+	/** What the schema records now (absent fields mean a wiped meta row). */
+	recorded;
+	constructor(schema, booted, recorded) {
+		super(`PostgresQuotaLimiter admission over schema "${schema}" was fenced: the schema now records rules fingerprint ${recorded.fingerprint ?? "(none)"} at generation ${String(recorded.generation ?? "(none)")}, this instance booted fingerprint ${booted.fingerprint} at generation ${String(booted.generation)}. The rules rotated after this host booted; restart it with the current rule set. Its outstanding reservations age out with their window, and the rotation carried current-window consumption conservatively.`);
+		this.name = "QuotaGenerationError";
+		this.schema = schema;
+		this.booted = booted;
+		this.recorded = recorded;
+	}
+};
+const wallClock = Date.now.bind(globalThis);
 /**
 * The canonical fingerprint of one rule SET (RV506): sha256 hex over
-* the sorted canonical rule keys. Order-insensitive on purpose,
-* matching bucket semantics (equal rules land on the same bucket
-* regardless of array position), so reordering a config never reads as
-* a rules change. Exported so a deployment can precompute the value it
-* expects a schema to have recorded.
+* the sorted canonical rule keys (the core's `quotaRuleKey`, the same
+* encoding both store references bucket on). Order-insensitive on
+* purpose, matching bucket semantics (equal rules land on the same
+* bucket regardless of array position), so reordering a config never
+* reads as a rules change. Exported so a deployment can precompute the
+* value it expects a schema to have recorded.
 */
 function quotaRulesFingerprint(rules) {
-	const keys = rules.map(ruleKey).sort();
+	const keys = rules.map(quotaRuleKey).sort();
 	return createHash("sha256").update(JSON.stringify(keys)).digest("hex");
 }
+/** The dimension triple of one canonical rule key, the identity the
+* rotation carry maps consumption across cap changes by. */
+function dimensionTriple(key) {
+	const parsed = JSON.parse(key);
+	return JSON.stringify({
+		provider: parsed.provider ?? null,
+		model: parsed.model ?? null,
+		tenant: parsed.tenant ?? null
+	});
+}
 /**
 * The multi-host reference implementation of the core QuotaLimiter
 * SPI: engine processes pointing instances at ONE database and schema
@@ -563,19 +592,38 @@ var PostgresQuotaLimiter = class {
 	pool;
 	schema;
 	rules;
+	/** Matching order for the denial fold: canonical rule-key order
+	* (RV608), so permuted identical sets produce byte-identical
+	* refusals. Telemetry keeps the declared order. */
+	ordered;
+	/** Computed ONCE from the immutable snapshot at construction (RV608):
+	* what boot records and every admission re-verifies. */
+	fingerprint;
+	/** The schema generation this instance booted at; admissions re-read
+	* the schema's and are fenced typed on a mismatch (RV608). */
+	generation = 0;
 	admissionDeadlineMs;
 	acceptRulesUpdate;
 	now;
 	boot;
+	/** The bootstrap transaction's connection while one is in flight, so
+	* a deadline can destroy it instead of letting an abandoned bootstrap
+	* commit DDL or a rotation late (RV608). */
+	bootClient;
 	constructor(options) {
 		if (typeof options.url !== "string" || options.url === "") throw new ConfigError("PostgresQuotaLimiterOptions.url must be a nonempty connection string");
 		const schema = options.schema ?? "public";
 		if (!IDENTIFIER.test(schema)) throw new ConfigError(`PostgresQuotaLimiterOptions.schema must be a plain SQL identifier; got '${schema}'`);
-		validateQuotaRules(options.rules, "PostgresQuotaLimiterOptions.rules");
 		if (options.max !== void 0 && (!Number.isInteger(options.max) || options.max < 1)) throw new ConfigError(`PostgresQuotaLimiterOptions.max must be a positive integer; got ${String(options.max)}`);
-		if (options.admissionDeadlineMs !== void 0 && (!Number.isInteger(options.admissionDeadlineMs) || options.admissionDeadlineMs <= 2e3)) throw new ConfigError(`PostgresQuotaLimiterOptions.admissionDeadlineMs must be an integer greater than QUOTA_LOCK_TIMEOUT_MS (${String(QUOTA_LOCK_TIMEOUT_MS)}), the lock-wait stage it bounds; got ${String(options.admissionDeadlineMs)}`);
+		if (options.admissionDeadlineMs !== void 0 && (!Number.isInteger(options.admissionDeadlineMs) || options.admissionDeadlineMs <= 2e3 || options.admissionDeadlineMs > MAX_TIMER_DELAY_MS)) throw new ConfigError(`PostgresQuotaLimiterOptions.admissionDeadlineMs must be an integer greater than QUOTA_LOCK_TIMEOUT_MS (${String(QUOTA_LOCK_TIMEOUT_MS)}), the lock-wait stage it bounds, and at most ${String(MAX_TIMER_DELAY_MS)} (the Node timer maximum, above which a timer fires after about a millisecond); got ${String(options.admissionDeadlineMs)}`);
+		if (options.acceptRulesUpdate !== void 0 && typeof options.acceptRulesUpdate !== "boolean") throw new ConfigError(`PostgresQuotaLimiterOptions.acceptRulesUpdate must be a boolean when given (it authorizes rewriting the schema's recorded rule identity, so truthiness is not enough); got ${JSON.stringify(options.acceptRulesUpdate)}`);
 		this.schema = schema;
-		this.rules = options.rules;
+		this.rules = snapshotQuotaRules(options.rules, "PostgresQuotaLimiterOptions.rules");
+		this.ordered = this.rules.map((rule) => ({
+			rule,
+			key: quotaRuleKey(rule)
+		})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+		this.fingerprint = quotaRulesFingerprint(this.rules);
 		this.admissionDeadlineMs = options.admissionDeadlineMs ?? 5e3;
 		this.acceptRulesUpdate = options.acceptRulesUpdate ?? false;
 		this.now = options.now ?? wallClock;
@@ -605,10 +653,12 @@ var PostgresQuotaLimiter = class {
 		return this.boot;
 	}
 	async runBootstrap() {
-		const fingerprint = quotaRulesFingerprint(this.rules);
 		const client = await this.pool.connect();
+		this.bootClient = client;
+		let destroyed = false;
 		try {
 			await client.query("BEGIN");
+			await client.query(`SET LOCAL lock_timeout = '${String(QUOTA_LOCK_TIMEOUT_MS)}ms'`);
 			await client.query("SELECT pg_advisory_xact_lock(hashtextextended($1, $2))", [`rulvar-quota-boot:${this.schema}`, LOCK_SEED]);
 			if (this.schema !== "public") await client.query(`CREATE SCHEMA IF NOT EXISTS "${this.schema}"`);
 			await client.query(`
@@ -630,20 +680,74 @@ var PostgresQuotaLimiter = class {
           value TEXT
         );
       `);
-			const recorded = (await client.query(`SELECT value FROM ${this.table("quota_meta")} WHERE key = 'rules_fingerprint'`)).rows[0]?.value;
-			if (recorded === void 0 || this.acceptRulesUpdate) await client.query(`INSERT INTO ${this.table("quota_meta")} (key, value) VALUES ('rules_fingerprint', $1)
-           ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [fingerprint]);
-			else if (recorded !== fingerprint) throw new ConfigError(`PostgresQuotaLimiter rules mismatch over schema "${this.schema}": the schema records rules fingerprint ${recorded}, this instance computes ${fingerprint}. Every coordinating process must configure the identical rule set (buckets key on rule content, so a drifted host would silently split the budget). To rotate the rules, boot the new deployment with acceptRulesUpdate: true, then remove the flag.`, { data: {
+			const meta = new Map((await client.query(`SELECT key, value FROM ${this.table("quota_meta")}
+                 WHERE key IN ('rules_fingerprint', 'rules_generation')`)).rows.map((row) => [row.key, row.value]));
+			const recorded = meta.get("rules_fingerprint");
+			const recordedGeneration = meta.get("rules_generation");
+			const writeIdentity = async (generation) => {
+				await client.query(`INSERT INTO ${this.table("quota_meta")} (key, value)
+             VALUES ('rules_fingerprint', $1), ('rules_generation', $2)
+           ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [this.fingerprint, String(generation)]);
+			};
+			if (recorded === void 0) {
+				this.generation = 1;
+				await writeIdentity(this.generation);
+			} else if (recorded === this.fingerprint) {
+				this.generation = recordedGeneration === void 0 ? 1 : Number(recordedGeneration);
+				if (recordedGeneration === void 0) await writeIdentity(this.generation);
+			} else if (this.acceptRulesUpdate) {
+				await client.query("SELECT pg_advisory_xact_lock(hashtextextended($1, $2))", [`${this.schema}:rulvar-quota`, LOCK_SEED]);
+				const at = this.now();
+				const windowStart = at - at % QUOTA_WINDOW_MS;
+				const oldBuckets = (await client.query(`SELECT rule_key, requests::int8 AS requests, tokens::int8 AS tokens
+               FROM ${this.table("quota_buckets")} WHERE window_start = $1`, [windowStart])).rows;
+				const byTriple = /* @__PURE__ */ new Map();
+				for (const row of oldBuckets) {
+					const triple = dimensionTriple(row.rule_key);
+					const prior = byTriple.get(triple) ?? {
+						requests: 0,
+						tokens: 0
+					};
+					byTriple.set(triple, {
+						requests: Math.max(prior.requests, Number(row.requests)),
+						tokens: Math.max(prior.tokens, Number(row.tokens))
+					});
+				}
+				for (const { rule, key } of this.ordered) {
+					const carried = byTriple.get(JSON.stringify({
+						provider: rule.provider ?? null,
+						model: rule.model ?? null,
+						tenant: rule.tenant ?? null
+					}));
+					if (carried === void 0 || carried.requests === 0 && carried.tokens === 0) continue;
+					await client.query(`INSERT INTO ${this.table("quota_buckets")} AS b
+               (rule_key, window_start, requests, tokens) VALUES ($1, $2, $3, $4)
+             ON CONFLICT (rule_key, window_start) DO UPDATE SET
+               requests = GREATEST(b.requests, excluded.requests),
+               tokens = GREATEST(b.tokens, excluded.tokens)`, [
+						key,
+						windowStart,
+						carried.requests,
+						carried.tokens
+					]);
+				}
+				this.generation = (recordedGeneration === void 0 ? 1 : Number(recordedGeneration)) + 1;
+				await writeIdentity(this.generation);
+			} else throw new ConfigError(`PostgresQuotaLimiter rules mismatch over schema "${this.schema}": the schema records rules fingerprint ${recorded}, this instance computes ${this.fingerprint}. Every coordinating process must configure the identical rule set (buckets key on rule content, so a drifted host would silently split the budget). To rotate the rules, boot the new deployment with acceptRulesUpdate: true, then remove the flag.`, { data: {
 				schema: this.schema,
 				recorded,
-				computed: fingerprint
+				computed: this.fingerprint
 			} });
 			await client.query("COMMIT");
 		} catch (thrown) {
-			await client.query("ROLLBACK").catch(() => void 0);
+			destroyed = this.bootClient === void 0;
+			if (!destroyed) await client.query("ROLLBACK").catch(() => void 0);
 			throw thrown;
 		} finally {
-			client.release();
+			if (this.bootClient !== void 0) {
+				this.bootClient = void 0;
+				if (!destroyed) client.release();
+			}
 		}
 	}
 	/**
@@ -667,7 +771,7 @@ var PostgresQuotaLimiter = class {
 		let client;
 		let expired = false;
 		let timer;
-		const refusal = () => new QuotaDeadlineError(this.admissionDeadlineMs, this.schema, client === void 0 ? "acquire" : "transaction");
+		const refusal = () => new QuotaDeadlineError(this.admissionDeadlineMs, this.schema, client !== void 0 ? "transaction" : this.bootClient !== void 0 ? "bootstrap" : "acquire");
 		const work = (async () => {
 			await this.booted();
 			if (expired) throw refusal();
@@ -698,6 +802,8 @@ var PostgresQuotaLimiter = class {
 				expired = true;
 				client?.release(reason);
 				client = void 0;
+				this.bootClient?.release(reason);
+				this.bootClient = void 0;
 				reject(reason);
 			}, this.admissionDeadlineMs);
 		});
@@ -707,17 +813,43 @@ var PostgresQuotaLimiter = class {
 			clearTimeout(timer);
 		}
 	}
+	/**
+	* The generation fence (RV608), run INSIDE every admission
+	* transaction after the lock is taken: the schema's recorded rule
+	* identity is re-read and compared to what this instance booted, so a
+	* host whose rules were rotated away admits NOTHING under retired
+	* bucket keys. The refusal is typed, and the boot memo is cleared so
+	* the host's next call re-boots into the honest boot-time refusal
+	* naming both fingerprints.
+	*/
+	async assertCurrentIdentity(client) {
+		const meta = new Map((await client.query(`SELECT key, value FROM ${this.table("quota_meta")}
+               WHERE key IN ('rules_fingerprint', 'rules_generation')`)).rows.map((row) => [row.key, row.value]));
+		const fingerprint = meta.get("rules_fingerprint");
+		const generationRaw = meta.get("rules_generation");
+		const generation = generationRaw === void 0 ? void 0 : Number(generationRaw);
+		if (fingerprint !== this.fingerprint || generation !== this.generation) {
+			this.boot = void 0;
+			throw new QuotaGenerationError(this.schema, {
+				fingerprint: this.fingerprint,
+				generation: this.generation
+			}, {
+				fingerprint,
+				generation
+			});
+		}
+	}
 	reserve(request) {
 		const at = this.now();
 		const windowStart = at - at % QUOTA_WINDOW_MS;
 		const estimateTokens = quotaEstimateTokens(request);
 		return this.withQuotaLock(async (client) => {
+			await this.assertCurrentIdentity(client);
 			await this.prune(client, windowStart);
 			const matched = [];
 			let denial;
-			for (const rule of this.rules) {
+			for (const { rule, key } of this.ordered) {
 				if (!quotaRuleMatches(rule, request)) continue;
-				const key = ruleKey(rule);
 				matched.push(key);
 				const row = (await client.query(`SELECT requests::int8 AS requests, tokens::int8 AS tokens
                FROM ${this.table("quota_buckets")} WHERE rule_key = $1 AND window_start = $2`, [key, windowStart])).rows[0];
@@ -764,6 +896,7 @@ var PostgresQuotaLimiter = class {
 		const at = this.now();
 		const windowStart = at - at % QUOTA_WINDOW_MS;
 		return this.withQuotaLock(async (client) => {
+			await this.assertCurrentIdentity(client);
 			const row = (await client.query(`SELECT window_start::int8 AS window_start, estimate_tokens::int8 AS estimate_tokens,
                   rule_keys
              FROM ${this.table("quota_reservations")} WHERE id = $1`, [reservationId])).rows[0];
@@ -788,7 +921,7 @@ var PostgresQuotaLimiter = class {
 		const out = [];
 		for (const rule of this.rules) {
 			const row = (await this.pool.query(`SELECT requests::int8 AS requests, tokens::int8 AS tokens
-             FROM ${this.table("quota_buckets")} WHERE rule_key = $1 AND window_start = $2`, [ruleKey(rule), windowStart])).rows[0];
+             FROM ${this.table("quota_buckets")} WHERE rule_key = $1 AND window_start = $2`, [quotaRuleKey(rule), windowStart])).rows[0];
 			out.push({
 				rule,
 				windowStart,
@@ -809,4 +942,4 @@ var PostgresQuotaLimiter = class {
 	}
 };
 //#endregion
-export { DEFAULT_LEASE_TTL_MS, DEFAULT_POOL_MAX, PostgresQuotaLimiter, PostgresStore, QUOTA_ADMISSION_DEADLINE_MS, QUOTA_LOCK_TIMEOUT_MS, QuotaDeadlineError, quotaRulesFingerprint };
+export { DEFAULT_LEASE_TTL_MS, DEFAULT_POOL_MAX, PostgresQuotaLimiter, PostgresStore, QUOTA_ADMISSION_DEADLINE_MS, QUOTA_LOCK_TIMEOUT_MS, QuotaDeadlineError, QuotaGenerationError, quotaRulesFingerprint };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/store-postgres",
-  "version": "1.104.0",
+  "version": "1.106.0",
   "description": "Rulvar PostgreSQL store implementing JournalStore and LeasableStore with a fencing epoch, for multi-process and multi-host deployments.",
   "type": "module",
   "license": "Apache-2.0",
@@ -23,14 +23,14 @@
   },
   "dependencies": {
     "pg": "^8.22.0",
-    "@rulvar/core": "1.104.0"
+    "@rulvar/core": "1.106.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",
     "@types/pg": "^8.20.0",
     "tsdown": "^0.22.14",
     "typescript": "~6.0.3",
-    "@rulvar/store-conformance": "1.104.0"
+    "@rulvar/store-conformance": "1.106.0"
   },
   "repository": {
     "type": "git",