@bymax-one/nest-ai-tokens 1.0.0

package/dist/prisma/index.cjs

@@ -0,0 +1,1197 @@
+'use strict';
+
+var crypto = require('crypto');
+var client = require('@prisma/client');
+var nestAiTokens = require('@bymax-one/nest-ai-tokens');
+
+// src/prisma/index.ts
+
+// src/server/services/ledger-idempotency-conflict.ts
+var LedgerIdempotencyConflict = class extends Error {
+  /**
+   * @param tenantId The tenant whose key collided.
+   * @param idempotencyKey The key reused with a different payload.
+   */
+  constructor(tenantId, idempotencyKey) {
+    super("Ledger idempotency-key payload mismatch");
+    this.tenantId = tenantId;
+    this.idempotencyKey = idempotencyKey;
+    this.name = "LedgerIdempotencyConflict";
+  }
+  tenantId;
+  idempotencyKey;
+  /** Structural brand matched by {@link isLedgerIdempotencyConflict} across bundles. */
+  isAiTokensLedgerConflict = true;
+};
+function isLedgerIdempotencyConflict(error) {
+  if (typeof error !== "object" || error === null) return false;
+  return error.isAiTokensLedgerConflict === true;
+}
+
+// src/shared/constants/ledger-fields.constants.ts
+var AMOUNT_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cacheReadTokens",
+  "cacheWrite5mTokens",
+  "cacheWrite1hTokens",
+  "reasoningTokens",
+  "audioInTokens",
+  "audioOutTokens",
+  "imageInTokens",
+  "imageOutTokens",
+  "totalTokens",
+  "rawCostNanoUsd",
+  "surchargeNanoUsd",
+  "billedCostNanoUsd"
+];
+var SETTLEMENT_FIELDS = [
+  ...AMOUNT_FIELDS,
+  "priceVersionId",
+  "priceMissing",
+  "markupMultiplier"
+];
+var RELEASE_FIELDS = ["correlationId", "requestId"];
+var REVERSAL_LINKAGE_FIELD = "reversedByRecordId";
+var SETTLEMENT_PATCH_KEYS = /* @__PURE__ */ new Set([...SETTLEMENT_FIELDS, REVERSAL_LINKAGE_FIELD]);
+var RELEASE_FIELD_SET = new Set(RELEASE_FIELDS);
+function isLegalTransitionPatchKey(from, to, key) {
+  if (from === "pending" && to === "posted") return SETTLEMENT_PATCH_KEYS.has(key);
+  if (from === "pending" && to === "released") return RELEASE_FIELD_SET.has(key);
+  if (from === "posted" && to === "reversed") return key === REVERSAL_LINKAGE_FIELD;
+  return false;
+}
+
+// src/shared/utils/sha256.ts
+var K_WORDS = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+var INITIAL_HASH = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var kView = new DataView(new ArrayBuffer(64 * 4));
+K_WORDS.forEach((value, index) => {
+  kView.setUint32(index * 4, value);
+});
+function rotr(x, n) {
+  return (x >>> n | x << 32 - n) >>> 0;
+}
+function expandSchedule(w) {
+  for (let i = 16; i < 64; i++) {
+    const w15 = w.getUint32((i - 15) * 4);
+    const w2 = w.getUint32((i - 2) * 4);
+    const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+    const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+    w.setUint32(i * 4, w.getUint32((i - 16) * 4) + s0 + w.getUint32((i - 7) * 4) + s1 >>> 0);
+  }
+}
+function compressBlock(h, w) {
+  let a = h.getUint32(0);
+  let b = h.getUint32(4);
+  let c = h.getUint32(8);
+  let d = h.getUint32(12);
+  let e = h.getUint32(16);
+  let f = h.getUint32(20);
+  let g = h.getUint32(24);
+  let hh = h.getUint32(28);
+  for (let i = 0; i < 64; i++) {
+    const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f ^ ~e & g;
+    const t1 = hh + s1 + ch + kView.getUint32(i * 4) + w.getUint32(i * 4) >>> 0;
+    const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c ^ b & c;
+    const t2 = s0 + maj >>> 0;
+    hh = g;
+    g = f;
+    f = e;
+    e = d + t1 >>> 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 >>> 0;
+  }
+  const next = [a, b, c, d, e, f, g, hh];
+  next.forEach((value, index) => {
+    h.setUint32(index * 4, h.getUint32(index * 4) + value >>> 0);
+  });
+}
+function sha256Hex(input) {
+  const message = new TextEncoder().encode(input);
+  const bitLength = message.length * 8;
+  const paddedLength = Math.ceil((message.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(message);
+  bytes[message.length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const hView = new DataView(new ArrayBuffer(32));
+  INITIAL_HASH.forEach((value, index) => {
+    hView.setUint32(index * 4, value);
+  });
+  const wView = new DataView(new ArrayBuffer(64 * 4));
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i++) wView.setUint32(i * 4, view.getUint32(offset + i * 4));
+    expandSchedule(wView);
+    compressBlock(hView, wView);
+  }
+  let hex = "";
+  for (let i = 0; i < 8; i++) hex += hView.getUint32(i * 4).toString(16).padStart(8, "0");
+  return hex;
+}
+
+// src/shared/utils/idempotency.ts
+function canonicalize(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "bigint") return JSON.stringify(`${value.toString()}n`);
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (Array.isArray(value)) {
+    return `[${value.map((element) => canonicalize(element)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const members = Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`);
+    return `{${members.join(",")}}`;
+  }
+  return "null";
+}
+function deriveIdempotencyKey(payload) {
+  return sha256Hex(canonicalize(payload));
+}
+
+// src/server/utils/payload-hash.ts
+function computePayloadHash(record) {
+  return deriveIdempotencyKey({
+    scope: record.scope,
+    beneficiary: record.beneficiary,
+    requestedBy: record.requestedBy,
+    provider: record.provider,
+    model: record.model,
+    requestedModel: record.requestedModel,
+    operation: record.operation,
+    serviceTier: record.serviceTier,
+    feature: record.feature,
+    tags: record.tags,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWrite5mTokens: record.cacheWrite5mTokens,
+    cacheWrite1hTokens: record.cacheWrite1hTokens,
+    reasoningTokens: record.reasoningTokens,
+    audioInTokens: record.audioInTokens,
+    audioOutTokens: record.audioOutTokens,
+    imageInTokens: record.imageInTokens,
+    imageOutTokens: record.imageOutTokens,
+    totalTokens: record.totalTokens,
+    extraUnits: record.extraUnits,
+    priceVersionId: record.priceVersionId,
+    rawCostNanoUsd: record.rawCostNanoUsd,
+    surchargeNanoUsd: record.surchargeNanoUsd,
+    billedCostNanoUsd: record.billedCostNanoUsd,
+    markupMultiplier: record.markupMultiplier,
+    currency: record.currency,
+    priceMissing: record.priceMissing,
+    correlationId: record.correlationId,
+    requestId: record.requestId,
+    isSystemCost: record.isSystemCost,
+    systemCostCategory: record.systemCostCategory,
+    enforced: record.enforced,
+    reversesRecordId: record.reversesRecordId,
+    occurredAt: record.occurredAt
+  });
+}
+
+// src/server/utils/hash-chain.ts
+function chainHash(prevHash, record) {
+  return deriveIdempotencyKey({
+    // Stryker disable next-line StringLiteral -- empty-string fallback for null prevHash; tests only verify hash determinism and inequality, not the specific hash value for a genesis block
+    prevHash: prevHash ?? "",
+    id: record.id,
+    content: computePayloadHash(record)
+  });
+}
+var USAGE_COLUMNS = [
+  "id",
+  "tenantId",
+  "scopeType",
+  "scopeId",
+  "beneficiaryType",
+  "beneficiaryId",
+  "requestedBy",
+  "provider",
+  "model",
+  "requestedModel",
+  "operation",
+  "serviceTier",
+  "feature",
+  "tags",
+  "inputTokens",
+  "outputTokens",
+  "cacheReadTokens",
+  "cacheWrite5mTokens",
+  "cacheWrite1hTokens",
+  "reasoningTokens",
+  "audioInTokens",
+  "audioOutTokens",
+  "imageInTokens",
+  "imageOutTokens",
+  "totalTokens",
+  "extraUnits",
+  "priceVersionId",
+  "rawCostNanoUsd",
+  "surchargeNanoUsd",
+  "billedCostNanoUsd",
+  "markupMultiplier",
+  "currency",
+  "priceMissing",
+  "status",
+  "reversedByRecordId",
+  "reversesRecordId",
+  "idempotencyKey",
+  "payloadHash",
+  "correlationId",
+  "requestId",
+  "isSystemCost",
+  "systemCostCategory",
+  "enforced",
+  "prevHash",
+  "hash",
+  "occurredAt"
+];
+function scopeOf(type, id) {
+  if (type === null || id === null) return void 0;
+  return { type, id };
+}
+function mapUsageRow(row) {
+  const beneficiary = scopeOf(row.beneficiaryType, row.beneficiaryId);
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    scope: { type: row.scopeType, id: row.scopeId },
+    ...beneficiary !== void 0 ? { beneficiary } : {},
+    ...row.requestedBy !== null ? { requestedBy: row.requestedBy } : {},
+    provider: row.provider,
+    model: row.model,
+    ...row.requestedModel !== null ? { requestedModel: row.requestedModel } : {},
+    operation: row.operation,
+    serviceTier: row.serviceTier,
+    feature: row.feature,
+    tags: row.tags,
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    cacheReadTokens: row.cacheReadTokens,
+    cacheWrite5mTokens: row.cacheWrite5mTokens,
+    cacheWrite1hTokens: row.cacheWrite1hTokens,
+    reasoningTokens: row.reasoningTokens,
+    audioInTokens: row.audioInTokens,
+    audioOutTokens: row.audioOutTokens,
+    imageInTokens: row.imageInTokens,
+    imageOutTokens: row.imageOutTokens,
+    totalTokens: row.totalTokens,
+    ...row.extraUnits !== null ? { extraUnits: row.extraUnits } : {},
+    priceVersionId: row.priceVersionId,
+    rawCostNanoUsd: row.rawCostNanoUsd,
+    surchargeNanoUsd: row.surchargeNanoUsd,
+    billedCostNanoUsd: row.billedCostNanoUsd,
+    markupMultiplier: row.markupMultiplier.toNumber(),
+    currency: row.currency,
+    priceMissing: row.priceMissing,
+    status: row.status,
+    ...row.reversedByRecordId !== null ? { reversedByRecordId: row.reversedByRecordId } : {},
+    ...row.reversesRecordId !== null ? { reversesRecordId: row.reversesRecordId } : {},
+    idempotencyKey: row.idempotencyKey,
+    ...row.correlationId !== null ? { correlationId: row.correlationId } : {},
+    ...row.requestId !== null ? { requestId: row.requestId } : {},
+    isSystemCost: row.isSystemCost,
+    ...row.systemCostCategory !== null ? { systemCostCategory: row.systemCostCategory } : {},
+    enforced: row.enforced,
+    ...row.prevHash !== null ? { prevHash: row.prevHash } : {},
+    ...row.hash !== null ? { hash: row.hash } : {},
+    occurredAt: row.occurredAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function serializeUnitRates(units) {
+  const out = {};
+  for (const [unit, rate] of Object.entries(units)) out[unit] = rate.toString();
+  return JSON.stringify(out);
+}
+function parseUnitRates(units) {
+  const out = {};
+  for (const [unit, rate] of Object.entries(units)) out[unit] = BigInt(rate);
+  return out;
+}
+function mapPriceRow(row) {
+  return {
+    id: row.id,
+    provider: row.provider,
+    model: row.model,
+    operation: row.operation,
+    serviceTier: row.serviceTier,
+    inputNanoUsdPerMillion: row.inputNanoUsdPerMillion,
+    outputNanoUsdPerMillion: row.outputNanoUsdPerMillion,
+    cacheReadNanoUsdPerMillion: row.cacheReadNanoUsdPerMillion,
+    cacheWrite5mNanoUsdPerMillion: row.cacheWrite5mNanoUsdPerMillion,
+    cacheWrite1hNanoUsdPerMillion: row.cacheWrite1hNanoUsdPerMillion,
+    reasoningNanoUsdPerMillion: row.reasoningNanoUsdPerMillion,
+    audioInNanoUsdPerMillion: row.audioInNanoUsdPerMillion,
+    audioOutNanoUsdPerMillion: row.audioOutNanoUsdPerMillion,
+    imageInNanoUsdPerMillion: row.imageInNanoUsdPerMillion,
+    imageOutNanoUsdPerMillion: row.imageOutNanoUsdPerMillion,
+    ...row.tierThresholdTokens !== null ? { tierThresholdTokens: row.tierThresholdTokens } : {},
+    ...row.tierInputNanoUsdPerMillion !== null ? { tierInputNanoUsdPerMillion: row.tierInputNanoUsdPerMillion } : {},
+    ...row.tierOutputNanoUsdPerMillion !== null ? { tierOutputNanoUsdPerMillion: row.tierOutputNanoUsdPerMillion } : {},
+    ...row.unitRates !== null ? { unitRates: parseUnitRates(row.unitRates) } : {},
+    currency: "USD",
+    effectiveFrom: row.effectiveFrom,
+    effectiveTo: row.effectiveTo,
+    source: row.source
+  };
+}
+function firstOrThrow(rows) {
+  const row = rows[0];
+  if (row === void 0) throw new nestAiTokens.AiTokensException("AI_TOKENS_STORE_ERROR", void 0, {});
+  return row;
+}
+var PG_UNIQUE_VIOLATION = "23505";
+function isUniqueViolation(error) {
+  if (!(error instanceof client.Prisma.PrismaClientKnownRequestError)) return false;
+  if (error.code === "P2002") return true;
+  const meta = error.meta;
+  if (meta?.code === PG_UNIQUE_VIOLATION) return true;
+  const cause = meta?.driverAdapterError?.cause;
+  return cause?.originalCode === PG_UNIQUE_VIOLATION || cause?.kind === "UniqueConstraintViolation";
+}
+function storeError(error) {
+  const code = error instanceof client.Prisma.PrismaClientKnownRequestError ? error.code : void 0;
+  return new nestAiTokens.AiTokensException("AI_TOKENS_STORE_ERROR", void 0, code === void 0 ? {} : { code });
+}
+function usageValues(id, record, payloadHash, prevHash, hash) {
+  const extraUnits = record.extraUnits === void 0 ? client.Prisma.sql`NULL` : client.Prisma.sql`${JSON.stringify(record.extraUnits)}::jsonb`;
+  return [
+    client.Prisma.sql`${id}`,
+    client.Prisma.sql`${record.tenantId}`,
+    client.Prisma.sql`${record.scope.type}`,
+    client.Prisma.sql`${record.scope.id}`,
+    client.Prisma.sql`${record.beneficiary?.type ?? null}`,
+    client.Prisma.sql`${record.beneficiary?.id ?? null}`,
+    client.Prisma.sql`${record.requestedBy ?? null}`,
+    client.Prisma.sql`${record.provider}`,
+    client.Prisma.sql`${record.model}`,
+    client.Prisma.sql`${record.requestedModel ?? null}`,
+    client.Prisma.sql`${record.operation}`,
+    client.Prisma.sql`${record.serviceTier}`,
+    client.Prisma.sql`${record.feature}`,
+    client.Prisma.sql`${record.tags}::text[]`,
+    client.Prisma.sql`${record.inputTokens}`,
+    client.Prisma.sql`${record.outputTokens}`,
+    client.Prisma.sql`${record.cacheReadTokens}`,
+    client.Prisma.sql`${record.cacheWrite5mTokens}`,
+    client.Prisma.sql`${record.cacheWrite1hTokens}`,
+    client.Prisma.sql`${record.reasoningTokens}`,
+    client.Prisma.sql`${record.audioInTokens}`,
+    client.Prisma.sql`${record.audioOutTokens}`,
+    client.Prisma.sql`${record.imageInTokens}`,
+    client.Prisma.sql`${record.imageOutTokens}`,
+    client.Prisma.sql`${record.totalTokens}`,
+    extraUnits,
+    client.Prisma.sql`${record.priceVersionId}`,
+    client.Prisma.sql`${record.rawCostNanoUsd}`,
+    client.Prisma.sql`${record.surchargeNanoUsd}`,
+    client.Prisma.sql`${record.billedCostNanoUsd}`,
+    client.Prisma.sql`${record.markupMultiplier}`,
+    client.Prisma.sql`${record.currency}`,
+    client.Prisma.sql`${record.priceMissing}`,
+    client.Prisma.sql`${record.status}`,
+    client.Prisma.sql`${record.reversedByRecordId ?? null}`,
+    client.Prisma.sql`${record.reversesRecordId ?? null}`,
+    client.Prisma.sql`${record.idempotencyKey}`,
+    client.Prisma.sql`${payloadHash}`,
+    client.Prisma.sql`${record.correlationId ?? null}`,
+    client.Prisma.sql`${record.requestId ?? null}`,
+    client.Prisma.sql`${record.isSystemCost}`,
+    client.Prisma.sql`${record.systemCostCategory ?? null}`,
+    client.Prisma.sql`${record.enforced}`,
+    client.Prisma.sql`${prevHash}`,
+    client.Prisma.sql`${hash}`,
+    client.Prisma.sql`${record.occurredAt}`
+  ];
+}
+var USAGE_COLUMNS_SQL = client.Prisma.raw(USAGE_COLUMNS.map((column) => `"${column}"`).join(", "));
+var PRICE_COLUMNS = [
+  "id",
+  "provider",
+  "model",
+  "operation",
+  "serviceTier",
+  "inputNanoUsdPerMillion",
+  "outputNanoUsdPerMillion",
+  "cacheReadNanoUsdPerMillion",
+  "cacheWrite5mNanoUsdPerMillion",
+  "cacheWrite1hNanoUsdPerMillion",
+  "reasoningNanoUsdPerMillion",
+  "audioInNanoUsdPerMillion",
+  "audioOutNanoUsdPerMillion",
+  "imageInNanoUsdPerMillion",
+  "imageOutNanoUsdPerMillion",
+  "tierThresholdTokens",
+  "tierInputNanoUsdPerMillion",
+  "tierOutputNanoUsdPerMillion",
+  "unitRates",
+  "currency",
+  "effectiveFrom",
+  "effectiveTo",
+  "source"
+];
+var PRICE_COLUMNS_SQL = client.Prisma.raw(PRICE_COLUMNS.map((column) => `"${column}"`).join(", "));
+function priceValues(input, serviceTier, effectiveFrom) {
+  const unitRates = input.unitRates === void 0 ? client.Prisma.sql`NULL` : client.Prisma.sql`${serializeUnitRates(input.unitRates)}::jsonb`;
+  return [
+    client.Prisma.sql`${crypto.randomUUID()}`,
+    client.Prisma.sql`${input.provider}`,
+    client.Prisma.sql`${input.model}`,
+    client.Prisma.sql`${input.operation}`,
+    client.Prisma.sql`${serviceTier}`,
+    client.Prisma.sql`${input.inputNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.outputNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.cacheReadNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.cacheWrite5mNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.cacheWrite1hNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.reasoningNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.audioInNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.audioOutNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.imageInNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.imageOutNanoUsdPerMillion ?? 0n}`,
+    client.Prisma.sql`${input.tierThresholdTokens ?? null}`,
+    client.Prisma.sql`${input.tierInputNanoUsdPerMillion ?? null}`,
+    client.Prisma.sql`${input.tierOutputNanoUsdPerMillion ?? null}`,
+    unitRates,
+    client.Prisma.sql`${"USD"}`,
+    client.Prisma.sql`${effectiveFrom}`,
+    client.Prisma.sql`${null}`,
+    client.Prisma.sql`${input.source ?? "snapshot"}`
+  ];
+}
+function statusAssignments(from, to, patch, prevHash, hash) {
+  const parts = [client.Prisma.sql`"status" = ${to}`, client.Prisma.sql`"updatedAt" = CURRENT_TIMESTAMP`];
+  if (patch !== void 0) {
+    for (const [key, value] of Object.entries(patch)) {
+      if (!isLegalTransitionPatchKey(from, to, key)) {
+        throw new nestAiTokens.AiTokensException("AI_TOKENS_IDEMPOTENCY_CONFLICT", void 0, {
+          reason: `${from} \u2192 ${to} may not patch "${key}"`
+        });
+      }
+      parts.push(client.Prisma.sql`${client.Prisma.raw(`"${key}"`)} = ${value}`);
+    }
+  }
+  if (hash !== null) {
+    parts.push(client.Prisma.sql`"prevHash" = ${prevHash}`, client.Prisma.sql`"hash" = ${hash}`);
+  }
+  return client.Prisma.join(parts, ", ");
+}
+function buildWhere(filter) {
+  const parts = [client.Prisma.sql`"tenantId" = ${filter.tenantId}`];
+  if (filter.scope !== void 0) parts.push(client.Prisma.sql`"scopeType" = ${filter.scope.type} AND "scopeId" = ${filter.scope.id}`);
+  if (filter.beneficiary !== void 0) {
+    parts.push(client.Prisma.sql`"beneficiaryType" = ${filter.beneficiary.type} AND "beneficiaryId" = ${filter.beneficiary.id}`);
+  }
+  if (filter.feature !== void 0) parts.push(client.Prisma.sql`"feature" = ${filter.feature}`);
+  if (filter.features !== void 0) parts.push(client.Prisma.sql`"feature" = ANY(${filter.features}::text[])`);
+  if (filter.provider !== void 0) parts.push(client.Prisma.sql`"provider" = ${filter.provider}`);
+  if (filter.model !== void 0) parts.push(client.Prisma.sql`"model" = ${filter.model}`);
+  if (filter.operation !== void 0) parts.push(client.Prisma.sql`"operation" = ${filter.operation}`);
+  if (filter.serviceTier !== void 0) parts.push(client.Prisma.sql`"serviceTier" = ${filter.serviceTier}`);
+  if (filter.tags !== void 0) parts.push(client.Prisma.sql`"tags" @> ${filter.tags}::text[]`);
+  if (filter.isSystemCost !== void 0) parts.push(client.Prisma.sql`"isSystemCost" = ${filter.isSystemCost}`);
+  if (filter.systemCostCategory !== void 0) parts.push(client.Prisma.sql`"systemCostCategory" = ${filter.systemCostCategory}`);
+  if (filter.status !== void 0) parts.push(client.Prisma.sql`"status" = ANY(${filter.status}::text[])`);
+  if (filter.enforcedOnly === true) parts.push(client.Prisma.sql`"enforced" = true`);
+  if (filter.from !== void 0) parts.push(client.Prisma.sql`"occurredAt" >= ${filter.from}`);
+  if (filter.to !== void 0) parts.push(client.Prisma.sql`"occurredAt" <= ${filter.to}`);
+  return client.Prisma.join(parts, " AND ");
+}
+var WalletMissingError = class extends Error {
+  isWalletMissing = true;
+  constructor() {
+    super("wallet does not exist");
+    this.name = "WalletMissingError";
+  }
+};
+function isWalletMissing(error) {
+  if (typeof error !== "object" || error === null) return false;
+  return error.isWalletMissing === true;
+}
+function mapWalletRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    ownerType: row.ownerType,
+    ownerId: row.ownerId,
+    balanceNanoUsd: row.balanceNanoUsd,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function mapWalletEntryRow(row) {
+  return {
+    id: row.id,
+    walletId: row.walletId,
+    type: row.type,
+    amountNanoUsd: row.amountNanoUsd,
+    priority: row.priority,
+    effectiveAt: row.effectiveAt,
+    ...row.expiresAt !== null ? { expiresAt: row.expiresAt } : {},
+    ...row.usageRecordId !== null ? { usageRecordId: row.usageRecordId } : {},
+    idempotencyKey: row.idempotencyKey,
+    ...row.reason !== null ? { reason: row.reason } : {},
+    createdAt: row.createdAt
+  };
+}
+function mapOpenGrantRow(row) {
+  return { ...mapWalletEntryRow(row), remainingNanoUsd: row.remaining };
+}
+function walletAutoCreatable(entry) {
+  return entry.type === "grant" || entry.type === "adjustment" && entry.amountNanoUsd > 0n;
+}
+function walletBalanceDelta(entry) {
+  if (entry.type !== "grant") return entry.amountNanoUsd;
+  const spendable = entry.effectiveAt <= entry.createdAt && (entry.expiresAt === void 0 || entry.expiresAt > entry.createdAt);
+  return spendable ? entry.amountNanoUsd : 0n;
+}
+function walletEntryMatches(row, entry) {
+  return row.type === entry.type && row.amountNanoUsd === entry.amountNanoUsd && row.priority === entry.priority && (row.expiresAt?.getTime() ?? null) === (entry.expiresAt?.getTime() ?? null) && (row.usageRecordId ?? null) === (entry.usageRecordId ?? null) && (row.reason ?? null) === (entry.reason ?? null);
+}
+function walletEntryWhere(walletId, filter) {
+  const parts = [client.Prisma.sql`"walletId" = ${walletId}`];
+  if (filter.type !== void 0) parts.push(client.Prisma.sql`"type" = ${filter.type}`);
+  if (filter.from !== void 0) parts.push(client.Prisma.sql`"createdAt" >= ${filter.from}`);
+  if (filter.to !== void 0) parts.push(client.Prisma.sql`"createdAt" <= ${filter.to}`);
+  return client.Prisma.join(parts, " AND ");
+}
+function spendableBalanceSql(now) {
+  return client.Prisma.sql`(
+    SELECT COALESCE(SUM(CASE WHEN e."type" = 'grant'
+                             THEN (CASE WHEN e."effectiveAt" <= ${now} THEN e."amountNanoUsd" ELSE 0 END)
+                             ELSE e."amountNanoUsd" END), 0)
+    FROM "ai_wallet_entries" e WHERE e."walletId" = w."id"
+  ) - (
+    SELECT COALESCE(SUM(g."amountNanoUsd" - COALESCE((SELECT SUM(a."amountNanoUsd") FROM "ai_wallet_debit_allocations" a WHERE a."grantEntryId" = g."id"), 0)), 0)
+    FROM "ai_wallet_entries" g
+    WHERE g."walletId" = w."id" AND g."type" = 'grant' AND g."effectiveAt" <= ${now}
+      AND g."expiresAt" IS NOT NULL AND g."expiresAt" <= ${now}
+  )`;
+}
+function serializeWindow(window) {
+  return typeof window === "object" ? `custom:${window.customSeconds.toString()}` : window;
+}
+function parseWindow(value) {
+  if (value.startsWith("custom:")) return { customSeconds: Number(value.slice("custom:".length)) };
+  return value;
+}
+function mapBudgetRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    scope: { type: row.scopeType, id: row.scopeId },
+    ...row.features.length > 0 ? { features: row.features } : {},
+    ...row.limitNanoUsd !== null ? { limitNanoUsd: row.limitNanoUsd } : {},
+    ...row.limitTokens !== null ? { limitTokens: Number(row.limitTokens) } : {},
+    ...row.limitCount !== null ? { limitCount: row.limitCount } : {},
+    window: parseWindow(row.window),
+    ...row.anchorAt !== null ? { anchorAt: row.anchorAt } : {},
+    ...row.expiresAt !== null ? { expiresAt: row.expiresAt } : {},
+    softThresholds: row.softThresholds,
+    policy: row.policy,
+    createdAt: row.createdAt
+  };
+}
+function mapBudgetWindowRow(row) {
+  return { spentNanoUsd: row.spentNanoUsd, spentTokens: Number(row.spentTokens), spentCount: row.spentCount };
+}
+var BUDGET_COLUMNS = [
+  "id",
+  "tenantId",
+  "scopeType",
+  "scopeId",
+  "features",
+  "limitNanoUsd",
+  "limitTokens",
+  "limitCount",
+  "window",
+  "anchorAt",
+  "expiresAt",
+  "softThresholds",
+  "policy"
+];
+var BUDGET_COLUMNS_SQL = client.Prisma.raw(BUDGET_COLUMNS.map((column) => `"${column}"`).join(", "));
+function tokenLimitSql(limit) {
+  return limit === void 0 ? null : BigInt(limit);
+}
+function budgetValues(id, input) {
+  return [
+    client.Prisma.sql`${id}`,
+    client.Prisma.sql`${input.tenantId}`,
+    client.Prisma.sql`${input.scope.type}`,
+    client.Prisma.sql`${input.scope.id}`,
+    client.Prisma.sql`${input.features ?? []}::text[]`,
+    client.Prisma.sql`${input.limitNanoUsd ?? null}`,
+    client.Prisma.sql`${tokenLimitSql(input.limitTokens)}`,
+    client.Prisma.sql`${input.limitCount ?? null}`,
+    client.Prisma.sql`${serializeWindow(input.window)}`,
+    client.Prisma.sql`${input.anchorAt ?? null}`,
+    client.Prisma.sql`${input.expiresAt ?? null}`,
+    client.Prisma.sql`${JSON.stringify(input.softThresholds)}::jsonb`,
+    client.Prisma.sql`${input.policy}`
+  ];
+}
+function budgetUpdateAssignments(input) {
+  return client.Prisma.join(
+    [
+      client.Prisma.sql`"scopeType" = ${input.scope.type}`,
+      client.Prisma.sql`"scopeId" = ${input.scope.id}`,
+      client.Prisma.sql`"features" = ${input.features ?? []}::text[]`,
+      client.Prisma.sql`"limitNanoUsd" = ${input.limitNanoUsd ?? null}`,
+      client.Prisma.sql`"limitTokens" = ${tokenLimitSql(input.limitTokens)}`,
+      client.Prisma.sql`"limitCount" = ${input.limitCount ?? null}`,
+      client.Prisma.sql`"window" = ${serializeWindow(input.window)}`,
+      client.Prisma.sql`"anchorAt" = ${input.anchorAt ?? null}`,
+      client.Prisma.sql`"expiresAt" = ${input.expiresAt ?? null}`,
+      client.Prisma.sql`"softThresholds" = ${JSON.stringify(input.softThresholds)}::jsonb`,
+      client.Prisma.sql`"policy" = ${input.policy}`,
+      client.Prisma.sql`"updatedAt" = CURRENT_TIMESTAMP`
+    ],
+    ", "
+  );
+}
+
+// src/prisma/index.ts
+var PrismaAiTokensStore = class {
+  /**
+   * @param prisma The host's Prisma client (talks to PostgreSQL).
+   * @param options Optional wallet grant burn order (must match the module's `wallets.burnOrder`; default `'expiry'`).
+   */
+  constructor(prisma, options = {}) {
+    this.prisma = prisma;
+    this.burnOrder = options.burnOrder ?? "expiry";
+  }
+  prisma;
+  burnOrder;
+  async append(record, payloadHash, hashChain) {
+    try {
+      if (hashChain === true && record.status === "posted") {
+        return await this.prisma.$transaction((tx) => this.insertChained(tx, record, payloadHash));
+      }
+      return await this.insert(this.prisma, crypto.randomUUID(), record, payloadHash, null, null);
+    } catch (error) {
+      if (isUniqueViolation(error)) return this.replayOrConflict(record, payloadHash);
+      throw storeError(error);
+    }
+  }
+  transition(id, from, to, patch, hashChain) {
+    if (hashChain === true && to === "posted") return this.settleChained(id, from, patch);
+    return this.updateStatus(this.prisma, id, from, to, patch, null, null);
+  }
+  async findByIdempotencyKey(tenantId, key) {
+    const rows = await this.prisma.$queryRaw(
+      client.Prisma.sql`SELECT * FROM "ai_usage_records" WHERE "tenantId" = ${tenantId} AND "idempotencyKey" = ${key} LIMIT 1`
+    );
+    return rows[0] === void 0 ? null : mapUsageRow(rows[0]);
+  }
+  async findById(id) {
+    const rows = await this.prisma.$queryRaw(
+      client.Prisma.sql`SELECT * FROM "ai_usage_records" WHERE "id" = ${id} LIMIT 1`
+    );
+    return rows[0] === void 0 ? null : mapUsageRow(rows[0]);
+  }
+  async findExpiredHolds(olderThan, limit) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_usage_records"
+      WHERE "status" = 'pending' AND "createdAt" < ${olderThan}
+      ORDER BY "createdAt" ASC LIMIT ${limit}
+    `);
+    return rows.map(mapUsageRow);
+  }
+  async query(filter) {
+    const limit = filter.limit === void 0 ? client.Prisma.empty : client.Prisma.sql`LIMIT ${filter.limit}`;
+    const offset = filter.offset === void 0 ? client.Prisma.empty : client.Prisma.sql`OFFSET ${filter.offset}`;
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_usage_records" WHERE ${buildWhere(filter)}
+      ORDER BY "createdAt" ASC ${limit} ${offset}
+    `);
+    return rows.map(mapUsageRow);
+  }
+  async sumCost(filter) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT
+        COALESCE(SUM("rawCostNanoUsd"), 0)::bigint AS "raw",
+        COALESCE(SUM("billedCostNanoUsd"), 0)::bigint AS "billed",
+        COALESCE(SUM("surchargeNanoUsd"), 0)::bigint AS "surcharge",
+        COALESCE(SUM("totalTokens"), 0)::bigint AS "tokens",
+        COUNT(*)::int AS "records"
+      FROM "ai_usage_records" WHERE ${buildWhere(filter)}
+    `);
+    const row = rows[0] ?? { raw: 0n, billed: 0n, surcharge: 0n, tokens: 0n, records: 0 };
+    return {
+      rawCostNanoUsd: row.raw,
+      billedCostNanoUsd: row.billed,
+      surchargeNanoUsd: row.surcharge,
+      totalTokens: Number(row.tokens),
+      records: row.records
+    };
+  }
+  lastHash(tenantId) {
+    return this.lastHashWithin(this.prisma, tenantId);
+  }
+  async resolveRate(provider, model, operation, serviceTier, at) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_model_prices"
+      WHERE "provider" = ${provider} AND "model" = ${model} AND "operation" = ${operation}
+        AND "serviceTier" = ${serviceTier} AND "effectiveFrom" <= ${at}
+        AND ("effectiveTo" IS NULL OR "effectiveTo" >= ${at})
+      ORDER BY "effectiveFrom" DESC LIMIT 1
+    `);
+    return rows[0] === void 0 ? null : mapPriceRow(rows[0]);
+  }
+  async upsertPrice(input) {
+    const serviceTier = input.serviceTier ?? "standard";
+    const effectiveFrom = input.effectiveFrom ?? /* @__PURE__ */ new Date();
+    const key = `${input.provider}|${input.model}|${input.operation}|${serviceTier}`;
+    return this.prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${key})::bigint)`;
+      await tx.$executeRaw(client.Prisma.sql`
+        UPDATE "ai_model_prices" SET "effectiveTo" = ${effectiveFrom}
+        WHERE "provider" = ${input.provider} AND "model" = ${input.model} AND "operation" = ${input.operation}
+          AND "serviceTier" = ${serviceTier} AND "effectiveTo" IS NULL
+      `);
+      const rows = await tx.$queryRaw(client.Prisma.sql`
+        INSERT INTO "ai_model_prices" (${PRICE_COLUMNS_SQL}) VALUES (${client.Prisma.join(priceValues(input, serviceTier, effectiveFrom))})
+        RETURNING *
+      `);
+      return mapPriceRow(firstOrThrow(rows));
+    });
+  }
+  async getPriceHistory(provider, model, operation, serviceTier) {
+    const tier = serviceTier === void 0 ? client.Prisma.empty : client.Prisma.sql`AND "serviceTier" = ${serviceTier}`;
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_model_prices"
+      WHERE "provider" = ${provider} AND "model" = ${model} AND "operation" = ${operation} ${tier}
+      ORDER BY "effectiveFrom" DESC
+    `);
+    return rows.map(mapPriceRow);
+  }
+  async listModels(provider) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT DISTINCT "model", "operation", "serviceTier" FROM "ai_model_prices" WHERE "provider" = ${provider}
+    `);
+    return rows.map((row) => ({ model: row.model, operation: row.operation, serviceTier: row.serviceTier }));
+  }
+  /** Advisory seed lock (§6.4): the first caller wins; concurrent boots seed exactly once. */
+  async acquireSeedLock(key) {
+    const rows = await this.prisma.$queryRaw(
+      client.Prisma.sql`SELECT pg_try_advisory_lock(hashtext(${key})::bigint) AS "acquired"`
+    );
+    return rows[0]?.acquired ?? false;
+  }
+  /** Insert one usage row and return it; shared by the plain and chained paths. */
+  async insert(executor, id, record, payloadHash, prevHash, hash) {
+    const values = client.Prisma.join(usageValues(id, record, payloadHash, prevHash, hash));
+    const rows = await executor.$queryRaw(
+      client.Prisma.sql`INSERT INTO "ai_usage_records" (${USAGE_COLUMNS_SQL}) VALUES (${values}) RETURNING *`
+    );
+    return mapUsageRow(firstOrThrow(rows));
+  }
+  /** Insert a `posted` row under the per-tenant chain lock (§8.6). */
+  async insertChained(tx, record, payloadHash) {
+    await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${record.tenantId})::bigint)`;
+    const prevHash = await this.lastHashWithin(tx, record.tenantId);
+    const id = crypto.randomUUID();
+    const hash = chainHash(prevHash, { ...record, id });
+    return this.insert(tx, id, record, payloadHash, prevHash, hash);
+  }
+  /** Settle a hold `pending → posted`, computing its chain hash under the lock (§8.6). */
+  settleChained(id, from, patch) {
+    return this.prisma.$transaction(async (tx) => {
+      const rows = await tx.$queryRaw(
+        client.Prisma.sql`SELECT * FROM "ai_usage_records" WHERE "id" = ${id} AND "status" = ${from} FOR UPDATE`
+      );
+      if (rows[0] === void 0) return null;
+      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${rows[0].tenantId})::bigint)`;
+      const prevHash = await this.lastHashWithin(tx, rows[0].tenantId);
+      const settled = { ...mapUsageRow(rows[0]), ...patch};
+      return this.updateStatus(tx, id, from, "posted", patch, prevHash, chainHash(prevHash, settled));
+    });
+  }
+  /** Atomic status transition via a conditional `UPDATE`; 0 rows → `null` (§8.3). */
+  async updateStatus(executor, id, from, to, patch, prevHash, hash) {
+    const assignments = statusAssignments(from, to, patch, prevHash, hash);
+    const rows = await executor.$queryRaw(
+      client.Prisma.sql`UPDATE "ai_usage_records" SET ${assignments} WHERE "id" = ${id} AND "status" = ${from} RETURNING *`
+    );
+    return rows[0] === void 0 ? null : mapUsageRow(rows[0]);
+  }
+  /** The tenant's last chain hash (most recently created settled row). */
+  async lastHashWithin(executor, tenantId) {
+    const rows = await executor.$queryRaw(client.Prisma.sql`
+      SELECT "hash" FROM "ai_usage_records"
+      WHERE "tenantId" = ${tenantId} AND "hash" IS NOT NULL
+      ORDER BY "createdAt" DESC, "id" DESC LIMIT 1
+    `);
+    return rows[0]?.hash ?? null;
+  }
+  async getWallet(ref) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_wallets"
+      WHERE "tenantId" = ${ref.tenantId} AND "ownerType" = ${ref.ownerType} AND "ownerId" = ${ref.ownerId} LIMIT 1
+    `);
+    return rows[0] === void 0 ? null : mapWalletRow(rows[0]);
+  }
+  async appendEntry(ref, entry, allocations = []) {
+    try {
+      return await this.prisma.$transaction(async (tx) => {
+        const wallet = await this.ensureWallet(tx, ref, walletAutoCreatable(entry));
+        if (wallet === null) throw new WalletMissingError();
+        const stored = await this.insertWalletEntry(tx, wallet.id, entry);
+        await this.insertAllocations(tx, stored.id, allocations);
+        await this.applyBalanceDelta(tx, wallet.id, walletBalanceDelta(stored));
+        return stored;
+      });
+    } catch (error) {
+      if (isUniqueViolation(error)) return this.replayOrConflictWallet(ref, entry);
+      if (isWalletMissing(error)) throw error;
+      throw storeError(error);
+    }
+  }
+  async conditionalDebit(ref, entry, overdraftNanoUsd) {
+    try {
+      return await this.prisma.$transaction(async (tx) => {
+        const wallet = await this.getWalletWithin(tx, ref) ?? null;
+        if (wallet === null) return null;
+        const replay = await this.walletReplay(tx, wallet.id, ref, entry);
+        if (replay !== void 0) return replay;
+        await this.sweepExpiredGrants(tx, wallet.id);
+        const cost = -entry.amountNanoUsd;
+        const reserved = await tx.$queryRaw(client.Prisma.sql`
+          UPDATE "ai_wallets" SET "balanceNanoUsd" = "balanceNanoUsd" - ${cost}, "updatedAt" = CURRENT_TIMESTAMP
+          WHERE "id" = ${wallet.id} AND "balanceNanoUsd" - ${cost} >= ${-overdraftNanoUsd} RETURNING *
+        `);
+        if (reserved[0] === void 0) return null;
+        const debit = await this.insertWalletEntry(tx, wallet.id, entry);
+        await this.insertAllocations(tx, debit.id, await this.burnDown(tx, wallet.id, cost));
+        return debit;
+      });
+    } catch (error) {
+      if (isLedgerIdempotencyConflict(error)) throw error;
+      if (isUniqueViolation(error)) return this.replayOrConflictWallet(ref, entry);
+      throw storeError(error);
+    }
+  }
+  async openGrants(ref, order) {
+    const wallet = await this.getWallet(ref);
+    if (wallet === null) return [];
+    const rows = await this.prisma.$queryRaw(this.openGrantsSql(wallet.id, order));
+    return rows.map(mapOpenGrantRow);
+  }
+  async listEntries(ref, filter = {}) {
+    const wallet = await this.getWallet(ref);
+    if (wallet === null) return { entries: [], total: 0 };
+    const where = walletEntryWhere(wallet.id, filter);
+    const limit = filter.limit === void 0 ? client.Prisma.empty : client.Prisma.sql`LIMIT ${filter.limit}`;
+    const offset = filter.offset === void 0 ? client.Prisma.empty : client.Prisma.sql`OFFSET ${filter.offset}`;
+    const [entries, counts] = await Promise.all([
+      this.prisma.$queryRaw(
+        client.Prisma.sql`SELECT * FROM "ai_wallet_entries" WHERE ${where} ORDER BY "createdAt" ASC ${limit} ${offset}`
+      ),
+      this.prisma.$queryRaw(client.Prisma.sql`SELECT COUNT(*)::bigint AS "total" FROM "ai_wallet_entries" WHERE ${where}`)
+    ]);
+    return { entries: entries.map(mapWalletEntryRow), total: Number(counts[0]?.total ?? 0n) };
+  }
+  async reconcile(ref) {
+    const wallet = await this.getWallet(ref);
+    if (wallet === null) throw new nestAiTokens.AiTokensException("AI_TOKENS_INSUFFICIENT_CREDITS", void 0, { reason: "wallet does not exist" });
+    const now = /* @__PURE__ */ new Date();
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      UPDATE "ai_wallets" w SET "balanceNanoUsd" = ${spendableBalanceSql(now)}, "updatedAt" = CURRENT_TIMESTAMP
+      WHERE w."id" = ${wallet.id} RETURNING *
+    `);
+    return mapWalletRow(firstOrThrow(rows));
+  }
+  async upsert(input) {
+    const id = input.id ?? crypto.randomUUID();
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      INSERT INTO "ai_budgets" (${BUDGET_COLUMNS_SQL}) VALUES (${client.Prisma.join(budgetValues(id, input))})
+      ON CONFLICT ("id") DO UPDATE SET ${budgetUpdateAssignments(input)} RETURNING *
+    `);
+    return mapBudgetRow(firstOrThrow(rows));
+  }
+  async remove(budgetId) {
+    await this.prisma.$transaction([
+      this.prisma.$executeRaw`DELETE FROM "ai_budget_windows" WHERE "budgetId" = ${budgetId}`,
+      this.prisma.$executeRaw`DELETE FROM "ai_budgets" WHERE "id" = ${budgetId}`
+    ]);
+  }
+  async findBudgetById(budgetId) {
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`SELECT * FROM "ai_budgets" WHERE "id" = ${budgetId} LIMIT 1`);
+    return rows[0] === void 0 ? null : mapBudgetRow(rows[0]);
+  }
+  async findMatching(tenantId, scope) {
+    const now = /* @__PURE__ */ new Date();
+    const rows = await this.prisma.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_budgets"
+      WHERE "tenantId" = ${tenantId}
+        AND ("scopeType" = 'tenant' OR ("scopeType" = ${scope.type} AND "scopeId" = ${scope.id}))
+        AND ("expiresAt" IS NULL OR "expiresAt" > ${now})
+    `);
+    return rows.map(mapBudgetRow);
+  }
+  async conditionalConsume(budgetId, windowStart, delta, limits) {
+    return this.prisma.$transaction(async (tx) => {
+      await this.ensureWindow(tx, budgetId, windowStart);
+      const rows = await tx.$queryRaw(client.Prisma.sql`
+        UPDATE "ai_budget_windows"
+        SET "spentNanoUsd" = "spentNanoUsd" + ${delta.nanoUsd},
+            "spentTokens" = "spentTokens" + ${BigInt(delta.tokens)},
+            "spentCount" = "spentCount" + ${delta.count},
+            "updatedAt" = CURRENT_TIMESTAMP
+        WHERE "budgetId" = ${budgetId} AND "windowStart" = ${windowStart}
+          AND (${limits.nanoUsd ?? null}::bigint IS NULL OR "spentNanoUsd" + ${delta.nanoUsd} <= ${limits.nanoUsd ?? null})
+          AND (${limits.tokens === void 0 ? null : BigInt(limits.tokens)}::bigint IS NULL OR "spentTokens" + ${BigInt(delta.tokens)} <= ${limits.tokens === void 0 ? null : BigInt(limits.tokens)})
+          AND (${limits.count ?? null}::int IS NULL OR "spentCount" + ${delta.count} <= ${limits.count ?? null})
+        RETURNING "id"
+      `);
+      return rows[0] !== void 0;
+    });
+  }
+  async adjustWindow(budgetId, windowStart, delta) {
+    await this.prisma.$transaction(async (tx) => {
+      await this.ensureWindow(tx, budgetId, windowStart);
+      await tx.$executeRaw(client.Prisma.sql`
+        UPDATE "ai_budget_windows"
+        SET "spentNanoUsd" = GREATEST(0, "spentNanoUsd" + ${delta.nanoUsd}),
+            "spentTokens" = GREATEST(0, "spentTokens" + ${BigInt(delta.tokens)}),
+            "spentCount" = GREATEST(0, "spentCount" + ${delta.count}),
+            "updatedAt" = CURRENT_TIMESTAMP
+        WHERE "budgetId" = ${budgetId} AND "windowStart" = ${windowStart}
+      `);
+    });
+  }
+  async getWindow(budgetId, windowStart) {
+    const rows = await this.prisma.$queryRaw(
+      client.Prisma.sql`SELECT * FROM "ai_budget_windows" WHERE "budgetId" = ${budgetId} AND "windowStart" = ${windowStart} LIMIT 1`
+    );
+    return rows[0] === void 0 ? null : mapBudgetWindowRow(rows[0]);
+  }
+  async setWindowStart(budgetId, windowStart) {
+    await this.prisma.$executeRaw(client.Prisma.sql`
+      INSERT INTO "ai_budget_windows" ("id", "budgetId", "windowStart", "spentNanoUsd", "spentTokens", "spentCount", "updatedAt")
+      VALUES (${crypto.randomUUID()}, ${budgetId}, ${windowStart}, 0, 0, 0, CURRENT_TIMESTAMP)
+      ON CONFLICT ("budgetId", "windowStart") DO UPDATE SET "spentNanoUsd" = 0, "spentTokens" = 0, "spentCount" = 0, "updatedAt" = CURRENT_TIMESTAMP
+    `);
+  }
+  /** Load the wallet within a transaction (existence + id for the conditional debit). */
+  async getWalletWithin(tx, ref) {
+    const rows = await tx.$queryRaw(client.Prisma.sql`
+      SELECT * FROM "ai_wallets"
+      WHERE "tenantId" = ${ref.tenantId} AND "ownerType" = ${ref.ownerType} AND "ownerId" = ${ref.ownerId} LIMIT 1
+    `);
+    return rows[0];
+  }
+  /** Fetch or (optionally) create the wallet for a ref within a transaction. */
+  async ensureWallet(tx, ref, autoCreate) {
+    const existing = await this.getWalletWithin(tx, ref);
+    if (existing !== void 0) return existing;
+    if (!autoCreate) return null;
+    const rows = await tx.$queryRaw(client.Prisma.sql`
+      INSERT INTO "ai_wallets" ("id", "tenantId", "ownerType", "ownerId", "balanceNanoUsd", "createdAt", "updatedAt")
+      VALUES (${crypto.randomUUID()}, ${ref.tenantId}, ${ref.ownerType}, ${ref.ownerId}, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT ("tenantId", "ownerType", "ownerId") DO UPDATE SET "updatedAt" = "ai_wallets"."updatedAt" RETURNING *
+    `);
+    return firstOrThrow(rows);
+  }
+  /** Insert a wallet entry, returning the stored row. */
+  async insertWalletEntry(tx, walletId, entry) {
+    const rows = await tx.$queryRaw(client.Prisma.sql`
+      INSERT INTO "ai_wallet_entries" ("id", "walletId", "type", "amountNanoUsd", "priority", "effectiveAt", "expiresAt", "usageRecordId", "idempotencyKey", "reason", "createdAt")
+      VALUES (${crypto.randomUUID()}, ${walletId}, ${entry.type}, ${entry.amountNanoUsd}, ${entry.priority}, ${entry.effectiveAt}, ${entry.expiresAt ?? null}, ${entry.usageRecordId ?? null}, ${entry.idempotencyKey}, ${entry.reason ?? null}, CURRENT_TIMESTAMP)
+      RETURNING *
+    `);
+    return mapWalletEntryRow(firstOrThrow(rows));
+  }
+  /** Insert the debit→grant allocation trail. */
+  async insertAllocations(tx, debitEntryId, allocations) {
+    for (const allocation of allocations) {
+      await tx.$executeRaw(client.Prisma.sql`
+        INSERT INTO "ai_wallet_debit_allocations" ("id", "debitEntryId", "grantEntryId", "amountNanoUsd")
+        VALUES (${crypto.randomUUID()}, ${debitEntryId}, ${allocation.grantEntryId}, ${allocation.amountNanoUsd})
+      `);
+    }
+  }
+  /** Apply a signed delta to the materialized balance. */
+  async applyBalanceDelta(tx, walletId, delta) {
+    if (delta === 0n) return;
+    await tx.$executeRaw(client.Prisma.sql`
+      UPDATE "ai_wallets" SET "balanceNanoUsd" = "balanceNanoUsd" + ${delta}, "updatedAt" = CURRENT_TIMESTAMP WHERE "id" = ${walletId}
+    `);
+  }
+  /** Write an `expiry` entry (with its allocation) for each expired grant with a remainder. */
+  async sweepExpiredGrants(tx, walletId) {
+    const now = /* @__PURE__ */ new Date();
+    const grants = await tx.$queryRaw(client.Prisma.sql`
+      SELECT g."id", g."priority", (g."amountNanoUsd" - COALESCE((SELECT SUM(a."amountNanoUsd") FROM "ai_wallet_debit_allocations" a WHERE a."grantEntryId" = g."id"), 0))::bigint AS "remaining"
+      FROM "ai_wallet_entries" g
+      WHERE g."walletId" = ${walletId} AND g."type" = 'grant'
+        AND g."effectiveAt" <= g."createdAt" AND (g."expiresAt" IS NULL OR g."expiresAt" > g."createdAt")
+        AND g."expiresAt" IS NOT NULL AND g."expiresAt" <= ${now}
+    `);
+    for (const grant of grants) {
+      if (grant.remaining <= 0n) continue;
+      const expiry = await this.insertWalletEntry(tx, walletId, {
+        walletId,
+        type: "expiry",
+        amountNanoUsd: -grant.remaining,
+        priority: grant.priority,
+        effectiveAt: now,
+        idempotencyKey: `expiry:${grant.id}`,
+        reason: "grant expired"
+      });
+      await this.insertAllocations(tx, expiry.id, [{ grantEntryId: grant.id, amountNanoUsd: grant.remaining }]);
+      await this.applyBalanceDelta(tx, walletId, -grant.remaining);
+    }
+  }
+  /** Greedily allocate a debit of `cost` across the open grants in burn order. */
+  async burnDown(tx, walletId, cost) {
+    const grants = await tx.$queryRaw(this.openGrantsSql(walletId, this.burnOrder));
+    const trail = [];
+    let remaining = cost;
+    for (const grant of grants) {
+      if (remaining <= 0n) break;
+      const take = grant.remaining < remaining ? grant.remaining : remaining;
+      trail.push({ grantEntryId: grant.id, amountNanoUsd: take });
+      remaining -= take;
+    }
+    return trail;
+  }
+  /** The open-grants query (remaining > 0, effective, not expired) ordered per burn order. */
+  openGrantsSql(walletId, order) {
+    const now = /* @__PURE__ */ new Date();
+    const orderBy = order === "priority" ? client.Prisma.sql`g."priority" ASC, g."createdAt" ASC` : order === "fifo" ? client.Prisma.sql`g."createdAt" ASC` : client.Prisma.sql`g."expiresAt" ASC NULLS LAST, g."createdAt" ASC`;
+    return client.Prisma.sql`
+      SELECT g.*, (g."amountNanoUsd" - COALESCE((SELECT SUM(a."amountNanoUsd") FROM "ai_wallet_debit_allocations" a WHERE a."grantEntryId" = g."id"), 0))::bigint AS "remaining"
+      FROM "ai_wallet_entries" g
+      WHERE g."walletId" = ${walletId} AND g."type" = 'grant'
+        AND g."effectiveAt" <= ${now} AND (g."expiresAt" IS NULL OR g."expiresAt" > ${now})
+        AND (g."amountNanoUsd" - COALESCE((SELECT SUM(a."amountNanoUsd") FROM "ai_wallet_debit_allocations" a WHERE a."grantEntryId" = g."id"), 0)) > 0
+      ORDER BY ${orderBy}
+    `;
+  }
+  /** Return the existing entry on a matching replay, throw the conflict, or `undefined` when new. */
+  async walletReplay(tx, walletId, ref, entry) {
+    const rows = await tx.$queryRaw(
+      client.Prisma.sql`SELECT * FROM "ai_wallet_entries" WHERE "walletId" = ${walletId} AND "idempotencyKey" = ${entry.idempotencyKey} LIMIT 1`
+    );
+    if (rows[0] === void 0) return void 0;
+    if (walletEntryMatches(rows[0], entry)) return mapWalletEntryRow(rows[0]);
+    throw new LedgerIdempotencyConflict(ref.tenantId, entry.idempotencyKey);
+  }
+  /** Ensure a (zeroed) window row exists for first-touch consumption. */
+  async ensureWindow(tx, budgetId, windowStart) {
+    await tx.$executeRaw(client.Prisma.sql`
+      INSERT INTO "ai_budget_windows" ("id", "budgetId", "windowStart", "spentNanoUsd", "spentTokens", "spentCount", "updatedAt")
+      VALUES (${crypto.randomUUID()}, ${budgetId}, ${windowStart}, 0, 0, 0, CURRENT_TIMESTAMP)
+      ON CONFLICT ("budgetId", "windowStart") DO NOTHING
+    `);
+  }
+  /** Map the P2002 replay-or-conflict path for a wallet entry (§15.2). */
+  async replayOrConflictWallet(ref, entry) {
+    const wallet = await this.getWallet(ref);
+    if (wallet !== null) {
+      const rows = await this.prisma.$queryRaw(
+        client.Prisma.sql`SELECT * FROM "ai_wallet_entries" WHERE "walletId" = ${wallet.id} AND "idempotencyKey" = ${entry.idempotencyKey} LIMIT 1`
+      );
+      if (rows[0] !== void 0 && walletEntryMatches(rows[0], entry)) return mapWalletEntryRow(rows[0]);
+    }
+    throw new LedgerIdempotencyConflict(ref.tenantId, entry.idempotencyKey);
+  }
+  /** Return the existing record on a matching payload replay, else raise the conflict (§15.2). */
+  async replayOrConflict(record, payloadHash) {
+    const rows = await this.prisma.$queryRaw(
+      client.Prisma.sql`SELECT * FROM "ai_usage_records" WHERE "tenantId" = ${record.tenantId} AND "idempotencyKey" = ${record.idempotencyKey} LIMIT 1`
+    );
+    if (rows[0]?.payloadHash === payloadHash) return mapUsageRow(rows[0]);
+    throw new LedgerIdempotencyConflict(record.tenantId, record.idempotencyKey);
+  }
+};
+
+exports.PrismaAiTokensStore = PrismaAiTokensStore;