@emilia-protocol/gate 0.10.0 → 0.13.0

package/src/witness-postgres.ts

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Tenant-scoped Postgres sequence store for EP-GATE-NETWORK-WITNESS-v1.
+ *
+ * The migration owns synchronization and authorization. Runtime callers get
+ * EXECUTE on one SECURITY DEFINER function, not INSERT/UPDATE privileges on the
+ * checkpoint table. Database ambiguity is allowed to throw so the witness
+ * ingestion kernel can fail closed as `sequence_store_unavailable`.
+ */
+
+export const PG_WITNESS_SEQUENCE_VERSION = 'EP-GATE-PG-WITNESS-SEQUENCE-v1';
+export const WITNESS_CHECKPOINT_FUNCTION = 'emilia_gate_evidence.advance_network_witness_checkpoint';
+
+const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+const CLOSED_REASONS = new Set(['statement_replay', 'sequence_rollback', 'sequence_equivocation']);
+
+export const WITNESS_SEQUENCE_SQL = Object.freeze({
+  advance: `SELECT accepted, reason
+FROM ${WITNESS_CHECKPOINT_FUNCTION}($1, $2, $3::bytea, $4::bigint, $5)`,
+});
+
+function scopedId(value, label) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > 256
+      || /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`${label} must be a non-empty control-free string of at most 256 characters`);
+  }
+  return value;
+}
+
+function streamBytes(value) {
+  if (typeof value !== 'string' || value.length > 513) {
+    throw new Error('witness streamId is invalid');
+  }
+  const parts = value.split('\0');
+  if (parts.length !== 2 || parts.some((part) => part.length === 0 || part.length > 256
+      || /[\u0000-\u001f\u007f]/.test(part))) {
+    throw new Error('witness streamId must contain one witness-id/capture-point separator');
+  }
+  return Buffer.from(value, 'utf8');
+}
+
+function definitiveRow(result) {
+  if (!result || result.rowCount !== 1 || !Array.isArray(result.rows)
+      || result.rows.length !== 1 || typeof result.rows[0]?.accepted !== 'boolean') {
+    throw new Error('witness checkpoint outcome is unproven');
+  }
+  const { accepted, reason } = result.rows[0];
+  if (accepted) {
+    if (reason !== null && reason !== undefined && reason !== '') {
+      throw new Error('accepted witness checkpoint carried a refusal reason');
+    }
+    return { accepted: true, reason: null };
+  }
+  if (!CLOSED_REASONS.has(reason)) {
+    throw new Error('witness checkpoint returned an unknown refusal reason');
+  }
+  return { accepted: false, reason };
+}
+
+/**
+ * Create the durable store expected by acceptNetworkWitnessStatement().
+ * `query` is a node-postgres style function such as pool.query.bind(pool).
+ * @param {{ query?: Function, tenantId?: string|number, gateId?: string|number }} [o]
+ */
+export function createPostgresWitnessSequenceStore({
+  query,
+  tenantId,
+  gateId,
+}: {
+  query?: (sql: string, params?: any[]) => Promise<any>;
+  tenantId?: string | number;
+  gateId?: string | number;
+} = {}) {
+  if (typeof query !== 'function') {
+    throw new Error('createPostgresWitnessSequenceStore: query must be an async pg-style function');
+  }
+  const tenant = scopedId(tenantId, 'tenantId');
+  const gate = scopedId(gateId, 'gateId');
+  return Object.freeze({
+    durable: true,
+    scope: Object.freeze({ tenantId: tenant, gateId: gate }),
+    async advance(streamId, sequence, statementDigest) {
+      if (!Number.isSafeInteger(sequence) || sequence < 0) {
+        throw new Error('witness sequence must be a non-negative safe integer');
+      }
+      if (typeof statementDigest !== 'string' || !DIGEST_RE.test(statementDigest)) {
+        throw new Error('witness statement digest is invalid');
+      }
+      const result = await query(WITNESS_SEQUENCE_SQL.advance, [
+        tenant,
+        gate,
+        streamBytes(streamId),
+        sequence,
+        statementDigest,
+      ]);
+      return definitiveRow(result);
+    },
+  });
+}
+
+export default {
+  PG_WITNESS_SEQUENCE_VERSION,
+  WITNESS_CHECKPOINT_FUNCTION,
+  WITNESS_SEQUENCE_SQL,
+  createPostgresWitnessSequenceStore,
+};

