@sixb/core 0.1.6 → 0.1.7

package/dist/{chunk-tg5mee00.js → chunk-ha58tjtt.js}

@@ -6,30 +6,30 @@ import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
   executionRecordInputFromRuntime
-} from "./chunk-f6erf2vv.js";
+} from "./chunk-hdz94br2.js";
 import {
   SYNC_RUN_FAILURE_CODES
-} from "./chunk-t624af60.js";
+} from "./chunk-6ed5bwnd.js";
 import {
   SyncRunError
-} from "./chunk-62c7t4jc.js";
+} from "./chunk-4nxeacx7.js";
 import {
   ConnectorConnectionStorageError
 } from "./chunk-5gd7tpv6.js";
 import {
   reportRunFailure
-} from "./chunk-dsrkgtnh.js";
+} from "./chunk-jq43kdvk.js";
 import {
   AuthorizationError,
   assertAuthorized,
   assertProviderAccess,
   resolveExecutionScopeAuthorization
-} from "./chunk-f83ka50g.js";
+} from "./chunk-37wk412q.js";
 import {
   createSixbError,
   isSixbError,
   toSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 
 // src/connectors/errors.ts
 class ConnectorError extends Error {

package/dist/{chunk-f6erf2vv.js → chunk-hdz94br2.js}

@@ -1,11 +1,11 @@
 // @bun
 import {
   ExecutionStorageError
-} from "./chunk-h9kxd41f.js";
+} from "./chunk-gbrpsx4m.js";
 import {
   createTrustedPrimitiveRuntimeAuthorization,
   getAuthorizationRef
-} from "./chunk-f83ka50g.js";
+} from "./chunk-37wk412q.js";
 
 // src/execution/durable.ts
 import { isDeepStrictEqual } from "util";

package/dist/chunk-jecn6t54.js

