@burdenoff/be-sdk 2026.1015.2 → 2026.1017.1

package/dist/chunk-N2UT3ESH.js

@@ -0,0 +1,1506 @@
+import { productSlugVariants, emitProductSlug } from './chunk-OBBCR6WY.js';
+import { logger } from './chunk-RU266375.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+
+// src/platform/index.ts
+var platform_exports = {};
+__export(platform_exports, {
+  CircuitBreakerOpenError: () => CircuitBreakerOpenError,
+  DEFAULT_GRAPHQL_PAGE_LIMIT: () => DEFAULT_GRAPHQL_PAGE_LIMIT,
+  InvocationAccountingCoordinator: () => InvocationAccountingCoordinator,
+  InvocationAccountingValidationError: () => InvocationAccountingValidationError,
+  LLMRouter: () => LLMRouter,
+  MAX_GRAPHQL_PAGE_LIMIT: () => MAX_GRAPHQL_PAGE_LIMIT,
+  PROMPTS_V2_DOCUMENTS: () => PROMPTS_V2_DOCUMENTS,
+  __resetHttpClientBreakers: () => __resetHttpClientBreakers,
+  buildCacheKey: () => buildCacheKey,
+  buildConnection: () => buildConnection,
+  buildLoaders: () => buildLoaders,
+  buildOffsetPage: () => buildOffsetPage,
+  clampGraphqlLimit: () => clampGraphqlLimit,
+  clampLimit: () => clampLimit,
+  clampOffset: () => clampOffset,
+  createClaudeUsageAccumulator: () => createClaudeUsageAccumulator,
+  createHttpClient: () => createHttpClient,
+  createLeaderLease: () => createLeaderLease,
+  decodeCursor: () => decodeCursor,
+  dropOldPartitions: () => dropOldPartitions,
+  encodeCursor: () => encodeCursor,
+  ensureMonthlyPartitions: () => ensureMonthlyPartitions,
+  getNamespaceVersion: () => getNamespaceVersion,
+  httpClient: () => httpClient,
+  invalidateNamespace: () => invalidateNamespace,
+  monthlyPartitionName: () => monthlyPartitionName,
+  normalizeClaudeUsage: () => normalizeClaudeUsage,
+  normalizeCursorPagination: () => normalizeCursorPagination,
+  normalizeOffsetPagination: () => normalizeOffsetPagination,
+  normalizeOpenAIUsage: () => normalizeOpenAIUsage,
+  normalizeRedisUrl: () => normalizeRedisUrl,
+  paginate: () => paginate,
+  rateLimitIncr: () => rateLimitIncr,
+  resolveReferenceLoader: () => resolveReferenceLoader,
+  toPrismaPage: () => toPrismaPage,
+  validateInvocationAttemptInput: () => validateInvocationAttemptInput,
+  validateInvocationAttemptReceipt: () => validateInvocationAttemptReceipt,
+  validateInvocationDelivery: () => validateInvocationDelivery,
+  validateInvocationIdentity: () => validateInvocationIdentity,
+  validateInvocationUsageInput: () => validateInvocationUsageInput,
+  validateInvocationUsageReceipt: () => validateInvocationUsageReceipt,
+  validateInvocationUsageSummary: () => validateInvocationUsageSummary,
+  withLeaderLock: () => withLeaderLock
+});
+
+// src/platform/httpClient.ts
+var breakers = /* @__PURE__ */ new Map();
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+__name(hostOf, "hostOf");
+function getBreaker(host) {
+  let b = breakers.get(host);
+  if (!b) {
+    b = {
+      failures: 0,
+      openedAt: null,
+      state: "CLOSED"
+    };
+    breakers.set(host, b);
+  }
+  return b;
+}
+__name(getBreaker, "getBreaker");
+function defaultRetryOn(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500 && status <= 599;
+}
+__name(defaultRetryOn, "defaultRetryOn");
+function jitter(delay) {
+  return Math.floor(Math.random() * delay);
+}
+__name(jitter, "jitter");
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+__name(sleep, "sleep");
+var CircuitBreakerOpenError = class extends Error {
+  static {
+    __name(this, "CircuitBreakerOpenError");
+  }
+  constructor(host) {
+    super(`circuit breaker OPEN for host=${host}`);
+    this.name = "CircuitBreakerOpenError";
+  }
+};
+function __resetHttpClientBreakers() {
+  breakers.clear();
+}
+__name(__resetHttpClientBreakers, "__resetHttpClientBreakers");
+async function executeOnce(url, init, timeoutMs) {
+  const signal = init.signal ?? AbortSignal.timeout(timeoutMs);
+  return fetch(url, {
+    ...init,
+    signal
+  });
+}
+__name(executeOnce, "executeOnce");
+async function httpClient(url, init = {}, config = {}) {
+  const fullUrl = config.baseUrl && !/^https?:\/\//i.test(url) ? `${config.baseUrl.replace(/\/$/, "")}/${url.replace(/^\//, "")}` : url;
+  const host = hostOf(fullUrl);
+  const breaker = getBreaker(host);
+  const breakerThreshold = config.breaker?.threshold ?? 5;
+  const cooldownMs = config.breaker?.cooldownMs ?? 3e4;
+  if (breaker.state === "OPEN") {
+    if (breaker.openedAt && Date.now() - breaker.openedAt >= cooldownMs) {
+      breaker.state = "HALF_OPEN";
+      logger.info("httpClient.breaker.halfOpen", {
+        host
+      });
+    } else {
+      throw new CircuitBreakerOpenError(host);
+    }
+  }
+  const attempts = init.retry?.attempts ?? config.retry?.attempts ?? 3;
+  const initialDelay = init.retry?.initialDelayMs ?? config.retry?.initialDelayMs ?? 100;
+  const maxDelay = init.retry?.maxDelayMs ?? config.retry?.maxDelayMs ?? 2e3;
+  const retryOn = init.retry?.retryOn ?? config.retry?.retryOn ?? defaultRetryOn;
+  const timeoutMs = init.timeoutMs ?? config.defaultTimeoutMs ?? 5e3;
+  const headers = {
+    ...config.defaultHeaders ?? {},
+    ...init.headers ?? {}
+  };
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const response = await executeOnce(fullUrl, {
+        ...init,
+        headers
+      }, timeoutMs);
+      if (response.status >= 500) {
+        breaker.failures += 1;
+        if (breaker.failures >= breakerThreshold) {
+          breaker.state = "OPEN";
+          breaker.openedAt = Date.now();
+          logger.warn("httpClient.breaker.open", {
+            host,
+            failures: breaker.failures
+          });
+        }
+        if (attempt < attempts && retryOn(response.status)) {
+          const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+          await sleep(jitter(delay));
+          continue;
+        }
+        return response;
+      }
+      breaker.failures = 0;
+      if (breaker.state === "HALF_OPEN") {
+        breaker.state = "CLOSED";
+        breaker.openedAt = null;
+        logger.info("httpClient.breaker.closed", {
+          host
+        });
+      }
+      if (attempt < attempts && retryOn(response.status)) {
+        const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+        await sleep(jitter(delay));
+        continue;
+      }
+      return response;
+    } catch (err) {
+      lastErr = err;
+      breaker.failures += 1;
+      if (breaker.failures >= breakerThreshold) {
+        breaker.state = "OPEN";
+        breaker.openedAt = Date.now();
+        logger.warn("httpClient.breaker.open", {
+          host,
+          failures: breaker.failures
+        });
+      }
+      if (attempt >= attempts) break;
+      const delay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+      await sleep(jitter(delay));
+    }
+  }
+  logger.error("httpClient.exhausted", {
+    url: fullUrl,
+    attempts,
+    host
+  });
+  throw lastErr instanceof Error ? lastErr : new Error(`httpClient failed: ${String(lastErr)}`);
+}
+__name(httpClient, "httpClient");
+function createHttpClient(config = {}) {
+  return (url, init = {}) => httpClient(url, init, config);
+}
+__name(createHttpClient, "createHttpClient");
+
+// src/platform/leaderLock.ts
+var RELEASE_LUA = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`;
+var RENEW_LUA = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("pexpire", KEYS[1], ARGV[2])
+else
+  return 0
+end
+`;
+function leaderKey(name) {
+  return `besdk:leader:${name}`;
+}
+__name(leaderKey, "leaderKey");
+function generateToken() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}-${process.pid}`;
+}
+__name(generateToken, "generateToken");
+function defaultRenewMs(ttlMs) {
+  return Math.max(1e3, Math.floor(ttlMs / 3));
+}
+__name(defaultRenewMs, "defaultRenewMs");
+async function acquireLease(redis, key2, token, ttlMs) {
+  const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
+  return await redis.set(key2, token, "EX", ttlSeconds, "NX") === "OK";
+}
+__name(acquireLease, "acquireLease");
+async function renewLease(redis, key2, token, ttlMs) {
+  return await redis.eval(RENEW_LUA, 1, key2, token, String(ttlMs)) === 1;
+}
+__name(renewLease, "renewLease");
+async function releaseLease(redis, key2, token) {
+  await redis.eval(RELEASE_LUA, 1, key2, token);
+}
+__name(releaseLease, "releaseLease");
+function normalizeRedisUrl(url) {
+  if (url.startsWith("valkeys://")) return url.replace(/^valkeys:\/\//, "rediss://");
+  if (url.startsWith("valkey://")) return url.replace(/^valkey:\/\//, "redis://");
+  return url;
+}
+__name(normalizeRedisUrl, "normalizeRedisUrl");
+async function withLeaderLock(redis, name, fn, options) {
+  const key2 = leaderKey(name);
+  const token = generateToken();
+  const ttlMs = options.ttlMs;
+  const renewMs = options.renewMs ?? defaultRenewMs(ttlMs);
+  const acquired = await acquireLease(redis, key2, token, ttlMs);
+  if (!acquired) {
+    return {
+      acquired: false
+    };
+  }
+  logger.info("leaderLock.acquired", {
+    name,
+    token,
+    ttlMs
+  });
+  let stopped = false;
+  const renewTimer = setInterval(() => {
+    if (stopped) return;
+    renewLease(redis, key2, token, ttlMs).catch((err) => {
+      logger.warn("leaderLock.renew.failed", {
+        name,
+        err: String(err)
+      });
+    });
+  }, renewMs);
+  if (typeof renewTimer.unref === "function") {
+    renewTimer.unref();
+  }
+  try {
+    const result = await fn();
+    return {
+      acquired: true,
+      result
+    };
+  } finally {
+    stopped = true;
+    clearInterval(renewTimer);
+    try {
+      await releaseLease(redis, key2, token);
+      logger.info("leaderLock.released", {
+        name,
+        token
+      });
+    } catch (err) {
+      logger.warn("leaderLock.release.failed", {
+        name,
+        err: String(err)
+      });
+    }
+  }
+}
+__name(withLeaderLock, "withLeaderLock");
+function createLeaderLease(options) {
+  const { name, ttlMs, redis } = options;
+  const key2 = leaderKey(name);
+  const token = generateToken();
+  const renewMs = options.renewMs ?? defaultRenewMs(ttlMs);
+  let held = false;
+  let released = false;
+  let inFlight = null;
+  const acquireOrRenew = /* @__PURE__ */ __name(async () => {
+    if (released) return false;
+    try {
+      if (held) {
+        if (await renewLease(redis, key2, token, ttlMs)) {
+          return true;
+        }
+        held = false;
+      }
+      const acquired = await acquireLease(redis, key2, token, ttlMs);
+      if (acquired && !held) {
+        logger.info("leaderLease.acquired", {
+          name,
+          token,
+          ttlMs
+        });
+      }
+      held = acquired;
+      return held;
+    } catch (err) {
+      logger.warn("leaderLease.renew.failed", {
+        name,
+        err: String(err)
+      });
+      return held;
+    }
+  }, "acquireOrRenew");
+  const runAttempt = /* @__PURE__ */ __name(() => {
+    if (inFlight) return inFlight;
+    const attempt = acquireOrRenew().finally(() => {
+      if (inFlight === attempt) inFlight = null;
+    });
+    inFlight = attempt;
+    return attempt;
+  }, "runAttempt");
+  const timer = setInterval(() => {
+    if (released) return;
+    void runAttempt();
+  }, renewMs);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return {
+    renew() {
+      return runAttempt();
+    },
+    async release() {
+      if (released) return;
+      released = true;
+      clearInterval(timer);
+      if (inFlight) {
+        try {
+          await inFlight;
+        } catch {
+        }
+      }
+      if (!held) return;
+      held = false;
+      try {
+        await releaseLease(redis, key2, token);
+        logger.info("leaderLease.released", {
+          name,
+          token
+        });
+      } catch (err) {
+        logger.warn("leaderLease.release.failed", {
+          name,
+          err: String(err)
+        });
+      }
+    },
+    isHeld() {
+      return held && !released;
+    }
+  };
+}
+__name(createLeaderLease, "createLeaderLease");
+
+// src/platform/rateLimit.ts
+async function rateLimitIncr(redis, input) {
+  const fullKey = `besdk:rl:${input.key}`;
+  const count = await redis.incr(fullKey);
+  if (count === 1) {
+    await redis.pexpire(fullKey, input.windowMs);
+  }
+  let ttl = -1;
+  try {
+    ttl = await redis.pttl(fullKey);
+  } catch {
+    ttl = input.windowMs;
+  }
+  const resetAt = Date.now() + (ttl > 0 ? ttl : input.windowMs);
+  const remaining = Math.max(0, input.limit - count);
+  return {
+    allowed: count <= input.limit,
+    count,
+    remaining,
+    resetAt
+  };
+}
+__name(rateLimitIncr, "rateLimitIncr");
+
+// src/platform/paginator.ts
+var DEFAULT_GRAPHQL_PAGE_LIMIT = 50;
+var MAX_GRAPHQL_PAGE_LIMIT = 100;
+function clampLimit(input, opts = {}) {
+  const def = opts.defaultLimit ?? 50;
+  const max = opts.maxLimit ?? 200;
+  const min = opts.minLimit ?? 1;
+  if (input == null || Number.isNaN(input)) return def;
+  return Math.min(Math.max(Math.floor(input), min), max);
+}
+__name(clampLimit, "clampLimit");
+function clampOffset(input) {
+  if (input == null || Number.isNaN(input)) return 0;
+  return Math.max(0, Math.floor(input));
+}
+__name(clampOffset, "clampOffset");
+function clampGraphqlLimit(input, opts = {}) {
+  return clampLimit(input, {
+    defaultLimit: opts.defaultLimit ?? DEFAULT_GRAPHQL_PAGE_LIMIT,
+    maxLimit: opts.maxLimit ?? MAX_GRAPHQL_PAGE_LIMIT,
+    minLimit: opts.minLimit ?? 1
+  });
+}
+__name(clampGraphqlLimit, "clampGraphqlLimit");
+function normalizeOffsetPagination(input, opts = {}) {
+  return {
+    limit: clampGraphqlLimit(input?.limit, opts),
+    offset: clampOffset(input?.offset)
+  };
+}
+__name(normalizeOffsetPagination, "normalizeOffsetPagination");
+function normalizeCursorPagination(input, opts = {}) {
+  const first = clampGraphqlLimit(input?.first, opts);
+  const after = typeof input?.after === "string" && input.after.trim().length > 0 ? input.after : null;
+  return {
+    first,
+    after,
+    take: first + 1
+  };
+}
+__name(normalizeCursorPagination, "normalizeCursorPagination");
+function encodeCursor(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+__name(encodeCursor, "encodeCursor");
+function decodeCursor(cursor) {
+  if (typeof cursor !== "string" || cursor.trim().length === 0) return null;
+  try {
+    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (decoded == null || typeof decoded !== "object" || Array.isArray(decoded)) return null;
+    const payload = {};
+    for (const [key2, value] of Object.entries(decoded)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value == null) {
+        payload[key2] = value;
+      }
+    }
+    return Object.keys(payload).length > 0 ? payload : null;
+  } catch {
+    return null;
+  }
+}
+__name(decodeCursor, "decodeCursor");
+function buildConnection(items, opts) {
+  const nodes = items.length > opts.limit ? items.slice(0, opts.limit) : items;
+  const edges = nodes.map((node) => ({
+    node,
+    cursor: opts.cursorForNode(node)
+  }));
+  const firstEdge = edges[0];
+  const lastEdge = edges.at(-1);
+  return {
+    edges,
+    nodes,
+    pageInfo: {
+      hasNextPage: items.length > opts.limit,
+      hasPreviousPage: opts.hasPreviousPage ?? false,
+      startCursor: firstEdge?.cursor ?? null,
+      endCursor: lastEdge?.cursor ?? null
+    },
+    totalCount: opts.totalCount
+  };
+}
+__name(buildConnection, "buildConnection");
+function buildOffsetPage(items, total, pagination) {
+  const nextOffset = pagination.offset + items.length;
+  const hasMore = nextOffset < total;
+  return {
+    items,
+    total,
+    limit: pagination.limit,
+    offset: pagination.offset,
+    hasMore,
+    nextOffset: hasMore ? nextOffset : null
+  };
+}
+__name(buildOffsetPage, "buildOffsetPage");
+function toPrismaPage(pagination) {
+  return {
+    take: pagination.limit,
+    skip: pagination.offset
+  };
+}
+__name(toPrismaPage, "toPrismaPage");
+async function paginate(model2, input, opts = {}) {
+  const take = clampGraphqlLimit(input.take ?? void 0, opts);
+  const items = await model2.findMany({
+    take: take + 1,
+    skip: input.cursor ? 1 : 0,
+    cursor: input.cursor ? {
+      id: input.cursor
+    } : void 0,
+    where: input.where,
+    orderBy: input.orderBy
+  });
+  const hasMore = items.length > take;
+  const trimmed = hasMore ? items.slice(0, take) : items;
+  const nextCursor = hasMore && trimmed.length > 0 ? trimmed[trimmed.length - 1].id : null;
+  return {
+    items: trimmed,
+    hasMore,
+    nextCursor
+  };
+}
+__name(paginate, "paginate");
+
+// src/platform/dataLoaderFactory.ts
+function buildLoaders(ctx, builder) {
+  return builder(ctx);
+}
+__name(buildLoaders, "buildLoaders");
+function resolveReferenceLoader(loaderName, keyField = "id") {
+  return async (reference, ctx) => {
+    const loader = ctx.loaders[loaderName];
+    if (!loader) {
+      throw new Error(`resolveReferenceLoader: loader "${loaderName}" not found on ctx.loaders`);
+    }
+    const key2 = reference[keyField];
+    if (typeof key2 !== "string") {
+      return null;
+    }
+    return loader.load(key2);
+  };
+}
+__name(resolveReferenceLoader, "resolveReferenceLoader");
+
+// src/platform/cacheInvalidation.ts
+var VERSION_PREFIX = "besdk:cv:";
+async function getNamespaceVersion(redis, namespace) {
+  const v = await redis.get(`${VERSION_PREFIX}${namespace}`);
+  if (!v) return 1;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : 1;
+}
+__name(getNamespaceVersion, "getNamespaceVersion");
+async function buildCacheKey(redis, namespace, ...parts) {
+  const ver = await getNamespaceVersion(redis, namespace);
+  return `${namespace}:v${ver}:${parts.join(":")}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+async function invalidateNamespace(redis, namespace) {
+  return redis.incr(`${VERSION_PREFIX}${namespace}`);
+}
+__name(invalidateNamespace, "invalidateNamespace");
+
+// src/platform/pgPartition.ts
+function pad2(n) {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+__name(pad2, "pad2");
+function monthlyPartitionName(table, year, month) {
+  return `${table}_y${year}m${pad2(month)}`;
+}
+__name(monthlyPartitionName, "monthlyPartitionName");
+async function ensureMonthlyPartitions(prisma, opts) {
+  const created = [];
+  const cur = new Date(Date.UTC(opts.from.getUTCFullYear(), opts.from.getUTCMonth(), 1));
+  const end = new Date(Date.UTC(opts.to.getUTCFullYear(), opts.to.getUTCMonth(), 1));
+  while (cur <= end) {
+    const y = cur.getUTCFullYear();
+    const m = cur.getUTCMonth() + 1;
+    const next = new Date(Date.UTC(y, m, 1));
+    const partition = monthlyPartitionName(opts.table, y, m);
+    const lower = `${y}-${pad2(m)}-01`;
+    const upper = `${next.getUTCFullYear()}-${pad2(next.getUTCMonth() + 1)}-01`;
+    await prisma.$executeRawUnsafe(`CREATE TABLE IF NOT EXISTS "${partition}" PARTITION OF "${opts.table}" FOR VALUES FROM ('${lower}') TO ('${upper}');`);
+    created.push(partition);
+    cur.setUTCMonth(cur.getUTCMonth() + 1);
+  }
+  return created;
+}
+__name(ensureMonthlyPartitions, "ensureMonthlyPartitions");
+async function dropOldPartitions(prisma, opts) {
+  const rows = await prisma.$queryRawUnsafe(`SELECT child.relname AS partition_name
+     FROM pg_inherits
+     JOIN pg_class parent  ON pg_inherits.inhparent = parent.oid
+     JOIN pg_class child   ON pg_inherits.inhrelid  = child.oid
+     WHERE parent.relname = $1`, opts.table);
+  const dropped = [];
+  const cutoffYear = opts.beforeDate.getUTCFullYear();
+  const cutoffMonth = opts.beforeDate.getUTCMonth() + 1;
+  for (const row of rows) {
+    const partitionRe = /_y(\d{4})m(\d{2})$/;
+    const m = partitionRe.exec(row.partition_name);
+    if (!m) continue;
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    if (y < cutoffYear || y === cutoffYear && mo < cutoffMonth) {
+      await prisma.$executeRawUnsafe(`DROP TABLE IF EXISTS "${row.partition_name}";`);
+      dropped.push(row.partition_name);
+    }
+  }
+  return dropped;
+}
+__name(dropOldPartitions, "dropOldPartitions");
+
+// src/platform/llmClient.ts
+var DEFAULTS = {
+  timeoutMs: 3e4,
+  maxAttempts: 3,
+  initialDelayMs: 500,
+  maxOutputTokensCap: 4096
+};
+function jitter2(n) {
+  return Math.floor(Math.random() * n);
+}
+__name(jitter2, "jitter");
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+__name(sleep2, "sleep");
+var LLMRouter = class {
+  static {
+    __name(this, "LLMRouter");
+  }
+  adapters = /* @__PURE__ */ new Map();
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      ...DEFAULTS,
+      ...opts
+    };
+  }
+  register(adapter) {
+    this.adapters.set(adapter.name, adapter);
+  }
+  resolveChain() {
+    const envChain = process.env["LLM_PROVIDER_CHAIN"]?.trim();
+    if (envChain) {
+      return envChain.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    return Array.from(this.adapters.keys());
+  }
+  async complete(req) {
+    const cappedReq = {
+      ...req,
+      maxTokens: Math.min(req.maxTokens ?? this.opts.maxOutputTokensCap, this.opts.maxOutputTokensCap)
+    };
+    const chain = this.resolveChain();
+    if (chain.length === 0) {
+      throw new Error("LLMRouter: no providers registered");
+    }
+    let lastErr = null;
+    for (let attempt = 0; attempt < this.opts.maxAttempts; attempt++) {
+      const providerName = chain[attempt % chain.length];
+      const adapter = providerName ? this.adapters.get(providerName) : void 0;
+      if (!adapter) {
+        logger.warn("llmRouter.provider.notRegistered", {
+          providerName
+        });
+        continue;
+      }
+      const timeoutMs = req.timeoutMs ?? this.opts.timeoutMs;
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), timeoutMs);
+      try {
+        const response = await adapter.complete(cappedReq, ctrl.signal);
+        return response;
+      } catch (err) {
+        lastErr = err;
+        logger.warn("llmRouter.attempt.failed", {
+          provider: adapter.name,
+          attempt,
+          err: String(err)
+        });
+        if (attempt < this.opts.maxAttempts - 1) {
+          const delay = this.opts.initialDelayMs * 2 ** attempt;
+          await sleep2(jitter2(delay));
+        }
+      } finally {
+        clearTimeout(t);
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(`LLMRouter exhausted ${this.opts.maxAttempts} attempts`);
+  }
+};
+
+// src/platform/invocation-accounting/documents.ts
+var PROMPTS_V2_DOCUMENTS = Object.freeze({
+  begin: "mutation SdkBeginInvocationAttemptV2($input:PromptBeginInvocationAttemptV2Input!){promptBeginInvocationAttemptV2(input:$input){id workspaceId attemptKey operationKey productKey providerKey modelKey startedAt createdBy origin fingerprint createdAt revisions{id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt} hasMoreRevisions}}",
+  record: "mutation SdkRecordInvocationUsageV2($input:PromptRecordInvocationUsageV2Input!){promptRecordInvocationUsageV2(input:$input){id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt}}",
+  read: "query SdkInvocationAttemptV2($key:String!,$offset:Int){promptInvocationAttemptV2(attemptKey:$key,revisionOffset:$offset){id workspaceId attemptKey operationKey productKey providerKey modelKey startedAt createdBy origin fingerprint createdAt revisions{id attemptId revision predecessorId eventKey fingerprint outcome inputTokens outputTokens totalTokens cachedInputTokens costMicroUsd currency costKind pricingReference origin finishedAt createdAt} hasMoreRevisions}}",
+  summary: "query SdkUsageSummaryV2($from:DateTime!,$to:DateTime!,$product:String,$operation:String){promptUsageSummaryV2(from:$from,to:$to,productKey:$product,operationKey:$operation){workspaceId from to scope productKey operationKey origin currency costKind operations attempts pendingAttempts knownAttempts partialAttempts unknownAttempts inputTokens{knownSubtotal knownAttempts missingAttempts} outputTokens{knownSubtotal knownAttempts missingAttempts} totalTokens{knownSubtotal knownAttempts missingAttempts} costMicroUsd{knownSubtotal knownAttempts missingAttempts}}}"
+});
+
+// src/platform/invocation-accounting/contracts.ts
+var InvocationAccountingValidationError = class extends Error {
+  static {
+    __name(this, "InvocationAccountingValidationError");
+  }
+  constructor() {
+    super("Invalid invocation accounting contract");
+    this.name = "InvocationAccountingValidationError";
+  }
+};
+function requireContract(value) {
+  if (!value) throw new InvocationAccountingValidationError();
+}
+__name(requireContract, "requireContract");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function fields(value, names) {
+  requireContract(isRecord(value));
+  requireContract(Object.keys(value).length === names.length && names.every((name) => Object.hasOwn(value, name)));
+  return value;
+}
+__name(fields, "fields");
+function uuid(value) {
+  requireContract(typeof value === "string" && value === value.trim() && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value));
+  return value.toLowerCase();
+}
+__name(uuid, "uuid");
+function key(value, maximum = 128) {
+  requireContract(typeof value === "string" && value.length <= maximum && value === value.trim() && /^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/.test(value));
+  return value;
+}
+__name(key, "key");
+function date(value) {
+  requireContract(typeof value === "string" && value.length === 24);
+  const parsed = new Date(value);
+  requireContract(Number.isFinite(parsed.getTime()) && parsed.getUTCFullYear() >= 1 && value === parsed.toISOString());
+  return value;
+}
+__name(date, "date");
+function fingerprint(value) {
+  requireContract(typeof value === "string" && value.length === 64 && /^[0-9a-f]+$/.test(value));
+  return value;
+}
+__name(fingerprint, "fingerprint");
+function decimal(value, maximumDigits = 19) {
+  requireContract(typeof value === "string" && value.length <= maximumDigits && value === value.trim() && /^(?:0|[1-9]\d*)$/.test(value));
+  return value;
+}
+__name(decimal, "decimal");
+function nullableCounter(value) {
+  if (value === null) return null;
+  const text = decimal(value);
+  requireContract(BigInt(text) <= 9223372036854775807n);
+  return text;
+}
+__name(nullableCounter, "nullableCounter");
+function validateInvocationIdentity(value) {
+  const row = fields(value, [
+    "workspaceId",
+    "actorId",
+    "actorType",
+    "onBehalfOf"
+  ]);
+  const actorType = row["actorType"];
+  requireContract(actorType === "user" || actorType === "app" || actorType === "service" || actorType === "super_admin");
+  return Object.freeze({
+    workspaceId: uuid(row["workspaceId"]),
+    actorId: uuid(row["actorId"]),
+    actorType,
+    onBehalfOf: row["onBehalfOf"] === null ? null : uuid(row["onBehalfOf"])
+  });
+}
+__name(validateInvocationIdentity, "validateInvocationIdentity");
+function sameIdentity(a, b) {
+  return a.workspaceId === b.workspaceId && a.actorId === b.actorId && a.actorType === b.actorType && a.onBehalfOf === b.onBehalfOf;
+}
+__name(sameIdentity, "sameIdentity");
+function validateInvocationAttemptInput(value) {
+  const row = fields(value, [
+    "attemptKey",
+    "operationKey",
+    "productKey",
+    "providerKey",
+    "modelKey",
+    "startedAt"
+  ]);
+  const modelKey = row["modelKey"];
+  requireContract(typeof modelKey === "string" && modelKey.length <= 128 && modelKey.split("/").every((segment) => {
+    key(segment);
+    return true;
+  }));
+  const product = key(row["productKey"], 64);
+  return Object.freeze({
+    attemptKey: key(row["attemptKey"]),
+    operationKey: key(row["operationKey"]),
+    productKey: productSlugVariants(product).length > 1 ? emitProductSlug(product) : product,
+    providerKey: key(row["providerKey"], 64),
+    modelKey,
+    startedAt: date(row["startedAt"])
+  });
+}
+__name(validateInvocationAttemptInput, "validateInvocationAttemptInput");
+function validateInvocationUsageInput(value) {
+  const row = fields(value, [
+    "attemptKey",
+    "eventKey",
+    "revision",
+    "predecessorId",
+    "outcome",
+    "inputTokens",
+    "outputTokens",
+    "cachedInputTokens",
+    "costMicroUsd",
+    "finishedAt"
+  ]);
+  const revision = row["revision"];
+  const outcome = row["outcome"];
+  requireContract(typeof revision === "number" && Number.isInteger(revision) && revision >= 1 && revision <= 2147483647);
+  requireContract(outcome === "succeeded" || outcome === "failed" || outcome === "blocked" || outcome === "timed_out");
+  const predecessorId = row["predecessorId"] === null ? null : uuid(row["predecessorId"]);
+  requireContract(revision === 1 === (predecessorId === null) && row["costMicroUsd"] === null);
+  const inputTokens = nullableCounter(row["inputTokens"]);
+  const outputTokens = nullableCounter(row["outputTokens"]);
+  const cachedInputTokens = nullableCounter(row["cachedInputTokens"]);
+  requireContract(cachedInputTokens === null || inputTokens !== null && BigInt(cachedInputTokens) <= BigInt(inputTokens));
+  return Object.freeze({
+    attemptKey: key(row["attemptKey"]),
+    eventKey: key(row["eventKey"]),
+    revision,
+    predecessorId,
+    outcome,
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    costMicroUsd: null,
+    finishedAt: date(row["finishedAt"])
+  });
+}
+__name(validateInvocationUsageInput, "validateInvocationUsageInput");
+var usageFields = [
+  "id",
+  "attemptId",
+  "revision",
+  "predecessorId",
+  "eventKey",
+  "fingerprint",
+  "outcome",
+  "inputTokens",
+  "outputTokens",
+  "totalTokens",
+  "cachedInputTokens",
+  "costMicroUsd",
+  "currency",
+  "costKind",
+  "pricingReference",
+  "origin",
+  "finishedAt",
+  "createdAt"
+];
+function historyReceipt(value, attemptKey, attemptId) {
+  const row = fields(value, usageFields);
+  const input = validateInvocationUsageInput({
+    attemptKey,
+    eventKey: row["eventKey"],
+    revision: row["revision"],
+    predecessorId: row["predecessorId"],
+    outcome: row["outcome"],
+    inputTokens: row["inputTokens"],
+    outputTokens: row["outputTokens"],
+    cachedInputTokens: row["cachedInputTokens"],
+    costMicroUsd: null,
+    finishedAt: row["finishedAt"]
+  });
+  const costMicroUsd = nullableCounter(row["costMicroUsd"]);
+  const pricingReference = row["pricingReference"] === null ? null : key(row["pricingReference"], 255);
+  requireContract(costMicroUsd === null || pricingReference !== null);
+  const totalTokens = input.inputTokens === null || input.outputTokens === null ? null : (BigInt(input.inputTokens) + BigInt(input.outputTokens)).toString();
+  requireContract(row["totalTokens"] === totalTokens && row["attemptId"] === attemptId && row["origin"] === "CALLER_REPORTED" && row["currency"] === "USD" && row["costKind"] === "ESTIMATE");
+  return Object.freeze({
+    id: uuid(row["id"]),
+    attemptId,
+    revision: input.revision,
+    predecessorId: input.predecessorId,
+    eventKey: input.eventKey,
+    fingerprint: fingerprint(row["fingerprint"]),
+    outcome: input.outcome,
+    inputTokens: input.inputTokens,
+    outputTokens: input.outputTokens,
+    totalTokens,
+    cachedInputTokens: input.cachedInputTokens,
+    costMicroUsd,
+    currency: "USD",
+    costKind: "ESTIMATE",
+    pricingReference,
+    origin: "CALLER_REPORTED",
+    finishedAt: input.finishedAt,
+    createdAt: date(row["createdAt"])
+  });
+}
+__name(historyReceipt, "historyReceipt");
+function validateInvocationUsageReceipt(value, expected, attemptId) {
+  const input = validateInvocationUsageInput(expected);
+  const known = historyReceipt(value, input.attemptKey, uuid(attemptId));
+  requireContract(known.pricingReference === null);
+  for (const [field, actual] of Object.entries(known)) {
+    const entry = Object.entries(input).find(([name]) => name === field);
+    if (entry !== void 0) requireContract(entry[1] === actual);
+  }
+  return known;
+}
+__name(validateInvocationUsageReceipt, "validateInvocationUsageReceipt");
+function sameValues(a, b) {
+  const left = Object.entries(a);
+  const right = Object.entries(b);
+  return left.length === right.length && left.every(([name, value]) => right.some(([other, item]) => other === name && item === value));
+}
+__name(sameValues, "sameValues");
+function envelope(value, field) {
+  requireContract(isRecord(value));
+  requireContract(value["errors"] === void 0 || Array.isArray(value["errors"]) && value["errors"].length === 0);
+  const data = fields(value["data"], [
+    field
+  ]);
+  return data[field];
+}
+__name(envelope, "envelope");
+function validateInvocationAttemptReceipt(value, expected, identity) {
+  const context = validateInvocationIdentity(identity);
+  const selected = validateInvocationAttemptInput(expected);
+  const row = fields(value, [
+    "id",
+    "workspaceId",
+    "attemptKey",
+    "operationKey",
+    "productKey",
+    "providerKey",
+    "modelKey",
+    "startedAt",
+    "createdBy",
+    "origin",
+    "fingerprint",
+    "createdAt",
+    "revisions",
+    "hasMoreRevisions"
+  ]);
+  const input = validateInvocationAttemptInput({
+    attemptKey: row["attemptKey"],
+    operationKey: row["operationKey"],
+    productKey: row["productKey"],
+    providerKey: row["providerKey"],
+    modelKey: row["modelKey"],
+    startedAt: row["startedAt"]
+  });
+  requireContract(sameValues(input, selected) && row["workspaceId"] === context.workspaceId && row["createdBy"] === context.actorId && row["origin"] === "CALLER_REPORTED");
+  requireContract(Array.isArray(row["revisions"]) && row["revisions"].length <= 50 && typeof row["hasMoreRevisions"] === "boolean");
+  const entries = row["revisions"];
+  const id = uuid(row["id"]);
+  const revisions = entries.map((entry) => historyReceipt(entry, selected.attemptKey, id));
+  requireContract(new Set(revisions.map((revision) => revision.id)).size === revisions.length);
+  requireContract(new Set(revisions.map((revision) => revision.eventKey)).size === revisions.length);
+  requireContract(revisions.every((revision, index) => index === 0 || revision.revision < (revisions[index - 1]?.revision ?? 0)));
+  return Object.freeze({
+    ...input,
+    id,
+    workspaceId: context.workspaceId,
+    createdBy: context.actorId,
+    origin: "CALLER_REPORTED",
+    fingerprint: fingerprint(row["fingerprint"]),
+    createdAt: date(row["createdAt"]),
+    revisions: Object.freeze(revisions),
+    hasMoreRevisions: row["hasMoreRevisions"]
+  });
+}
+__name(validateInvocationAttemptReceipt, "validateInvocationAttemptReceipt");
+
+// src/platform/invocation-accounting/coordinator.ts
+function parseIntent(value) {
+  requireContract(isRecord(value));
+  const kind = value["kind"];
+  const row = fields(value, kind === "begin" ? [
+    "kind",
+    "identity",
+    "key",
+    "input"
+  ] : [
+    "kind",
+    "identity",
+    "key",
+    "input",
+    "attempt",
+    "attemptId"
+  ]);
+  const identity = validateInvocationIdentity(row["identity"]);
+  const key2 = uuid(row["key"]);
+  if (kind === "begin") return Object.freeze({
+    kind,
+    identity,
+    key: key2,
+    input: validateInvocationAttemptInput(row["input"])
+  });
+  requireContract(kind === "record");
+  const input = validateInvocationUsageInput(row["input"]);
+  const attempt = validateInvocationAttemptInput(row["attempt"]);
+  requireContract(input.attemptKey === attempt.attemptKey && input.finishedAt >= attempt.startedAt);
+  return Object.freeze({
+    kind,
+    identity,
+    key: key2,
+    input,
+    attempt,
+    attemptId: uuid(row["attemptId"])
+  });
+}
+__name(parseIntent, "parseIntent");
+function receipt(value, intent) {
+  return intent.kind === "begin" ? validateInvocationAttemptReceipt(value, intent.input, intent.identity) : validateInvocationUsageReceipt(value, intent.input, intent.attemptId);
+}
+__name(receipt, "receipt");
+function validateInvocationDelivery(value) {
+  const row = fields(value, [
+    "intent",
+    "version",
+    "state",
+    "receipt",
+    "observedIds"
+  ]);
+  const intent = parseIntent(row["intent"]);
+  const version = row["version"];
+  const state = row["state"];
+  requireContract(typeof version === "number" && Number.isSafeInteger(version) && version >= 0);
+  requireContract(state === "UNSENT" || state === "DISPATCHED" || state === "UNKNOWN" || state === "ACKNOWLEDGED");
+  requireContract(Array.isArray(row["observedIds"]) && row["observedIds"].length <= 3);
+  const values = row["observedIds"];
+  const observedIds = Object.freeze(values.map(uuid));
+  requireContract(new Set(observedIds).size === observedIds.length);
+  const known = row["receipt"] === null ? null : receipt(row["receipt"], intent);
+  requireContract(state === "ACKNOWLEDGED" === (known !== null));
+  requireContract(known === null || observedIds.every((id) => ids(known).includes(id)));
+  return Object.freeze({
+    intent,
+    version,
+    state,
+    receipt: known,
+    observedIds
+  });
+}
+__name(validateInvocationDelivery, "validateInvocationDelivery");
+function sameIntent(a, b) {
+  return a.kind === b.kind && a.key === b.key && sameIdentity(a.identity, b.identity) && sameValues(a.input, b.input) && (a.kind !== "record" || b.kind === "record" && a.attemptId === b.attemptId && sameValues(a.attempt, b.attempt));
+}
+__name(sameIntent, "sameIntent");
+function ids(value) {
+  if (!isRecord(value)) return [];
+  const found = [];
+  for (const name of [
+    "id",
+    "attemptId",
+    "predecessorId"
+  ]) {
+    try {
+      const id = uuid(value[name]);
+      if (!found.includes(id)) found.push(id);
+    } catch {
+    }
+  }
+  return Object.freeze(found);
+}
+__name(ids, "ids");
+var hold = /* @__PURE__ */ __name((reason, observedIds = [], knownReceipt) => knownReceipt ? {
+  status: "HOLD",
+  reason,
+  observedIds,
+  knownReceipt
+} : {
+  status: "HOLD",
+  reason,
+  observedIds
+}, "hold");
+var InvocationAccountingCoordinator = class {
+  static {
+    __name(this, "InvocationAccountingCoordinator");
+  }
+  options;
+  now;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  async admitted(identity) {
+    try {
+      const admission = await this.options.admit();
+      const now = this.now();
+      return admission !== null && sameIdentity(validateInvocationIdentity(admission.identity), identity) && Number.isFinite(admission.expiresAt) && Number.isFinite(now) && now < admission.expiresAt;
+    } catch {
+      return false;
+    }
+  }
+  async load(identity, key2) {
+    const row = await this.options.store.load(identity, key2);
+    if (row === null) return null;
+    const parsed = validateInvocationDelivery(row);
+    requireContract(parsed.intent.key === key2 && sameIdentity(parsed.intent.identity, identity));
+    return parsed;
+  }
+  async unknown(previous, observedIds) {
+    try {
+      await this.options.store.compareAndSet(previous, Object.freeze({
+        ...previous,
+        version: previous.version + 1,
+        state: "UNKNOWN",
+        observedIds
+      }));
+    } catch {
+    }
+  }
+  async acknowledge(previous, known, observedIds) {
+    if (!previous.observedIds.every((id) => ids(known).includes(id))) return hold("RECEIPT", observedIds, known);
+    try {
+      const saved = await this.options.store.compareAndSet(previous, Object.freeze({
+        ...previous,
+        version: previous.version + 1,
+        state: "ACKNOWLEDGED",
+        receipt: known,
+        observedIds
+      }));
+      if (!saved) return hold("STORE", observedIds, known);
+    } catch {
+      return hold("STORE", observedIds, known);
+    }
+    if (!await this.admitted(previous.intent.identity)) return hold("CONTEXT", observedIds, known);
+    return {
+      status: "ACKNOWLEDGED",
+      receipt: known,
+      observedIds
+    };
+  }
+  async deliver(intent) {
+    if (!await this.admitted(intent.identity)) return hold("CONTEXT");
+    let previous;
+    try {
+      let existing = await this.load(intent.identity, intent.key);
+      if (existing === null) {
+        const initial = Object.freeze({
+          intent,
+          version: 0,
+          state: "UNSENT",
+          receipt: null,
+          observedIds: Object.freeze([])
+        });
+        await this.options.store.create(initial);
+        existing = await this.load(intent.identity, intent.key);
+      }
+      if (existing === null) return hold("STORE");
+      if (!sameIntent(existing.intent, intent)) return hold("OCCUPIED", existing.observedIds);
+      if (existing.state === "ACKNOWLEDGED" && existing.receipt !== null) {
+        return await this.admitted(intent.identity) ? {
+          status: "ACKNOWLEDGED",
+          receipt: existing.receipt,
+          observedIds: existing.observedIds
+        } : hold("CONTEXT", existing.observedIds);
+      }
+      if (existing.state !== "UNSENT") return hold("UNKNOWN", existing.observedIds);
+      previous = Object.freeze({
+        ...existing,
+        version: existing.version + 1,
+        state: "DISPATCHED"
+      });
+      if (!await this.options.store.compareAndSet(existing, previous)) return hold("OCCUPIED", existing.observedIds);
+    } catch {
+      return hold("STORE");
+    }
+    if (!await this.admitted(intent.identity)) {
+      await this.unknown(previous, []);
+      return hold("CONTEXT");
+    }
+    let raw;
+    try {
+      raw = await this.options.transport(PROMPTS_V2_DOCUMENTS[intent.kind], Object.freeze({
+        input: intent.input
+      }));
+    } catch {
+      await this.unknown(previous, []);
+      return hold("UNKNOWN");
+    }
+    const field = intent.kind === "begin" ? "promptBeginInvocationAttemptV2" : "promptRecordInvocationUsageV2";
+    const data = isRecord(raw) && isRecord(raw["data"]) ? raw["data"][field] : null;
+    const observedIds = ids(data);
+    let known;
+    try {
+      known = receipt(envelope(raw, field), intent);
+    } catch {
+      await this.unknown(previous, observedIds);
+      return hold("RECEIPT", observedIds);
+    }
+    return this.acknowledge(previous, known, observedIds);
+  }
+  async begin(identity, key2, input) {
+    return this.deliver(parseIntent({
+      kind: "begin",
+      identity,
+      key: key2,
+      input
+    }));
+  }
+  async record(identity, key2, beginKey, input, predecessorKey = null) {
+    const context = validateInvocationIdentity(identity);
+    const observation = validateInvocationUsageInput(input);
+    if (!await this.admitted(context)) return hold("CONTEXT");
+    try {
+      const begin = await this.load(context, uuid(beginKey));
+      if (begin?.state !== "ACKNOWLEDGED" || begin.intent.kind !== "begin") return hold("UNKNOWN");
+      const attempt = validateInvocationAttemptReceipt(begin.receipt, begin.intent.input, context);
+      if (observation.revision > 1) {
+        const previous = predecessorKey === null ? null : await this.load(context, uuid(predecessorKey));
+        if (previous?.state !== "ACKNOWLEDGED" || previous.intent.kind !== "record" || previous.intent.attemptId !== attempt.id) return hold("UNKNOWN");
+        const known = validateInvocationUsageReceipt(previous.receipt, previous.intent.input, attempt.id);
+        if (observation.predecessorId !== known.id || observation.revision !== known.revision + 1 || observation.eventKey === known.eventKey) return hold("RECEIPT");
+      } else if (predecessorKey !== null) return hold("RECEIPT");
+      return await this.deliver(parseIntent({
+        kind: "record",
+        identity: context,
+        key: key2,
+        input: observation,
+        attempt: begin.intent.input,
+        attemptId: attempt.id
+      }));
+    } catch {
+      return hold("STORE");
+    }
+  }
+  /** Explicit read-only reconciliation; no mutation retransmit, no absence proof. At most four pages. */
+  async reconcile(identity, key2) {
+    const context = validateInvocationIdentity(identity);
+    if (!await this.admitted(context)) return hold("CONTEXT");
+    let previous;
+    try {
+      const existing = await this.load(context, uuid(key2));
+      if (existing === null) return hold("UNKNOWN");
+      previous = existing;
+    } catch {
+      return hold("STORE");
+    }
+    if (!await this.admitted(context)) return hold("CONTEXT", previous.observedIds);
+    if (previous.state === "ACKNOWLEDGED" && previous.receipt !== null) return {
+      status: "ACKNOWLEDGED",
+      receipt: previous.receipt,
+      observedIds: previous.observedIds
+    };
+    if (previous.state === "UNSENT") return hold("UNKNOWN");
+    const intent = previous.intent;
+    if (intent.kind === "begin") return hold("HISTORY", previous.observedIds);
+    const expected = intent.attempt;
+    for (let page = 0; page < 4; page++) {
+      if (!await this.admitted(context)) return hold("CONTEXT", previous.observedIds);
+      try {
+        const response = await this.options.transport(PROMPTS_V2_DOCUMENTS.read, {
+          key: expected.attemptKey,
+          offset: page * 50
+        });
+        const row = envelope(response, "promptInvocationAttemptV2");
+        if (row === null) return hold("HISTORY", previous.observedIds);
+        const attempt = validateInvocationAttemptReceipt(row, expected, context);
+        const matches = attempt.revisions.filter((revision) => revision.eventKey === intent.input.eventKey);
+        const match = matches[0];
+        if (matches.length === 1 && match !== void 0) {
+          const known = validateInvocationUsageReceipt(match, intent.input, intent.attemptId);
+          return await this.acknowledge(previous, known, ids(known));
+        }
+        if (matches.length > 1 || !attempt.hasMoreRevisions) return hold("HISTORY", previous.observedIds);
+      } catch {
+        return hold("HISTORY", previous.observedIds);
+      }
+    }
+    return hold("HISTORY", previous.observedIds);
+  }
+};
+
+// src/platform/invocation-accounting/normalizers.ts
+var MAX_COUNTER = 9223372036854775807n;
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function object(value) {
+  return isObject(value) ? value : {};
+}
+__name(object, "object");
+function counter(value, issue, issues) {
+  if (value == null) return null;
+  const text = typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? String(value) : value;
+  if (typeof text !== "string" || text.length > 19 || !/^(?:0|[1-9]\d*)$/.test(text) || text !== text.trim() || BigInt(text) > MAX_COUNTER) {
+    issues.push(issue);
+    return null;
+  }
+  return text;
+}
+__name(counter, "counter");
+function model(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 255 && value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value) ? value : null;
+}
+__name(model, "model");
+function normalizeOpenAIUsage(response) {
+  const row = object(response);
+  const usage = object(row["usage"]);
+  const issues = [];
+  const inputTokens = counter(usage["prompt_tokens"], "INPUT", issues);
+  const outputTokens = counter(usage["completion_tokens"], "OUTPUT", issues);
+  let cachedInputTokens = counter(object(usage["prompt_tokens_details"])["cached_tokens"], "CACHE_READ", issues);
+  if (cachedInputTokens !== null && (inputTokens === null || BigInt(cachedInputTokens) > BigInt(inputTokens))) {
+    issues.push("CACHE_SUBSET");
+    cachedInputTokens = null;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    costMicroUsd: null,
+    reportedModel: model(row["model"]),
+    issues
+  };
+}
+__name(normalizeOpenAIUsage, "normalizeOpenAIUsage");
+function normalizeClaudeUsage(response) {
+  const row = object(response);
+  const usage = object(row["usage"]);
+  const issues = [];
+  const uncachedInputTokens = counter(usage["input_tokens"], "INPUT", issues);
+  const outputTokens = counter(usage["output_tokens"], "OUTPUT", issues);
+  const cacheCreationInputTokens = counter(usage["cache_creation_input_tokens"], "CACHE_WRITE", issues);
+  const cacheReadInputTokens = counter(usage["cache_read_input_tokens"], "CACHE_READ", issues);
+  let inputTokens = null;
+  if (uncachedInputTokens !== null && cacheCreationInputTokens !== null && cacheReadInputTokens !== null) {
+    const total = BigInt(uncachedInputTokens) + BigInt(cacheCreationInputTokens) + BigInt(cacheReadInputTokens);
+    if (total <= MAX_COUNTER) inputTokens = total.toString();
+    else issues.push("INPUT_OVERFLOW");
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens: inputTokens === null ? null : cacheReadInputTokens,
+    costMicroUsd: null,
+    reportedModel: model(row["model"]),
+    issues,
+    uncachedInputTokens,
+    cacheCreationInputTokens,
+    cacheReadInputTokens
+  };
+}
+__name(normalizeClaudeUsage, "normalizeClaudeUsage");
+function createClaudeUsageAccumulator() {
+  let usage = {};
+  let reportedModel;
+  const highest = /* @__PURE__ */ new Map();
+  const regressed = /* @__PURE__ */ new Set();
+  return (snapshot) => {
+    const row = object(snapshot);
+    const incoming = object(row["usage"]);
+    for (const key2 of [
+      "input_tokens",
+      "output_tokens",
+      "cache_creation_input_tokens",
+      "cache_read_input_tokens"
+    ]) {
+      if (Object.hasOwn(incoming, key2)) {
+        const parsed = counter(incoming[key2], "INPUT", []);
+        const previous = highest.get(key2);
+        if (parsed !== null && previous !== void 0 && BigInt(parsed) < previous) {
+          usage = {
+            ...usage,
+            [key2]: null
+          };
+          regressed.add(key2);
+        } else {
+          usage = {
+            ...usage,
+            [key2]: incoming[key2]
+          };
+          if (parsed !== null) {
+            highest.set(key2, BigInt(parsed));
+            regressed.delete(key2);
+          }
+        }
+      }
+    }
+    if (Object.hasOwn(row, "model")) reportedModel = row["model"];
+    const result = normalizeClaudeUsage({
+      model: reportedModel,
+      usage
+    });
+    return regressed.size === 0 ? result : {
+      ...result,
+      issues: [
+        ...result.issues,
+        "CUMULATIVE_REGRESSION"
+      ]
+    };
+  };
+}
+__name(createClaudeUsageAccumulator, "createClaudeUsageAccumulator");
+
+// src/platform/invocation-accounting/summary.ts
+function canonicalProduct(value) {
+  if (value === null) return null;
+  const product = key(value, 64);
+  return productSlugVariants(product).length > 1 ? emitProductSlug(product) : product;
+}
+__name(canonicalProduct, "canonicalProduct");
+function validateInvocationUsageSummary(value, selection) {
+  const row = fields(value, [
+    "workspaceId",
+    "from",
+    "to",
+    "productKey",
+    "operationKey",
+    "scope",
+    "origin",
+    "currency",
+    "costKind",
+    "attempts",
+    "operations",
+    "pendingAttempts",
+    "knownAttempts",
+    "partialAttempts",
+    "unknownAttempts",
+    "inputTokens",
+    "outputTokens",
+    "totalTokens",
+    "costMicroUsd"
+  ]);
+  const workspaceId = uuid(selection.workspaceId);
+  const from = date(selection.from), to = date(selection.to);
+  requireContract(from < to && new Date(to).getTime() - new Date(from).getTime() <= 366 * 864e5);
+  const productKey = canonicalProduct(selection.productKey);
+  requireContract(canonicalProduct(row["productKey"]) === productKey);
+  const operationKey = selection.operationKey === null ? null : key(selection.operationKey);
+  for (const [name, expected] of Object.entries({
+    workspaceId,
+    from,
+    to,
+    operationKey,
+    scope: "RECORDED_V2_ATTEMPTS",
+    origin: "CALLER_REPORTED",
+    currency: "USD",
+    costKind: "ESTIMATE"
+  })) requireContract(row[name] === expected);
+  const attempts = decimal(row["attempts"]), operations = decimal(row["operations"]);
+  const pendingAttempts = decimal(row["pendingAttempts"]), knownAttempts = decimal(row["knownAttempts"]);
+  const partialAttempts = decimal(row["partialAttempts"]), unknownAttempts = decimal(row["unknownAttempts"]);
+  requireContract(BigInt(operations) <= BigInt(attempts) && BigInt(pendingAttempts) <= BigInt(unknownAttempts) && BigInt(knownAttempts) + BigInt(partialAttempts) + BigInt(unknownAttempts) === BigInt(attempts));
+  const component = /* @__PURE__ */ __name((value2) => {
+    const item = fields(value2, [
+      "knownSubtotal",
+      "knownAttempts",
+      "missingAttempts"
+    ]);
+    const known = decimal(item["knownAttempts"]), missing = decimal(item["missingAttempts"]);
+    const subtotal = item["knownSubtotal"] === null ? null : decimal(item["knownSubtotal"], 255);
+    requireContract(BigInt(known) + BigInt(missing) === BigInt(attempts) && known === "0" === (subtotal === null));
+    return Object.freeze({
+      knownSubtotal: subtotal,
+      knownAttempts: known,
+      missingAttempts: missing
+    });
+  }, "component");
+  return Object.freeze({
+    workspaceId,
+    from,
+    to,
+    productKey,
+    operationKey,
+    scope: "RECORDED_V2_ATTEMPTS",
+    origin: "CALLER_REPORTED",
+    currency: "USD",
+    costKind: "ESTIMATE",
+    attempts,
+    operations,
+    pendingAttempts,
+    knownAttempts,
+    partialAttempts,
+    unknownAttempts,
+    inputTokens: component(row["inputTokens"]),
+    outputTokens: component(row["outputTokens"]),
+    totalTokens: component(row["totalTokens"]),
+    costMicroUsd: component(row["costMicroUsd"])
+  });
+}
+__name(validateInvocationUsageSummary, "validateInvocationUsageSummary");
+
+export { CircuitBreakerOpenError, DEFAULT_GRAPHQL_PAGE_LIMIT, InvocationAccountingCoordinator, InvocationAccountingValidationError, LLMRouter, MAX_GRAPHQL_PAGE_LIMIT, PROMPTS_V2_DOCUMENTS, __resetHttpClientBreakers, buildCacheKey, buildConnection, buildLoaders, buildOffsetPage, clampGraphqlLimit, clampLimit, clampOffset, createClaudeUsageAccumulator, createHttpClient, createLeaderLease, decodeCursor, dropOldPartitions, encodeCursor, ensureMonthlyPartitions, getNamespaceVersion, httpClient, invalidateNamespace, monthlyPartitionName, normalizeClaudeUsage, normalizeCursorPagination, normalizeOffsetPagination, normalizeOpenAIUsage, normalizeRedisUrl, paginate, platform_exports, rateLimitIncr, resolveReferenceLoader, toPrismaPage, validateInvocationAttemptInput, validateInvocationAttemptReceipt, validateInvocationDelivery, validateInvocationIdentity, validateInvocationUsageInput, validateInvocationUsageReceipt, validateInvocationUsageSummary, withLeaderLock };
+//# sourceMappingURL=chunk-N2UT3ESH.js.map
+//# sourceMappingURL=chunk-N2UT3ESH.js.map