@bymax-one/nest-ai-tokens 1.0.0

package/dist/shared/index.cjs

@@ -0,0 +1,659 @@
+'use strict';
+
+// src/shared/constants/provider-ids.constants.ts
+var PROVIDER_IDS = [
+  "openai",
+  "azure-openai",
+  "anthropic",
+  "gemini",
+  "vertex",
+  "mistral",
+  "bedrock",
+  "openrouter",
+  "deepseek",
+  "xai",
+  "groq"
+];
+
+// src/shared/constants/operations.constants.ts
+var AI_OPERATIONS = [
+  "chat",
+  "responses",
+  "embeddings",
+  "image",
+  "video",
+  "audio",
+  "rerank",
+  "moderation"
+];
+
+// src/shared/constants/service-tiers.constants.ts
+var SERVICE_TIERS = ["standard", "batch", "flex", "priority"];
+
+// src/shared/constants/token-categories.constants.ts
+var TOKEN_CATEGORIES = [
+  "input",
+  "output",
+  "cacheRead",
+  "cacheWrite5m",
+  "cacheWrite1h",
+  "reasoning",
+  "audioIn",
+  "audioOut",
+  "imageIn",
+  "imageOut"
+];
+
+// src/shared/constants/wallet-entry-types.constants.ts
+var WALLET_ENTRY_TYPES = ["grant", "debit", "refund", "adjustment", "expiry"];
+
+// src/shared/constants/error-codes.constants.ts
+var AI_TOKENS_ERROR_CODES = {
+  AI_TOKENS_NOT_CONFIGURED: "AI_TOKENS_NOT_CONFIGURED",
+  AI_TOKENS_INVALID_CONFIG: "AI_TOKENS_INVALID_CONFIG",
+  AI_TOKENS_UNKNOWN_PROVIDER: "AI_TOKENS_UNKNOWN_PROVIDER",
+  AI_TOKENS_USAGE_MALFORMED: "AI_TOKENS_USAGE_MALFORMED",
+  AI_TOKENS_PRICE_NOT_FOUND: "AI_TOKENS_PRICE_NOT_FOUND",
+  AI_TOKENS_FX_REQUIRED: "AI_TOKENS_FX_REQUIRED",
+  AI_TOKENS_BUDGET_EXCEEDED: "AI_TOKENS_BUDGET_EXCEEDED",
+  AI_TOKENS_QUOTA_EXCEEDED: "AI_TOKENS_QUOTA_EXCEEDED",
+  AI_TOKENS_INSUFFICIENT_CREDITS: "AI_TOKENS_INSUFFICIENT_CREDITS",
+  AI_TOKENS_HOLD_NOT_FOUND: "AI_TOKENS_HOLD_NOT_FOUND",
+  AI_TOKENS_HOLD_EXPIRED: "AI_TOKENS_HOLD_EXPIRED",
+  AI_TOKENS_HOLD_ALREADY_SETTLED: "AI_TOKENS_HOLD_ALREADY_SETTLED",
+  AI_TOKENS_IDEMPOTENCY_CONFLICT: "AI_TOKENS_IDEMPOTENCY_CONFLICT",
+  AI_TOKENS_STREAM_USAGE_MISSING: "AI_TOKENS_STREAM_USAGE_MISSING",
+  AI_TOKENS_STORE_ERROR: "AI_TOKENS_STORE_ERROR"
+};
+
+// 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 isLegalLedgerTransition(from, to) {
+  if (from === "pending") return to === "posted" || to === "released";
+  return from === "posted" && to === "reversed";
+}
+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/normalizers/usage-fields.ts
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function requireNum(value, provider, field) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  throw new Error(`${provider}: missing or invalid numeric field "${field}"`);
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function knownServiceTier(value) {
+  const candidate = str(value);
+  return candidate !== void 0 && SERVICE_TIERS.includes(candidate) ? candidate : void 0;
+}
+function openAiServiceTier(value) {
+  const candidate = str(value);
+  return knownServiceTier(candidate === "default" ? "standard" : candidate);
+}
+function toolUseCounts(value) {
+  const source = asObject(value);
+  if (source === void 0) return void 0;
+  const counts = {};
+  for (const [key, raw] of Object.entries(source)) {
+    if (typeof raw === "number" && Number.isFinite(raw)) counts[key] = raw;
+  }
+  return Object.keys(counts).length > 0 ? counts : void 0;
+}
+function buildUsage(draft) {
+  const usage = {
+    provider: draft.provider,
+    model: draft.model,
+    operation: draft.operation,
+    inputTokens: draft.inputTokens,
+    outputTokens: draft.outputTokens,
+    cacheReadTokens: draft.cacheReadTokens ?? 0,
+    cacheWrite5mTokens: draft.cacheWrite5mTokens ?? 0,
+    cacheWrite1hTokens: draft.cacheWrite1hTokens ?? 0,
+    reasoningTokens: draft.reasoningTokens ?? 0,
+    audioInTokens: draft.audioInTokens ?? 0,
+    audioOutTokens: draft.audioOutTokens ?? 0,
+    imageInTokens: draft.imageInTokens ?? 0,
+    imageOutTokens: draft.imageOutTokens ?? 0
+  };
+  if (draft.serviceTier !== void 0) usage.serviceTier = draft.serviceTier;
+  if (draft.serverToolUse !== void 0) usage.serverToolUse = draft.serverToolUse;
+  if (draft.providerReportedCostNanoUsd !== void 0) {
+    usage.providerReportedCostNanoUsd = draft.providerReportedCostNanoUsd;
+  }
+  if (draft.raw !== void 0) usage.raw = draft.raw;
+  return usage;
+}
+function readResponse(raw, provider, usageKey = "usage") {
+  const response = asObject(raw) ?? {};
+  const usage = asObject(response[usageKey]);
+  if (usage === void 0) throw new Error(`${provider}: missing "${usageKey}" object`);
+  return { response, usage };
+}
+
+// src/shared/normalizers/openai-chat.normalizer.ts
+function normalizeOpenAiChatUsage(raw) {
+  const { response, usage } = readResponse(raw, "openai-chat");
+  const promptTokens = requireNum(usage.prompt_tokens, "openai-chat", "usage.prompt_tokens");
+  const completionTokens = requireNum(usage.completion_tokens, "openai-chat", "usage.completion_tokens");
+  const promptDetails = asObject(usage.prompt_tokens_details);
+  const completionDetails = asObject(usage.completion_tokens_details);
+  const cacheReadTokens = num(promptDetails?.cached_tokens);
+  const audioInTokens = num(promptDetails?.audio_tokens);
+  const reasoningTokens = num(completionDetails?.reasoning_tokens);
+  const audioOutTokens = num(completionDetails?.audio_tokens);
+  const serviceTier = openAiServiceTier(response.service_tier);
+  return buildUsage({
+    provider: "openai",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens: promptTokens - cacheReadTokens - audioInTokens,
+    outputTokens: completionTokens - reasoningTokens,
+    cacheReadTokens,
+    reasoningTokens,
+    audioInTokens,
+    audioOutTokens,
+    serviceTier,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/openai-responses.normalizer.ts
+function normalizeOpenAiResponsesUsage(raw) {
+  const { response, usage } = readResponse(raw, "openai-responses");
+  const inputTokensTotal = requireNum(usage.input_tokens, "openai-responses", "usage.input_tokens");
+  const outputTokensTotal = requireNum(usage.output_tokens, "openai-responses", "usage.output_tokens");
+  const inputDetails = asObject(usage.input_tokens_details);
+  const outputDetails = asObject(usage.output_tokens_details);
+  const cacheReadTokens = num(inputDetails?.cached_tokens);
+  const audioInTokens = num(inputDetails?.audio_tokens);
+  const reasoningTokens = num(outputDetails?.reasoning_tokens);
+  const audioOutTokens = num(outputDetails?.audio_tokens);
+  const serviceTier = openAiServiceTier(response.service_tier);
+  return buildUsage({
+    provider: "openai",
+    model: str(response.model) ?? "",
+    operation: "responses",
+    inputTokens: inputTokensTotal - cacheReadTokens - audioInTokens,
+    outputTokens: outputTokensTotal - reasoningTokens,
+    cacheReadTokens,
+    reasoningTokens,
+    audioInTokens,
+    audioOutTokens,
+    serviceTier,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/openai-compatible.normalizer.ts
+function normalizeOpenAiCompatibleUsage(raw) {
+  const { response, usage } = readResponse(raw, "openai-compatible");
+  const promptTokens = requireNum(usage.prompt_tokens, "openai-compatible", "usage.prompt_tokens");
+  const completionTokens = requireNum(usage.completion_tokens, "openai-compatible", "usage.completion_tokens");
+  const promptDetails = asObject(usage.prompt_tokens_details);
+  const completionDetails = asObject(usage.completion_tokens_details);
+  const cacheReadTokens = num(usage.prompt_cache_hit_tokens) + num(promptDetails?.cached_tokens);
+  const reasoningTokens = num(completionDetails?.reasoning_tokens);
+  const serviceTier = openAiServiceTier(response.service_tier);
+  return buildUsage({
+    provider: "",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens: promptTokens - cacheReadTokens,
+    outputTokens: completionTokens - reasoningTokens,
+    cacheReadTokens,
+    reasoningTokens,
+    serviceTier,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/anthropic.normalizer.ts
+function normalizeAnthropicUsage(raw) {
+  const { response, usage } = readResponse(raw, "anthropic");
+  const inputTokens = requireNum(usage.input_tokens, "anthropic", "usage.input_tokens");
+  const outputTokens = requireNum(usage.output_tokens, "anthropic", "usage.output_tokens");
+  const cacheReadTokens = num(usage.cache_read_input_tokens);
+  const cacheCreation = asObject(usage.cache_creation);
+  const cacheWrite5mTokens = cacheCreation ? num(cacheCreation.ephemeral_5m_input_tokens) : num(usage.cache_creation_input_tokens);
+  const cacheWrite1hTokens = cacheCreation ? num(cacheCreation.ephemeral_1h_input_tokens) : 0;
+  return buildUsage({
+    provider: "anthropic",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWrite5mTokens,
+    cacheWrite1hTokens,
+    serviceTier: knownServiceTier(usage.service_tier),
+    serverToolUse: toolUseCounts(usage.server_tool_use),
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/gemini.normalizer.ts
+function normalizeGeminiUsage(raw) {
+  const { response, usage } = readResponse(raw, "gemini", "usageMetadata");
+  const promptTokenCount = requireNum(usage.promptTokenCount, "gemini", "usageMetadata.promptTokenCount");
+  const candidatesTokenCount = num(usage.candidatesTokenCount);
+  const cacheReadTokens = num(usage.cachedContentTokenCount);
+  const reasoningTokens = num(usage.thoughtsTokenCount);
+  const toolUseInputTokens = num(usage.toolUsePromptTokenCount);
+  return buildUsage({
+    provider: "gemini",
+    model: str(response.modelVersion) ?? str(response.model) ?? "",
+    operation: "chat",
+    inputTokens: promptTokenCount - cacheReadTokens + toolUseInputTokens,
+    outputTokens: candidatesTokenCount,
+    cacheReadTokens,
+    reasoningTokens,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/bedrock-converse.normalizer.ts
+function splitCacheWrite(usage) {
+  const details = asArray(usage.cacheDetails);
+  if (details === void 0) {
+    return { cacheWrite5mTokens: num(usage.cacheWriteInputTokens), cacheWrite1hTokens: 0 };
+  }
+  let cacheWrite5mTokens = 0;
+  let cacheWrite1hTokens = 0;
+  for (const item of details) {
+    const entry = asObject(item);
+    if (entry === void 0) continue;
+    const count = num(entry.cacheWriteInputTokens);
+    if (str(entry.ttl) === "1h") cacheWrite1hTokens += count;
+    else cacheWrite5mTokens += count;
+  }
+  return { cacheWrite5mTokens, cacheWrite1hTokens };
+}
+function normalizeBedrockConverseUsage(raw) {
+  const { response, usage } = readResponse(raw, "bedrock-converse");
+  const inputTokens = requireNum(usage.inputTokens, "bedrock-converse", "usage.inputTokens");
+  const outputTokens = requireNum(usage.outputTokens, "bedrock-converse", "usage.outputTokens");
+  const { cacheWrite5mTokens, cacheWrite1hTokens } = splitCacheWrite(usage);
+  return buildUsage({
+    provider: "bedrock",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: num(usage.cacheReadInputTokens),
+    cacheWrite5mTokens,
+    cacheWrite1hTokens,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/mistral.normalizer.ts
+function normalizeMistralUsage(raw) {
+  const { response, usage } = readResponse(raw, "mistral");
+  return buildUsage({
+    provider: "mistral",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    // Stryker disable next-line StringLiteral -- provider and field names in error messages are internal diagnostics
+    inputTokens: requireNum(usage.prompt_tokens, "mistral", "usage.prompt_tokens"),
+    // Stryker disable next-line StringLiteral -- provider and field names in error messages are internal diagnostics
+    outputTokens: requireNum(usage.completion_tokens, "mistral", "usage.completion_tokens"),
+    raw: usage
+  });
+}
+
+// src/shared/pricing/money.ts
+var NANO_PER_USD = 1000000000n;
+var DEFAULT_DISPLAY_DECIMALS = 6;
+function perMillion(tokens, ratePerMillionNano) {
+  return BigInt(tokens) * ratePerMillionNano / 1000000n;
+}
+function floatUsdToNanoUsd(usd) {
+  if (!Number.isFinite(usd)) {
+    throw new RangeError(`floatUsdToNanoUsd: expected a finite number, received ${String(usd)}`);
+  }
+  const sign = usd < 0 ? -1n : 1n;
+  const abs = Math.abs(usd);
+  const wholeDollars = Math.floor(abs);
+  const fractionalDollars = abs - wholeDollars;
+  const wholeNano = BigInt(wholeDollars) * NANO_PER_USD;
+  const fractionalNano = BigInt(Math.round(fractionalDollars * 1e9));
+  return sign * (wholeNano + fractionalNano);
+}
+function formatNanoUsd(nanoUsd, opts) {
+  const decimals = opts?.decimals ?? DEFAULT_DISPLAY_DECIMALS;
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 9) {
+    throw new RangeError(`formatNanoUsd: decimals must be an integer in [0, 9], received ${String(decimals)}`);
+  }
+  const currency = opts?.currency ?? "USD";
+  const converted = opts?.fxRateNano == null ? nanoUsd : nanoUsd * opts.fxRateNano / NANO_PER_USD;
+  const negative = converted < 0n;
+  const magnitude = negative ? -converted : converted;
+  const nanoPerDisplayUnit = 10n ** BigInt(9 - decimals);
+  const displayUnits = (magnitude + nanoPerDisplayUnit / 2n) / nanoPerDisplayUnit;
+  const scale = 10n ** BigInt(decimals);
+  const integerPart = displayUnits / scale;
+  const fractionalPart = displayUnits % scale;
+  const fractionalText = decimals > 0 ? `.${fractionalPart.toString().padStart(decimals, "0")}` : "";
+  const body = `${integerPart.toString()}${fractionalText}`;
+  const signText = negative ? "-" : "";
+  return currency === "USD" ? `${signText}$${body}` : `${signText}${body} ${currency}`;
+}
+
+// src/shared/normalizers/openrouter.normalizer.ts
+function normalizeOpenRouterUsage(raw) {
+  const { response, usage } = readResponse(raw, "openrouter");
+  const promptTokens = requireNum(usage.prompt_tokens, "openrouter", "usage.prompt_tokens");
+  const completionTokens = requireNum(usage.completion_tokens, "openrouter", "usage.completion_tokens");
+  const promptDetails = asObject(usage.prompt_tokens_details);
+  const completionDetails = asObject(usage.completion_tokens_details);
+  const cacheReadTokens = num(promptDetails?.cached_tokens);
+  const cacheWrite5mTokens = num(promptDetails?.cache_write_tokens);
+  const reasoningTokens = num(completionDetails?.reasoning_tokens);
+  const cost = usage.cost;
+  const providerReportedCostNanoUsd = typeof cost === "number" && Number.isFinite(cost) ? floatUsdToNanoUsd(cost) : void 0;
+  return buildUsage({
+    provider: "openrouter",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens: promptTokens - cacheReadTokens - cacheWrite5mTokens,
+    outputTokens: completionTokens - reasoningTokens,
+    cacheReadTokens,
+    cacheWrite5mTokens,
+    reasoningTokens,
+    serviceTier: openAiServiceTier(response.service_tier),
+    providerReportedCostNanoUsd,
+    raw: usage
+  });
+}
+
+// src/shared/normalizers/vercel-ai-sdk.normalizer.ts
+function normalizeVercelAiSdkUsage(raw) {
+  const { response, usage } = readResponse(raw, "vercel-ai-sdk");
+  const inputTokensTotal = requireNum(usage.inputTokens, "vercel-ai-sdk", "usage.inputTokens");
+  const outputTokensTotal = requireNum(usage.outputTokens, "vercel-ai-sdk", "usage.outputTokens");
+  const inputDetails = asObject(usage.inputTokenDetails);
+  const outputDetails = asObject(usage.outputTokenDetails);
+  const cacheReadTokens = num(usage.cachedInputTokens) + num(inputDetails?.cacheReadTokens);
+  const cacheWrite5mTokens = num(inputDetails?.cacheWriteTokens);
+  const reasoningTokens = num(usage.reasoningTokens) + num(outputDetails?.reasoningTokens);
+  return buildUsage({
+    provider: "",
+    model: str(response.model) ?? "",
+    operation: "chat",
+    inputTokens: inputTokensTotal - cacheReadTokens - cacheWrite5mTokens,
+    outputTokens: outputTokensTotal - reasoningTokens,
+    cacheReadTokens,
+    cacheWrite5mTokens,
+    reasoningTokens,
+    raw: usage
+  });
+}
+
+// src/shared/pricing/compute-cost.ts
+function computeCostNanoUsd(usage, rate) {
+  const totalInput = usage.inputTokens + usage.cacheReadTokens + usage.cacheWrite5mTokens + usage.cacheWrite1hTokens;
+  const overTier = rate.tierThresholdTokens != null && totalInput > rate.tierThresholdTokens;
+  const inputRate = overTier ? rate.tierInputNanoUsdPerMillion ?? rate.inputNanoUsdPerMillion : rate.inputNanoUsdPerMillion;
+  const outputRate = overTier ? rate.tierOutputNanoUsdPerMillion ?? rate.outputNanoUsdPerMillion : rate.outputNanoUsdPerMillion;
+  const tokenNanoUsd = perMillion(usage.inputTokens, inputRate) + perMillion(usage.outputTokens, outputRate) + perMillion(usage.cacheReadTokens, rate.cacheReadNanoUsdPerMillion) + perMillion(usage.cacheWrite5mTokens, rate.cacheWrite5mNanoUsdPerMillion) + perMillion(usage.cacheWrite1hTokens, rate.cacheWrite1hNanoUsdPerMillion) + perMillion(usage.reasoningTokens, rate.reasoningNanoUsdPerMillion) + perMillion(usage.audioInTokens, rate.audioInNanoUsdPerMillion) + perMillion(usage.audioOutTokens, rate.audioOutNanoUsdPerMillion) + perMillion(usage.imageInTokens, rate.imageInNanoUsdPerMillion) + perMillion(usage.imageOutTokens, rate.imageOutNanoUsdPerMillion);
+  let surchargeNanoUsd = 0n;
+  for (const [unit, count] of Object.entries({ ...usage.serverToolUse })) {
+    const unitRate = rate.unitRates?.[unit];
+    if (unitRate != null) surchargeNanoUsd += BigInt(count) * unitRate;
+  }
+  return { totalNanoUsd: tokenNanoUsd + surchargeNanoUsd, tokenNanoUsd, surchargeNanoUsd };
+}
+
+// src/shared/pricing/apply-markup.ts
+var MARKUP_SCALE = 10000n;
+function assertValidMultiplier(multiplier) {
+  if (!Number.isFinite(multiplier) || multiplier <= 0) {
+    throw new RangeError(`applyMarkup: multiplier must be finite and > 0, received ${String(multiplier)}`);
+  }
+}
+function resolveMultiplier4dp(multiplier) {
+  assertValidMultiplier(multiplier);
+  return Math.round(multiplier * 1e4) / 1e4;
+}
+function applyMarkup(rawCostNanoUsd, multiplier) {
+  assertValidMultiplier(multiplier);
+  return rawCostNanoUsd * BigInt(Math.round(multiplier * 1e4)) / MARKUP_SCALE;
+}
+
+// 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));
+}
+
+exports.AI_OPERATIONS = AI_OPERATIONS;
+exports.AI_TOKENS_ERROR_CODES = AI_TOKENS_ERROR_CODES;
+exports.AMOUNT_FIELDS = AMOUNT_FIELDS;
+exports.PROVIDER_IDS = PROVIDER_IDS;
+exports.RELEASE_FIELDS = RELEASE_FIELDS;
+exports.REVERSAL_LINKAGE_FIELD = REVERSAL_LINKAGE_FIELD;
+exports.SERVICE_TIERS = SERVICE_TIERS;
+exports.SETTLEMENT_FIELDS = SETTLEMENT_FIELDS;
+exports.SETTLEMENT_PATCH_KEYS = SETTLEMENT_PATCH_KEYS;
+exports.TOKEN_CATEGORIES = TOKEN_CATEGORIES;
+exports.WALLET_ENTRY_TYPES = WALLET_ENTRY_TYPES;
+exports.applyMarkup = applyMarkup;
+exports.computeCostNanoUsd = computeCostNanoUsd;
+exports.deriveIdempotencyKey = deriveIdempotencyKey;
+exports.floatUsdToNanoUsd = floatUsdToNanoUsd;
+exports.formatNanoUsd = formatNanoUsd;
+exports.isLegalLedgerTransition = isLegalLedgerTransition;
+exports.isLegalTransitionPatchKey = isLegalTransitionPatchKey;
+exports.normalizeAnthropicUsage = normalizeAnthropicUsage;
+exports.normalizeBedrockConverseUsage = normalizeBedrockConverseUsage;
+exports.normalizeGeminiUsage = normalizeGeminiUsage;
+exports.normalizeMistralUsage = normalizeMistralUsage;
+exports.normalizeOpenAiChatUsage = normalizeOpenAiChatUsage;
+exports.normalizeOpenAiCompatibleUsage = normalizeOpenAiCompatibleUsage;
+exports.normalizeOpenAiResponsesUsage = normalizeOpenAiResponsesUsage;
+exports.normalizeOpenRouterUsage = normalizeOpenRouterUsage;
+exports.normalizeVercelAiSdkUsage = normalizeVercelAiSdkUsage;
+exports.perMillion = perMillion;
+exports.resolveMultiplier4dp = resolveMultiplier4dp;