package/src/zk-range-proof.ts

@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * EP-ZK-RANGE-RECEIPT-v1.
+ *
+ * This is a genuine Bulletproof range proof adapter, not a commitment renamed
+ * as zero knowledge. It proves a hidden integer v satisfies 0 <= v <= max by
+ * proving ranges for v and max-v, while the second Pedersen commitment is
+ * publicly linked to the first. The base EP receipt and its signature remain a
+ * separate verification step; this envelope binds only its public digest.
+ *
+ * The cryptographic engine is intentionally injected/lazy-loaded. The main
+ * Gate package does not silently add a 60 MB mobile/WASM dependency. The
+ * compatible backend is @aptos-labs/confidential-asset-bindings, which exposes
+ * Bulletproofs over Ristretto255. A deployment must pin and audit that optional
+ * backend before enabling this path.
+ */
+
+import { createHash, randomBytes } from 'node:crypto';
+import { ristretto255, ristretto255_hasher } from '@noble/curves/ed25519.js';
+import { canonicalize } from './execution-binding.js';
+
+export const ZK_RANGE_RECEIPT_VERSION = 'EP-ZK-RANGE-RECEIPT-v1';
+export const ZK_RANGE_SCHEME = 'Bulletproofs-Ristretto255-range-v1';
+export const ZK_RANGE_BACKEND_PACKAGE = '@aptos-labs/confidential-asset-bindings@1.1.2';
+const ZK_RANGE_BACKEND_MODULE = '@aptos-labs/confidential-asset-bindings';
+
+const ORDER = ristretto255.Point.Fn.ORDER;
+const TEXT_ENCODER = new TextEncoder();
+
+/**
+ * @param {Uint8Array|string} value
+ * @param {string} label
+ * @param {number|null} [length]
+ * @returns {Uint8Array}
+ */
+function bytes(value, label, length: number | null = null) {
+  const out = value instanceof Uint8Array ? new Uint8Array(value) : Buffer.from(value, 'base64url');
+  if (length !== null && out.length !== length) throw new TypeError(`${label} must be ${length} bytes`);
+  return out;
+}
+
+function b64(value) {
+  return Buffer.from(value).toString('base64url');
+}
+
+function sha256Hex(value) {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function digest(value, label) {
+  if (typeof value !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(value)) throw new TypeError(`${label} must be a sha256: digest`);
+  return value;
+}
+
+function safeU64(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${label} must be a non-negative safe integer`);
+  return value;
+}
+
+function rangeBits(max) {
+  if (max <= 0xff) return 8;
+  if (max <= 0xffff) return 16;
+  if (max <= 0xffffffff) return 32;
+  return 64;
+}
+
+function bytesToBigIntLE(value) {
+  let result = 0n;
+  for (let i = value.length - 1; i >= 0; i -= 1) result = (result << 8n) | BigInt(value[i]);
+  return result;
+}
+
+function bigIntToBytesLE(value, length) {
+  const out = new Uint8Array(length);
+  let current = value;
+  for (let i = 0; i < length; i += 1) {
+    out[i] = Number(current & 0xffn);
+    current >>= 8n;
+  }
+  return out;
+}
+
+function negateScalar(value) {
+  const scalar = bytesToBigIntLE(value) % ORDER;
+  return bigIntToBytesLE(scalar === 0n ? 0n : ORDER - scalar, 32);
+}
+
+/** Derive independent, deterministic Pedersen bases for this proof domain. */
+export function deriveZkRangeBases(domain = ZK_RANGE_RECEIPT_VERSION) {
+  if (typeof domain !== 'string' || domain.length === 0) throw new TypeError('ZK range domain is required');
+  const valBase = ristretto255.Point.BASE.toBytes();
+  const randBase = ristretto255_hasher.hashToCurve(TEXT_ENCODER.encode(`${domain}:randomness-base`)).toBytes();
+  if (Buffer.from(valBase).equals(Buffer.from(randBase))) throw new Error('ZK range bases unexpectedly collide');
+  return { valBase, randBase };
+}
+
+/** Lazy-load the audited/pinned optional Bulletproof WASM binding. */
+export async function loadBulletproofBackend() {
+  try {
+    // Keep the backend genuinely optional at bundle time. Server deployments
+    // that enable ZK install the pinned module explicitly; default Gate builds
+    // must not fail or pull the WASM/mobile distribution into every route.
+    return await import(/* webpackIgnore: true */ ZK_RANGE_BACKEND_MODULE);
+  } catch {
+    throw new Error(`ZK range backend unavailable; install ${ZK_RANGE_BACKEND_PACKAGE} explicitly before enabling this path`);
+  }
+}
+
+function requireBackend(backend) {
+  if (!backend || typeof backend.batchRangeProof !== 'function' || typeof backend.batchVerifyProof !== 'function') {
+    throw new TypeError('ZK range backend must implement batchRangeProof() and batchVerifyProof()');
+  }
+  return backend;
+}
+
+function linkedSecondCommitment(max, first, valBase) {
+  const valueBase = ristretto255.Point.fromBytes(valBase);
+  const firstPoint = ristretto255.Point.fromBytes(first);
+  return valueBase.multiply(BigInt(max)).subtract(firstPoint).toBytes();
+}
+
+function equalBytes(left, right) {
+  return left.length === right.length && Buffer.from(left).equals(Buffer.from(right));
+}
+
+function publicStatement({ policyHash, actionPredicate, max, baseReceiptDigest, issuerPublicKey, numBits }) {
+  return {
+    policy_hash: digest(policyHash, 'policy_hash'),
+    action_predicate: actionPredicate,
+    max,
+    base_receipt_digest: digest(baseReceiptDigest, 'base_receipt_digest'),
+    issuer_public_key: issuerPublicKey,
+    num_bits: numBits,
+  };
+}
+
+/**
+ * Mint a hidden-amount Bulletproof range receipt.
+ * @param {{ value?: any, max?: any, blindingFactor?: any, policyHash?: any, actionPredicate?: any, baseReceiptDigest?: any, issuerPublicKey?: any, nonce?: string, domain?: string, backend?: any }} [options]
+ */
+export async function mintZkRangeReceipt({
+  value,
+  max,
+  blindingFactor = randomBytes(32),
+  policyHash,
+  actionPredicate,
+  baseReceiptDigest,
+  issuerPublicKey,
+  nonce = randomBytes(16).toString('base64url'),
+  domain = ZK_RANGE_RECEIPT_VERSION,
+  backend = null,
+}: {
+  value?: number;
+  max?: number;
+  blindingFactor?: Uint8Array | string;
+  policyHash?: string;
+  actionPredicate?: string;
+  baseReceiptDigest?: string;
+  issuerPublicKey?: string;
+  nonce?: string;
+  domain?: string;
+  backend?: { batchRangeProof?: Function; batchVerifyProof?: Function } | null;
+} = {}) {
+  const hiddenValue = safeU64(value, 'value');
+  const upperBound = safeU64(max, 'max');
+  if (hiddenValue > upperBound) throw new TypeError('value exceeds the public range bound');
+  if (typeof actionPredicate !== 'string' || actionPredicate.length === 0) throw new TypeError('actionPredicate is required');
+  if (typeof issuerPublicKey !== 'string' || issuerPublicKey.length === 0) throw new TypeError('issuerPublicKey is required');
+  const normalizedBlinding = bytes(blindingFactor, 'blindingFactor', 32);
+  const numBits = rangeBits(upperBound);
+  const bases = deriveZkRangeBases(domain);
+  const engine = requireBackend(backend || await loadBulletproofBackend());
+  const result = await engine.batchRangeProof({
+    v: [BigInt(hiddenValue), BigInt(upperBound - hiddenValue)],
+    rs: [normalizedBlinding, negateScalar(normalizedBlinding)],
+    valBase: bases.valBase,
+    randBase: bases.randBase,
+    numBits,
+  });
+  if (!result || !(result.proof instanceof Uint8Array) || !Array.isArray(result.comms) || result.comms.length !== 2) throw new Error('ZK range backend returned a malformed proof');
+  const first = bytes(result.comms[0], 'first commitment', 32);
+  const second = bytes(result.comms[1], 'second commitment', 32);
+  if (!equalBytes(second, linkedSecondCommitment(upperBound, first, bases.valBase))) throw new Error('ZK range backend returned unlinked commitments');
+  const statement = publicStatement({ policyHash, actionPredicate, max: upperBound, baseReceiptDigest, issuerPublicKey, numBits });
+  const commitments = envelopeCommitments([first, second]);
+  const envelope = {
+    '@version': ZK_RANGE_RECEIPT_VERSION,
+    scheme: ZK_RANGE_SCHEME,
+    domain,
+    nonce,
+    statement,
+    commitments,
+    proof: b64(result.proof),
+    binding: `sha256:${sha256Hex(canonicalize({ statement, commitments, nonce, domain }))}`,
+  };
+  return envelope;
+}
+
+function envelopeCommitments(commitments) {
+  return commitments.map((value) => b64(value));
+}
+
+/** Verify the range proof and its public commitment relation. */
+export async function verifyZkRangeReceipt(receipt, { backend = null } = {}) {
+  try {
+    if (!receipt || receipt['@version'] !== ZK_RANGE_RECEIPT_VERSION || receipt.scheme !== ZK_RANGE_SCHEME) return { ok: false, reason: 'malformed_zk_range_receipt' };
+    const statement = receipt.statement;
+    const max = safeU64(statement?.max, 'statement.max');
+    const numBits = rangeBits(max);
+    if (statement.num_bits !== numBits) return { ok: false, reason: 'range_bits_mismatch' };
+    publicStatement({
+      policyHash: statement.policy_hash,
+      actionPredicate: statement.action_predicate,
+      baseReceiptDigest: statement.base_receipt_digest,
+      issuerPublicKey: statement.issuer_public_key,
+      max,
+      numBits,
+    });
+    const bases = deriveZkRangeBases(receipt.domain);
+    const commitments = receipt.commitments?.map((value) => bytes(Buffer.from(value, 'base64url'), 'commitment', 32));
+    if (!Array.isArray(commitments) || commitments.length !== 2) return { ok: false, reason: 'commitments_malformed' };
+    if (!equalBytes(commitments[1], linkedSecondCommitment(max, commitments[0], bases.valBase))) return { ok: false, reason: 'commitment_relation_invalid' };
+    const expectedBinding = `sha256:${sha256Hex(canonicalize({ statement, commitments: envelopeCommitments(commitments), nonce: receipt.nonce, domain: receipt.domain }))}`;
+    if (expectedBinding !== receipt.binding) return { ok: false, reason: 'zk_binding_invalid' };
+    const engine = requireBackend(backend || await loadBulletproofBackend());
+    const valid = await engine.batchVerifyProof({
+      proof: bytes(Buffer.from(receipt.proof || '', 'base64url'), 'proof'),
+      comms: commitments,
+      valBase: bases.valBase,
+      randBase: bases.randBase,
+      numBits,
+    });
+    return valid === true
+      ? { ok: true, scheme: ZK_RANGE_SCHEME, statement }
+      : { ok: false, reason: 'zk_range_proof_invalid' };
+  } catch (error) {
+    return { ok: false, reason: 'zk_range_receipt_invalid', detail: (error instanceof Error && error.message) || 'invalid proof' };
+  }
+}
+
+export default {
+  ZK_RANGE_RECEIPT_VERSION,
+  ZK_RANGE_SCHEME,
+  ZK_RANGE_BACKEND_PACKAGE,
+  deriveZkRangeBases,
+  loadBulletproofBackend,
+  mintZkRangeReceipt,
+  verifyZkRangeReceipt,
+};

package/store-postgres.js

@@ -1,162 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * EMILIA Gate — reference DURABLE consumption backend: Postgres
- * (EP-GATE-PG-CONSUMPTION-v2).
- *
- * Replay defense that survives restarts. This module implements the backend
- * contract consumed by `createDurableConsumptionStore` in ./store.js:
- *
- *   backend = {
- *     async addIfAbsent(key, value, { ttlSeconds }?) : boolean  // true iff inserted
- *     async compareAndSet(key, expected, replacement, { ttlSeconds }?) : boolean
- *     async deleteIfValue(key, expected)             : boolean
- *     async has(key)                                 : boolean
- *   }
- *
- * plus a `cleanupExpired(now)` garbage-collection statement.
- *
- * Each transition is one SQL statement. `addIfAbsent` decides first use;
- * `compareAndSet` and `deleteIfValue` bind commit/release to the opaque owner of
- * the current reservation. There is no read-then-write interval in which a
- * delayed worker can overwrite or remove a newer worker's reservation.
- *
- * FAIL-CLOSED CONTRACT: if the injected `query` THROWS (connection down,
- * timeout, constraint other than the PK, ...) the error PROPAGATES to the
- * caller — nothing here catches it. The gate must refuse an action when
- * one-time-use cannot be proven; a backend error is NEVER treated as
- * not-consumed (which would admit replays during an outage) and never treated
- * as consumed-silently (which would mask the outage as a replay verdict).
- * Likewise, an EXPIRED row that cleanup has not yet removed still refuses:
- * TTL expiry is garbage collection, never a grant — the gate already rejects
- * stale receipts on freshness, so nothing is lost by refusing conservatively.
- *
- * Deterministic by construction: the pg-style `query(text, params)` function
- * and the clock (`now`) are both injected, so tests run against an in-memory
- * fake with real ON CONFLICT semantics — no network, no database.
- */
-
-export const PG_CONSUMPTION_VERSION = 'EP-GATE-PG-CONSUMPTION-v2';
-
-/** Single consumption table. Timestamps are epoch milliseconds (BIGINT) so the
- * injected JS clock maps 1:1 onto column values with no timezone ambiguity. */
-export const CONSUMPTION_TABLE = 'ep_gate_consumption';
-
-export const CONSUMPTION_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${CONSUMPTION_TABLE} (
-  consumption_key TEXT PRIMARY KEY,
-  state           TEXT NOT NULL,
-  consumed_at     BIGINT NOT NULL,
-  expires_at      BIGINT
-);
-CREATE INDEX IF NOT EXISTS ${CONSUMPTION_TABLE}_expires_idx
-  ON ${CONSUMPTION_TABLE} (expires_at) WHERE expires_at IS NOT NULL;`;
-
-/** The exact statements the backend issues — exported for transparency and so
- * a fake client can implement them without parsing SQL. */
-export const CONSUMPTION_SQL = {
-  health: `SELECT
-  to_regclass('public.${CONSUMPTION_TABLE}') IS NOT NULL AS table_ready,
-  CASE WHEN to_regclass('public.${CONSUMPTION_TABLE}') IS NULL THEN FALSE
-    ELSE has_table_privilege(current_user, to_regclass('public.${CONSUMPTION_TABLE}'), 'SELECT,INSERT,UPDATE,DELETE') END AS can_use`,
-  /** $1 key, $2 state, $3 consumed_at ms, $4 expires_at ms|null. rowCount 1 = consumed, 0 = replay. */
-  addIfAbsent: `INSERT INTO ${CONSUMPTION_TABLE} (consumption_key, state, consumed_at, expires_at) `
-    + 'VALUES ($1, $2, $3, $4) ON CONFLICT (consumption_key) DO NOTHING',
-  /** $1 key, $2 expected state, $3 replacement, $4 consumed_at ms, $5 expires_at ms|null. */
-  compareAndSet: `UPDATE ${CONSUMPTION_TABLE} SET state = $3, consumed_at = $4, expires_at = $5 `
-    + 'WHERE consumption_key = $1 AND state = $2',
-  /** $1 key, $2 expected state. */
-  deleteIfValue: `DELETE FROM ${CONSUMPTION_TABLE} WHERE consumption_key = $1 AND state = $2`,
-  /** $1 key. Any row — even an expired one — counts as consumed until cleaned. */
-  has: `SELECT 1 FROM ${CONSUMPTION_TABLE} WHERE consumption_key = $1`,
-  /** $1 now ms. Removes ONLY rows whose TTL has elapsed; NULL expires_at never expires. */
-  cleanupExpired: `DELETE FROM ${CONSUMPTION_TABLE} WHERE state LIKE 'committed:%' `
-    + 'AND expires_at IS NOT NULL AND expires_at <= $1',
-};
-
-/**
- * Create the Postgres consumption backend.
- * @param {object} o
- * @param {(text: string, params: any[]) => Promise<{ rowCount: number, rows?: any[] }>} o.query
- *   pg-style query function (e.g. `pool.query.bind(pool)`). Injected so tests
- *   need no database. MUST throw on failure — errors propagate (fail closed).
- * @param {number|function} [o.now=Date.now] injected clock (ms or () => ms).
- * @returns backend conforming to createDurableConsumptionStore, plus cleanupExpired(now).
- */
-export function createPostgresBackend({ query, now = Date.now } = {}) {
-  if (typeof query !== 'function') {
-    throw new Error('createPostgresBackend: query must be an async (text, params) => { rowCount } function '
-      + '(e.g. pg pool.query). It must THROW on failure — a backend error must never look like a verdict.');
-  }
-  let lastObservedNow = Number.NEGATIVE_INFINITY;
-  const checkedNow = (candidate) => {
-    if (!Number.isSafeInteger(candidate) || candidate < 0) {
-      throw new Error('consumption clock must return a non-negative safe-integer epoch millisecond');
-    }
-    if (candidate < lastObservedNow) {
-      throw new Error(`consumption clock regression refused: ${candidate} < ${lastObservedNow}`);
-    }
-    lastObservedNow = candidate;
-    return candidate;
-  };
-  const nowMs = () => checkedNow(typeof now === 'function' ? now() : now);
-  const expiryFor = (opt) => {
-    const ttl = Number(opt?.ttlSeconds);
-    return Number.isFinite(ttl) && ttl > 0 ? nowMs() + ttl * 1000 : null;
-  };
-
-  return {
-    durable: true,
-    async health() {
-      const res = await query(CONSUMPTION_SQL.health, []);
-      if (!res || res.rowCount !== 1 || !Array.isArray(res.rows) || res.rows.length !== 1) {
-        throw new Error('consumption health: malformed Postgres result');
-      }
-      return {
-        ok: res.rows[0].table_ready === true && res.rows[0].can_use === true,
-        version: PG_CONSUMPTION_VERSION,
-      };
-    },
-    /** True iff THIS call inserted the row — the atomic consumed-vs-replay decision. */
-    async addIfAbsent(key, value, opt) {
-      const res = await query(CONSUMPTION_SQL.addIfAbsent, [key, value, nowMs(), expiryFor(opt)]);
-      // Fail closed on a malformed driver result: without a numeric rowCount we
-      // cannot PROVE first-use, so refuse loudly rather than guess.
-      if (!res || typeof res.rowCount !== 'number') {
-        throw new Error('addIfAbsent: query result has no numeric rowCount — cannot prove one-time use');
-      }
-      return res.rowCount === 1;
-    },
-
-    /** Ownership-fenced reserved -> committed transition. */
-    async compareAndSet(key, expected, replacement, opt) {
-      const res = await query(CONSUMPTION_SQL.compareAndSet, [key, expected, replacement, nowMs(), expiryFor(opt)]);
-      if (!res || typeof res.rowCount !== 'number') {
-        throw new Error('compareAndSet: query result has no numeric rowCount — cannot prove reservation ownership');
-      }
-      return res.rowCount === 1;
-    },
-
-    /** Remove only the reservation owned by the caller. */
-    async deleteIfValue(key, expected) {
-      const res = await query(CONSUMPTION_SQL.deleteIfValue, [key, expected]);
-      if (!res || typeof res.rowCount !== 'number') {
-        throw new Error('deleteIfValue: query result has no numeric rowCount — cannot prove reservation ownership');
-      }
-      return res.rowCount === 1;
-    },
-
-    /** Present = consumed. Expired-but-uncleaned rows still count (conservative). */
-    async has(key) {
-      const res = await query(CONSUMPTION_SQL.has, [key]);
-      return (res?.rows?.length ?? res?.rowCount ?? 0) > 0;
-    },
-
-    /** Garbage-collect rows whose TTL elapsed. Returns the number removed. */
-    async cleanupExpired(at) {
-      const cleanupAt = at === undefined ? nowMs() : checkedNow(at);
-      const res = await query(CONSUMPTION_SQL.cleanupExpired, [cleanupAt]);
-      return res?.rowCount ?? 0;
-    },
-  };
-}
-
-export default { createPostgresBackend, CONSUMPTION_TABLE_DDL, CONSUMPTION_TABLE, CONSUMPTION_SQL, PG_CONSUMPTION_VERSION };
+// Compatibility entry point for the TypeScript store-postgres module.
+export * from './dist/store-postgres.js';
+export { default } from './dist/store-postgres.js';