@@ -0,0 +1,307 @@
+// @bun
+// src/storage/ai-limits/errors.ts
+class AiLimitStorageError extends Error {
+  code;
+  name = "AiLimitStorageError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// src/storage/ai-limits/period.ts
+function aiLimitCalendarMonth(at) {
+  if (!(at instanceof Date) || !Number.isFinite(at.getTime())) {
+    throw new TypeError("[Sixb] AI limit period date must be a valid Date.");
+  }
+  const start = new Date(Date.UTC(at.getUTCFullYear(), at.getUTCMonth(), 1));
+  const end = new Date(Date.UTC(at.getUTCFullYear(), at.getUTCMonth() + 1, 1));
+  return { kind: "calendarMonth", start, end, resetAt: new Date(end) };
+}
+
+// src/storage/ai-limits/provider.ts
+var SIGNED_INT64_MAX = 9223372036854775807n;
+
+class AiLimitOperationLock {
+  tail = Promise.resolve();
+  settle() {
+    return this.tail;
+  }
+  async run(operation) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+}
+function normalizeAiLimitSubject(subject) {
+  if (!subject || typeof subject !== "object") {
+    throw new TypeError("[Sixb] AI limit subject must be an object.");
+  }
+  if (subject.type === "project")
+    return { type: "project" };
+  if (subject.type === "group" || subject.type === "user" || subject.type === "serviceAccount") {
+    assertNonBlank(subject.id, "subject id");
+    return { type: subject.type, id: subject.id };
+  }
+  throw new TypeError("[Sixb] AI limit subject type is unsupported.");
+}
+function normalizeAiLimitSubjects(subjects) {
+  if (!Array.isArray(subjects)) {
+    throw new TypeError("[Sixb] AI limit subjects must be an array.");
+  }
+  const normalized = [
+    normalizeAiLimitSubject({ type: "project" }),
+    ...subjects.map(normalizeAiLimitSubject)
+  ];
+  const byKey = new Map(normalized.map((subject) => [aiLimitSubjectKey(subject), subject]));
+  return [...byKey.values()].sort((left, right) => aiLimitSubjectKey(left).localeCompare(aiLimitSubjectKey(right)));
+}
+function aiLimitSubjectKey(subject) {
+  return subject.type === "project" ? "project:" : `${subject.type}:${subject.id}`;
+}
+function aiLimitSubjectParts(subject) {
+  return { type: subject.type, id: subject.type === "project" ? "" : subject.id };
+}
+function aiLimitSubjectFromParts(type, id) {
+  return normalizeAiLimitSubject(type === "project" ? { type } : { type, id });
+}
+function normalizeAiLimitQuantity(quantity) {
+  const normalized = normalizeAiLimitAmount(quantity);
+  return aiLimitQuantityFromAmount(normalized);
+}
+function normalizeAiLimitQuantities(quantities, label) {
+  if (!Array.isArray(quantities) || quantities.length === 0) {
+    throw new TypeError(`[Sixb] AI limit ${label} must contain at least one quantity.`);
+  }
+  const byKey = new Map;
+  for (const quantity of quantities) {
+    const normalized = normalizeAiLimitQuantity(quantity);
+    const key = aiLimitAmountKey(normalizeAiLimitAmount(normalized));
+    if (byKey.has(key)) {
+      throw new TypeError(`[Sixb] AI limit ${label} contains duplicate meter '${key}'.`);
+    }
+    byKey.set(key, normalized);
+  }
+  return [...byKey.values()].sort((left, right) => aiLimitAmountKey(normalizeAiLimitAmount(left)).localeCompare(aiLimitAmountKey(normalizeAiLimitAmount(right))));
+}
+function normalizeAiLimitAmount(quantity) {
+  if (!quantity || typeof quantity !== "object") {
+    throw new TypeError("[Sixb] AI limit quantity must be an object.");
+  }
+  if (quantity.meter === "tokens.total") {
+    if (!Number.isSafeInteger(quantity.amount) || quantity.amount < 0) {
+      throw new TypeError("[Sixb] AI limit token amount must be a non-negative safe integer.");
+    }
+    return { meter: quantity.meter, currency: "", amount: BigInt(quantity.amount) };
+  }
+  if (quantity.meter === "cost.catalogEstimated") {
+    const money = normalizeAiMoney(quantity.amount);
+    return { meter: quantity.meter, currency: money.currency, amount: BigInt(money.amountNanos) };
+  }
+  throw new TypeError("[Sixb] AI limit meter is unsupported.");
+}
+function aiLimitQuantityFromAmount(amount) {
+  if (amount.amount < 0n) {
+    throw new TypeError("[Sixb] AI limit amount cannot be negative.");
+  }
+  if (amount.meter === "tokens.total") {
+    const tokens = Number(amount.amount);
+    if (!Number.isSafeInteger(tokens)) {
+      throw new RangeError("[Sixb] AI limit token amount exceeds JavaScript's safe integer range.");
+    }
+    return { meter: amount.meter, amount: tokens };
+  }
+  if (amount.currency !== "USD") {
+    throw new TypeError("[Sixb] AI limit catalog-estimated cost currency must be 'USD'.");
+  }
+  return {
+    meter: amount.meter,
+    amount: { currency: "USD", amountNanos: amount.amount.toString() }
+  };
+}
+function aiLimitAmountKey(amount) {
+  return `${amount.meter}:${amount.currency}`;
+}
+function normalizeCreateAiLimitPolicy(input) {
+  assertNonBlank(input.id, "policy id");
+  assertNonBlank(input.projectId, "projectId");
+  const createdAt = cloneValidDate(input.createdAt ?? new Date, "createdAt");
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    subject: normalizeAiLimitSubject(input.subject),
+    limit: normalizeAiLimitQuantity(input.limit),
+    period: "calendarMonth",
+    enabled: input.enabled ?? true,
+    createdAt,
+    updatedAt: new Date(createdAt)
+  };
+}
+function normalizeUpdateAiLimitPolicy(input) {
+  assertNonBlank(input.projectId, "projectId");
+  assertNonBlank(input.id, "policy id");
+  if (input.limit === undefined && input.enabled === undefined) {
+    throw new TypeError("[Sixb] AI limit policy update must change limit or enabled.");
+  }
+  if (input.enabled !== undefined && typeof input.enabled !== "boolean") {
+    throw new TypeError("[Sixb] AI limit enabled must be a boolean.");
+  }
+  return {
+    projectId: input.projectId,
+    id: input.id,
+    ...input.limit === undefined ? {} : { limit: normalizeAiLimitQuantity(input.limit) },
+    ...input.enabled === undefined ? {} : { enabled: input.enabled },
+    updatedAt: cloneValidDate(input.updatedAt ?? new Date, "updatedAt")
+  };
+}
+function normalizeReserveAiModelCall(input) {
+  const identity = normalizeAiModelCallReservationIdentity(input);
+  const reservedAt = cloneValidDate(input.reservedAt ?? new Date, "reservedAt");
+  return {
+    identity,
+    subjects: normalizeAiLimitSubjects(input.subjects),
+    estimates: normalizeAiLimitQuantities(input.estimates, "estimates"),
+    period: aiLimitCalendarMonth(reservedAt),
+    reservedAt
+  };
+}
+function normalizeAiModelCallReservationIdentity(input) {
+  assertNonBlank(input.projectId, "projectId");
+  assertNonBlank(input.executionId, "executionId");
+  if (!Number.isSafeInteger(input.attempt) || input.attempt <= 0) {
+    throw new TypeError("[Sixb] AI limit reservation attempt must be a positive safe integer.");
+  }
+  assertNonBlank(input.callId, "callId");
+  return {
+    projectId: input.projectId,
+    executionId: input.executionId,
+    attempt: input.attempt,
+    callId: input.callId
+  };
+}
+function aiModelCallReservationKey(identity) {
+  return JSON.stringify([
+    identity.projectId,
+    identity.executionId,
+    identity.attempt,
+    identity.callId
+  ]);
+}
+function aiLimitPolicyDimensionKey(policy) {
+  const amount = normalizeAiLimitAmount(policy.limit);
+  return JSON.stringify([
+    policy.projectId,
+    aiLimitSubjectKey(policy.subject),
+    amount.meter,
+    amount.currency
+  ]);
+}
+function aiLimitReservationRequestMatches(reservation, request) {
+  return reservation.requestKey === aiLimitReservationRequestKey(request);
+}
+function aiLimitReservationRequestKey(request) {
+  return JSON.stringify([
+    request.period.start.toISOString(),
+    request.subjects.map(aiLimitSubjectKey),
+    request.estimates.map((quantity) => {
+      const amount = normalizeAiLimitAmount(quantity);
+      return [amount.meter, amount.currency, amount.amount.toString()];
+    })
+  ]);
+}
+function aiLimitReservationBuckets(policies, subjects, estimates) {
+  const subjectKeys = new Set(subjects.map(aiLimitSubjectKey));
+  const estimatesByDimension = new Map(estimates.map((estimate) => {
+    const amount = normalizeAiLimitAmount(estimate);
+    return [aiLimitAmountKey(amount), estimate];
+  }));
+  return policies.filter((policy) => subjectKeys.has(aiLimitSubjectKey(policy.subject))).flatMap((policy) => {
+    const estimate = estimatesByDimension.get(aiLimitAmountKey(normalizeAiLimitAmount(policy.limit)));
+    return estimate ? [{ subject: policy.subject, estimate }] : [];
+  }).sort((left, right) => {
+    const subject = aiLimitSubjectKey(left.subject).localeCompare(aiLimitSubjectKey(right.subject));
+    if (subject !== 0)
+      return subject;
+    return aiLimitAmountKey(normalizeAiLimitAmount(left.estimate)).localeCompare(aiLimitAmountKey(normalizeAiLimitAmount(right.estimate)));
+  });
+}
+function aiLimitAccountingEntryAppliesToSubject(entry, subject) {
+  if (subject.type === "project")
+    return true;
+  if (subject.type === "group")
+    return entry.requesterGroupIds.includes(subject.id);
+  return entry.requester?.type === subject.type && entry.requester.id === subject.id;
+}
+function aiLimitSubjectsFromAccountingEntry(entry) {
+  return normalizeAiLimitSubjects([
+    ...entry.requesterGroupIds.map((id) => ({ type: "group", id })),
+    ...entry.requester ? [entry.requester] : []
+  ]);
+}
+function resolveAiLimitActual(entries, dimension) {
+  let amount = 0n;
+  let accountingStatus = "complete";
+  for (const entry of entries) {
+    if (dimension.meter === "tokens.total") {
+      if (entry.totalTokens === undefined) {
+        accountingStatus = "unavailable";
+      } else {
+        amount += BigInt(entry.totalTokens);
+      }
+      continue;
+    }
+    if (entry.valuation?.status !== "rated" || entry.valuation.money.currency !== dimension.currency) {
+      accountingStatus = "unavailable";
+      continue;
+    }
+    amount += BigInt(entry.valuation.money.amountNanos);
+  }
+  return { amount, accountingStatus };
+}
+function assertAiLimitAccountingMatchesReservation(reservation, entry) {
+  if (entry.projectId !== reservation.projectId || entry.executionId !== reservation.executionId || entry.attempt !== reservation.attempt || entry.callId !== reservation.callId) {
+    throw new AiLimitStorageError("usage_mismatch", `[Sixb] AI usage record '${entry.usageRecordId}' does not belong to reservation '${reservation.callId}'.`);
+  }
+}
+function cloneAiLimitPolicy(policy) {
+  return structuredClone(policy);
+}
+function normalizeAiMoney(money) {
+  if (!money || typeof money !== "object") {
+    throw new TypeError("[Sixb] AI limit cost amount must be AiMoney.");
+  }
+  assertNonBlank(money.currency, "cost currency");
+  if (money.currency !== "USD") {
+    throw new TypeError("[Sixb] AI limit catalog-estimated cost currency must be 'USD'.");
+  }
+  if (!/^(0|[1-9][0-9]*)$/.test(money.amountNanos)) {
+    throw new TypeError("[Sixb] AI limit cost amountNanos must be a canonical non-negative integer string.");
+  }
+  if (BigInt(money.amountNanos) > SIGNED_INT64_MAX) {
+    throw new RangeError("[Sixb] AI limit cost amountNanos exceeds the supported range.");
+  }
+  return { currency: "USD", amountNanos: money.amountNanos };
+}
+function assertNonBlank(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI limit ${label} must be nonblank.`);
+  }
+}
+function cloneValidDate(value, label) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError(`[Sixb] AI limit ${label} must be a valid Date.`);
+  }
+  return new Date(value);
+}
+
+export { AiLimitStorageError, aiLimitCalendarMonth, AiLimitOperationLock, normalizeAiLimitSubject, normalizeAiLimitSubjects, aiLimitSubjectKey, aiLimitSubjectParts, aiLimitSubjectFromParts, normalizeAiLimitQuantity, normalizeAiLimitQuantities, normalizeAiLimitAmount, aiLimitQuantityFromAmount, aiLimitAmountKey, normalizeCreateAiLimitPolicy, normalizeUpdateAiLimitPolicy, normalizeReserveAiModelCall, normalizeAiModelCallReservationIdentity, aiModelCallReservationKey, aiLimitPolicyDimensionKey, aiLimitReservationRequestMatches, aiLimitReservationRequestKey, aiLimitReservationBuckets, aiLimitAccountingEntryAppliesToSubject, aiLimitSubjectsFromAccountingEntry, resolveAiLimitActual, assertAiLimitAccountingMatchesReservation, cloneAiLimitPolicy, assertNonBlank, cloneValidDate };
+
+//# debugId=8F027D87CF44DB7364756E2164756E21

package/dist/chunk-jecn6t54.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/storage/ai-limits/errors.ts", "../src/storage/ai-limits/period.ts", "../src/storage/ai-limits/provider.ts"],
+  "sourcesContent": [
+    "export type AiLimitStorageErrorCode =\n  | \"duplicate_policy\"\n  | \"missing_policy\"\n  | \"missing_execution\"\n  | \"missing_reservation\"\n  | \"missing_usage_record\"\n  | \"usage_mismatch\"\n  | \"unavailable_actuals\"\n  | \"reservation_conflict\"\n  | \"reconciliation_conflict\"\n  | \"invalid_reservation_state\"\n\n/** Stable storage failure for AI limit policies and reservations. */\nexport class AiLimitStorageError extends Error {\n  readonly name = \"AiLimitStorageError\"\n\n  constructor(\n    readonly code: AiLimitStorageErrorCode,\n    message: string\n  ) {\n    super(message)\n  }\n}\n",
+    "import type { AiLimitPeriod } from \"./types\"\n\n/** Return the UTC calendar month containing `at`, with an inclusive start and exclusive end. */\nexport function aiLimitCalendarMonth(at: Date): AiLimitPeriod {\n  if (!(at instanceof Date) || !Number.isFinite(at.getTime())) {\n    throw new TypeError(\"[Sixb] AI limit period date must be a valid Date.\")\n  }\n  const start = new Date(Date.UTC(at.getUTCFullYear(), at.getUTCMonth(), 1))\n  const end = new Date(Date.UTC(at.getUTCFullYear(), at.getUTCMonth() + 1, 1))\n  return { kind: \"calendarMonth\", start, end, resetAt: new Date(end) }\n}\n",
+    "import type { AiMoney } from \"../ai-cost\"\nimport { AiLimitStorageError } from \"./errors\"\nimport { aiLimitCalendarMonth } from \"./period\"\nimport type {\n  AiLimitPeriod,\n  AiLimitPolicy,\n  AiLimitQuantity,\n  AiLimitReservationBucket,\n  AiLimitSubject,\n  AiModelCallReservation,\n  AiModelCallReservationIdentity,\n  CreateAiLimitPolicyInput,\n  ReserveAiModelCallInput,\n  UpdateAiLimitPolicyInput,\n} from \"./types\"\n\nconst SIGNED_INT64_MAX = 9_223_372_036_854_775_807n\n\n/** @internal Serialize compound limit operations, including within an existing transaction. */\nexport class AiLimitOperationLock {\n  private tail: Promise<void> = Promise.resolve()\n\n  /** Wait for already queued operations before the owning transaction commits or rolls back. */\n  settle(): Promise<void> {\n    return this.tail\n  }\n\n  async run<T>(operation: () => Promise<T> | T): Promise<T> {\n    const previous = this.tail\n    let release!: () => void\n    this.tail = new Promise<void>((resolve) => {\n      release = resolve\n    })\n    await previous\n    try {\n      return await operation()\n    } finally {\n      release()\n    }\n  }\n}\n\n/** @internal Canonical integer quantity used by storage providers. */\nexport interface NormalizedAiLimitAmount {\n  readonly meter: AiLimitQuantity[\"meter\"]\n  readonly currency: string\n  readonly amount: bigint\n}\n\n/** @internal Minimal immutable accounting facts consumed by limit providers. */\nexport interface AiLimitAccountingEntry {\n  readonly projectId: string\n  readonly usageRecordId: string\n  readonly executionId: string\n  readonly attempt: number\n  readonly callId: string\n  readonly occurredAt: Date\n  readonly totalTokens?: number\n  readonly requesterGroupIds: readonly string[]\n  readonly requester?:\n    | { readonly type: \"user\"; readonly id: string }\n    | { readonly type: \"serviceAccount\"; readonly id: string }\n  readonly valuation?:\n    | { readonly status: \"rated\"; readonly money: AiMoney }\n    | { readonly status: \"unavailable\" }\n}\n\nexport interface ResolvedAiLimitActual {\n  readonly amount: bigint\n  readonly accountingStatus: \"complete\" | \"unavailable\"\n}\n\nexport function normalizeAiLimitSubject(subject: AiLimitSubject): AiLimitSubject {\n  if (!subject || typeof subject !== \"object\") {\n    throw new TypeError(\"[Sixb] AI limit subject must be an object.\")\n  }\n  if (subject.type === \"project\") return { type: \"project\" }\n  if (subject.type === \"group\" || subject.type === \"user\" || subject.type === \"serviceAccount\") {\n    assertNonBlank(subject.id, \"subject id\")\n    return { type: subject.type, id: subject.id }\n  }\n  throw new TypeError(\"[Sixb] AI limit subject type is unsupported.\")\n}\n\nexport function normalizeAiLimitSubjects(\n  subjects: readonly AiLimitSubject[]\n): readonly AiLimitSubject[] {\n  if (!Array.isArray(subjects)) {\n    throw new TypeError(\"[Sixb] AI limit subjects must be an array.\")\n  }\n  const normalized = [\n    normalizeAiLimitSubject({ type: \"project\" }),\n    ...subjects.map(normalizeAiLimitSubject),\n  ]\n  const byKey = new Map(normalized.map((subject) => [aiLimitSubjectKey(subject), subject]))\n  return [...byKey.values()].sort((left, right) =>\n    aiLimitSubjectKey(left).localeCompare(aiLimitSubjectKey(right))\n  )\n}\n\nexport function aiLimitSubjectKey(subject: AiLimitSubject): string {\n  return subject.type === \"project\" ? \"project:\" : `${subject.type}:${subject.id}`\n}\n\nexport function aiLimitSubjectParts(subject: AiLimitSubject): {\n  readonly type: AiLimitSubject[\"type\"]\n  readonly id: string\n} {\n  return { type: subject.type, id: subject.type === \"project\" ? \"\" : subject.id }\n}\n\nexport function aiLimitSubjectFromParts(type: AiLimitSubject[\"type\"], id: string): AiLimitSubject {\n  return normalizeAiLimitSubject(type === \"project\" ? { type } : { type, id })\n}\n\nexport function normalizeAiLimitQuantity(quantity: AiLimitQuantity): AiLimitQuantity {\n  const normalized = normalizeAiLimitAmount(quantity)\n  return aiLimitQuantityFromAmount(normalized)\n}\n\nexport function normalizeAiLimitQuantities(\n  quantities: readonly AiLimitQuantity[],\n  label: string\n): readonly AiLimitQuantity[] {\n  if (!Array.isArray(quantities) || quantities.length === 0) {\n    throw new TypeError(`[Sixb] AI limit ${label} must contain at least one quantity.`)\n  }\n  const byKey = new Map<string, AiLimitQuantity>()\n  for (const quantity of quantities) {\n    const normalized = normalizeAiLimitQuantity(quantity)\n    const key = aiLimitAmountKey(normalizeAiLimitAmount(normalized))\n    if (byKey.has(key)) {\n      throw new TypeError(`[Sixb] AI limit ${label} contains duplicate meter '${key}'.`)\n    }\n    byKey.set(key, normalized)\n  }\n  return [...byKey.values()].sort((left, right) =>\n    aiLimitAmountKey(normalizeAiLimitAmount(left)).localeCompare(\n      aiLimitAmountKey(normalizeAiLimitAmount(right))\n    )\n  )\n}\n\nexport function normalizeAiLimitAmount(quantity: AiLimitQuantity): NormalizedAiLimitAmount {\n  if (!quantity || typeof quantity !== \"object\") {\n    throw new TypeError(\"[Sixb] AI limit quantity must be an object.\")\n  }\n  if (quantity.meter === \"tokens.total\") {\n    if (!Number.isSafeInteger(quantity.amount) || quantity.amount < 0) {\n      throw new TypeError(\"[Sixb] AI limit token amount must be a non-negative safe integer.\")\n    }\n    return { meter: quantity.meter, currency: \"\", amount: BigInt(quantity.amount) }\n  }\n  if (quantity.meter === \"cost.catalogEstimated\") {\n    const money = normalizeAiMoney(quantity.amount)\n    return { meter: quantity.meter, currency: money.currency, amount: BigInt(money.amountNanos) }\n  }\n  throw new TypeError(\"[Sixb] AI limit meter is unsupported.\")\n}\n\nexport function aiLimitQuantityFromAmount(amount: NormalizedAiLimitAmount): AiLimitQuantity {\n  if (amount.amount < 0n) {\n    throw new TypeError(\"[Sixb] AI limit amount cannot be negative.\")\n  }\n  if (amount.meter === \"tokens.total\") {\n    const tokens = Number(amount.amount)\n    if (!Number.isSafeInteger(tokens)) {\n      throw new RangeError(\"[Sixb] AI limit token amount exceeds JavaScript's safe integer range.\")\n    }\n    return { meter: amount.meter, amount: tokens }\n  }\n  if (amount.currency !== \"USD\") {\n    throw new TypeError(\"[Sixb] AI limit catalog-estimated cost currency must be 'USD'.\")\n  }\n  return {\n    meter: amount.meter,\n    amount: { currency: \"USD\", amountNanos: amount.amount.toString() },\n  }\n}\n\nexport function aiLimitAmountKey(\n  amount: Pick<NormalizedAiLimitAmount, \"meter\" | \"currency\">\n): string {\n  return `${amount.meter}:${amount.currency}`\n}\n\nexport function normalizeCreateAiLimitPolicy(input: CreateAiLimitPolicyInput): AiLimitPolicy {\n  assertNonBlank(input.id, \"policy id\")\n  assertNonBlank(input.projectId, \"projectId\")\n  const createdAt = cloneValidDate(input.createdAt ?? new Date(), \"createdAt\")\n  return {\n    id: input.id,\n    projectId: input.projectId,\n    subject: normalizeAiLimitSubject(input.subject),\n    limit: normalizeAiLimitQuantity(input.limit),\n    period: \"calendarMonth\",\n    enabled: input.enabled ?? true,\n    createdAt,\n    updatedAt: new Date(createdAt),\n  }\n}\n\nexport function normalizeUpdateAiLimitPolicy(input: UpdateAiLimitPolicyInput): {\n  readonly projectId: string\n  readonly id: string\n  readonly limit?: AiLimitQuantity\n  readonly enabled?: boolean\n  readonly updatedAt: Date\n} {\n  assertNonBlank(input.projectId, \"projectId\")\n  assertNonBlank(input.id, \"policy id\")\n  if (input.limit === undefined && input.enabled === undefined) {\n    throw new TypeError(\"[Sixb] AI limit policy update must change limit or enabled.\")\n  }\n  if (input.enabled !== undefined && typeof input.enabled !== \"boolean\") {\n    throw new TypeError(\"[Sixb] AI limit enabled must be a boolean.\")\n  }\n  return {\n    projectId: input.projectId,\n    id: input.id,\n    ...(input.limit === undefined ? {} : { limit: normalizeAiLimitQuantity(input.limit) }),\n    ...(input.enabled === undefined ? {} : { enabled: input.enabled }),\n    updatedAt: cloneValidDate(input.updatedAt ?? new Date(), \"updatedAt\"),\n  }\n}\n\nexport function normalizeReserveAiModelCall(input: ReserveAiModelCallInput): {\n  readonly identity: AiModelCallReservationIdentity\n  readonly subjects: readonly AiLimitSubject[]\n  readonly estimates: readonly AiLimitQuantity[]\n  readonly period: AiLimitPeriod\n  readonly reservedAt: Date\n} {\n  const identity = normalizeAiModelCallReservationIdentity(input)\n  const reservedAt = cloneValidDate(input.reservedAt ?? new Date(), \"reservedAt\")\n  return {\n    identity,\n    subjects: normalizeAiLimitSubjects(input.subjects),\n    estimates: normalizeAiLimitQuantities(input.estimates, \"estimates\"),\n    period: aiLimitCalendarMonth(reservedAt),\n    reservedAt,\n  }\n}\n\nexport function normalizeAiModelCallReservationIdentity(\n  input: AiModelCallReservationIdentity\n): AiModelCallReservationIdentity {\n  assertNonBlank(input.projectId, \"projectId\")\n  assertNonBlank(input.executionId, \"executionId\")\n  if (!Number.isSafeInteger(input.attempt) || input.attempt <= 0) {\n    throw new TypeError(\"[Sixb] AI limit reservation attempt must be a positive safe integer.\")\n  }\n  assertNonBlank(input.callId, \"callId\")\n  return {\n    projectId: input.projectId,\n    executionId: input.executionId,\n    attempt: input.attempt,\n    callId: input.callId,\n  }\n}\n\nexport function aiModelCallReservationKey(identity: AiModelCallReservationIdentity): string {\n  return JSON.stringify([\n    identity.projectId,\n    identity.executionId,\n    identity.attempt,\n    identity.callId,\n  ])\n}\n\nexport function aiLimitPolicyDimensionKey(\n  policy: Pick<AiLimitPolicy, \"projectId\" | \"subject\" | \"limit\">\n): string {\n  const amount = normalizeAiLimitAmount(policy.limit)\n  return JSON.stringify([\n    policy.projectId,\n    aiLimitSubjectKey(policy.subject),\n    amount.meter,\n    amount.currency,\n  ])\n}\n\nexport function aiLimitReservationRequestMatches(\n  reservation: AiModelCallReservation,\n  request: ReturnType<typeof normalizeReserveAiModelCall>\n): boolean {\n  return reservation.requestKey === aiLimitReservationRequestKey(request)\n}\n\nexport function aiLimitReservationRequestKey(\n  request: ReturnType<typeof normalizeReserveAiModelCall>\n): string {\n  return JSON.stringify([\n    request.period.start.toISOString(),\n    request.subjects.map(aiLimitSubjectKey),\n    request.estimates.map((quantity) => {\n      const amount = normalizeAiLimitAmount(quantity)\n      return [amount.meter, amount.currency, amount.amount.toString()]\n    }),\n  ])\n}\n\nexport function aiLimitReservationBuckets(\n  policies: readonly AiLimitPolicy[],\n  subjects: readonly AiLimitSubject[],\n  estimates: readonly AiLimitQuantity[]\n): readonly AiLimitReservationBucket[] {\n  const subjectKeys = new Set(subjects.map(aiLimitSubjectKey))\n  const estimatesByDimension = new Map(\n    estimates.map((estimate) => {\n      const amount = normalizeAiLimitAmount(estimate)\n      return [aiLimitAmountKey(amount), estimate] as const\n    })\n  )\n  return policies\n    .filter((policy) => subjectKeys.has(aiLimitSubjectKey(policy.subject)))\n    .flatMap((policy) => {\n      const estimate = estimatesByDimension.get(\n        aiLimitAmountKey(normalizeAiLimitAmount(policy.limit))\n      )\n      return estimate ? [{ subject: policy.subject, estimate }] : []\n    })\n    .sort((left, right) => {\n      const subject = aiLimitSubjectKey(left.subject).localeCompare(\n        aiLimitSubjectKey(right.subject)\n      )\n      if (subject !== 0) return subject\n      return aiLimitAmountKey(normalizeAiLimitAmount(left.estimate)).localeCompare(\n        aiLimitAmountKey(normalizeAiLimitAmount(right.estimate))\n      )\n    })\n}\n\nexport function aiLimitAccountingEntryAppliesToSubject(\n  entry: AiLimitAccountingEntry,\n  subject: AiLimitSubject\n): boolean {\n  if (subject.type === \"project\") return true\n  if (subject.type === \"group\") return entry.requesterGroupIds.includes(subject.id)\n  return entry.requester?.type === subject.type && entry.requester.id === subject.id\n}\n\nexport function aiLimitSubjectsFromAccountingEntry(\n  entry: AiLimitAccountingEntry\n): readonly AiLimitSubject[] {\n  return normalizeAiLimitSubjects([\n    ...entry.requesterGroupIds.map((id) => ({ type: \"group\" as const, id })),\n    ...(entry.requester ? [entry.requester] : []),\n  ])\n}\n\nexport function resolveAiLimitActual(\n  entries: readonly AiLimitAccountingEntry[],\n  dimension: Pick<NormalizedAiLimitAmount, \"meter\" | \"currency\">\n): ResolvedAiLimitActual {\n  let amount = 0n\n  let accountingStatus: ResolvedAiLimitActual[\"accountingStatus\"] = \"complete\"\n  for (const entry of entries) {\n    if (dimension.meter === \"tokens.total\") {\n      if (entry.totalTokens === undefined) {\n        accountingStatus = \"unavailable\"\n      } else {\n        amount += BigInt(entry.totalTokens)\n      }\n      continue\n    }\n    if (\n      entry.valuation?.status !== \"rated\" ||\n      entry.valuation.money.currency !== dimension.currency\n    ) {\n      accountingStatus = \"unavailable\"\n      continue\n    }\n    amount += BigInt(entry.valuation.money.amountNanos)\n  }\n  return { amount, accountingStatus }\n}\n\nexport function assertAiLimitAccountingMatchesReservation(\n  reservation: AiModelCallReservation,\n  entry: AiLimitAccountingEntry\n): void {\n  if (\n    entry.projectId !== reservation.projectId ||\n    entry.executionId !== reservation.executionId ||\n    entry.attempt !== reservation.attempt ||\n    entry.callId !== reservation.callId\n  ) {\n    throw new AiLimitStorageError(\n      \"usage_mismatch\",\n      `[Sixb] AI usage record '${entry.usageRecordId}' does not belong to reservation '${reservation.callId}'.`\n    )\n  }\n}\n\nexport function cloneAiLimitPolicy(policy: AiLimitPolicy): AiLimitPolicy {\n  return structuredClone(policy)\n}\n\nfunction normalizeAiMoney(money: AiMoney): AiMoney & { readonly currency: \"USD\" } {\n  if (!money || typeof money !== \"object\") {\n    throw new TypeError(\"[Sixb] AI limit cost amount must be AiMoney.\")\n  }\n  assertNonBlank(money.currency, \"cost currency\")\n  if (money.currency !== \"USD\") {\n    throw new TypeError(\"[Sixb] AI limit catalog-estimated cost currency must be 'USD'.\")\n  }\n  if (!/^(0|[1-9][0-9]*)$/.test(money.amountNanos)) {\n    throw new TypeError(\n      \"[Sixb] AI limit cost amountNanos must be a canonical non-negative integer string.\"\n    )\n  }\n  if (BigInt(money.amountNanos) > SIGNED_INT64_MAX) {\n    throw new RangeError(\"[Sixb] AI limit cost amountNanos exceeds the supported range.\")\n  }\n  return { currency: \"USD\", amountNanos: money.amountNanos }\n}\n\nexport function assertNonBlank(value: string, label: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`[Sixb] AI limit ${label} must be nonblank.`)\n  }\n}\n\nexport function cloneValidDate(value: Date, label: string): Date {\n  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {\n    throw new TypeError(`[Sixb] AI limit ${label} must be a valid Date.`)\n  }\n  return new Date(value)\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "8F027D87CF44DB7364756E2164756E21",
+  "names": []
+}

package/dist/{chunk-dsrkgtnh.js → chunk-jq43kdvk.js}

@@ -5,7 +5,7 @@ import {
   reportEventDeliveryFailure,
   reportRuleEvaluationFailure,
   reportRunFailure
-} from "./chunk-bhxaq2nn.js";
+} from "./chunk-qw9gvjv5.js";
 
 // src/error-reporting/capability.ts
 var ERROR_REPORTER = Symbol("sixb.error-reporter");

package/dist/{chunk-wtmzkcht.js → chunk-k34z5rvh.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   getInvalidJsonValueReason
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 
 // src/broker/errors.ts
 class BrokerError extends Error {

package/dist/{chunk-htq0qh7z.js → chunk-ka3a2ft3.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   parseSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
   isPlainRecord
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 
 // src/storage/action-runs/types.ts
 var ACTION_RUN_PHASES = [

package/dist/{chunk-znagycq7.js → chunk-kt81c11h.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-5sz8ta9r.js";
 import {
   isDatasetDefinition
-} from "./chunk-a31h57d5.js";
+} from "./chunk-tn7xcs2n.js";
 import {
   ConnectorError,
   SyncValidationError,
   createConnectorCodedError,
   getConnectorExecutionSourceResolver
-} from "./chunk-tg5mee00.js";
+} from "./chunk-ha58tjtt.js";
 import {
   isConnectorDefinition,
   isOAuthConnectorAdapter