@ykurilov/agent-chat-limits 0.0.0-stage → 0.56.0

package/dist/index.js

@@ -0,0 +1,841 @@
+// src/create-spending-limits.ts
+import { SpendingLimitReachedError, resolveTimeZone as resolveTimeZone2 } from "@ykurilov/agent-chat-core";
+
+// src/limit-state.ts
+var UPDATE_ATTEMPTS = 50;
+var MAX_RETRY_PAUSE_MS = 32;
+function retryPause(attempt) {
+  const ceiling = Math.min(MAX_RETRY_PAUSE_MS, 2 ** attempt);
+  return new Promise((resolve) => setTimeout(resolve, Math.random() * ceiling));
+}
+function limitStateStore(storage) {
+  const get = storage.getSpendingLimitState?.bind(storage);
+  const save = storage.saveSpendingLimitState?.bind(storage);
+  if (!get || !save) return null;
+  const queues = /* @__PURE__ */ new Map();
+  function inTurn(key, work) {
+    const result = (queues.get(key) ?? Promise.resolve()).then(work);
+    const tail = result.catch(() => void 0);
+    queues.set(key, tail);
+    void tail.then(() => {
+      if (queues.get(key) === tail) queues.delete(key);
+    });
+    return result;
+  }
+  return {
+    async read(key) {
+      const record = await get(key);
+      return record ? JSON.parse(record.value) : null;
+    },
+    update(key, change) {
+      return inTurn(key, async () => {
+        for (let attempt = 0; attempt < UPDATE_ATTEMPTS; attempt++) {
+          if (attempt > 0) await retryPause(attempt);
+          const record = await get(key);
+          const current = record ? JSON.parse(record.value) : null;
+          const next = change(current);
+          if (next === null) return { value: current, written: false };
+          if (await save(key, JSON.stringify(next), record?.version ?? null)) return { value: next, written: true };
+        }
+        throw new Error(`\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043B\u0438\u043C\u0438\u0442\u043E\u0432 \xAB${key}\xBB: \u0437\u0430\u043F\u0438\u0441\u044C \u0432\u0441\u0451 \u0432\u0440\u0435\u043C\u044F \u043C\u0435\u043D\u044F\u044E\u0442 \u0434\u0440\u0443\u0433\u0438\u0435 \u0445\u043E\u0434\u044B`);
+      });
+    }
+  };
+}
+
+// src/spending-state.ts
+var PRECISION = 1e9;
+var round = (amount) => Math.round(amount * PRECISION) / PRECISION;
+function spendingState(input) {
+  const spent = round(input.spentUsd);
+  const limit = round(input.limitUsd);
+  const share = limit > 0 ? round(spent / limit) : 1;
+  if (spent >= limit) return { state: "exhausted", share };
+  if (share >= input.warnAt) return { state: "warning", share };
+  return { state: "ok", share };
+}
+
+// src/spending-period.ts
+function calendarBounds(unit, now, timeZone = "UTC", weekStartsOn = 1) {
+  const { year, month, day } = localDate(now, timeZone);
+  if (unit === "month") return { start: localMidnight(year, month, 1, timeZone), end: localMidnight(year, month + 1, 1, timeZone) };
+  if (unit === "day") return { start: localMidnight(year, month, day, timeZone), end: localMidnight(year, month, day + 1, timeZone) };
+  const weekday = new Date(Date.UTC(year, month, day)).getUTCDay() || 7;
+  const startDay = day - (weekday - weekStartsOn + 7) % 7;
+  return { start: localMidnight(year, month, startDay, timeZone), end: localMidnight(year, month, startDay + 7, timeZone) };
+}
+var formatters = /* @__PURE__ */ new Map();
+function formatterOf(timeZone) {
+  let formatter = formatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    formatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+function wallClock(moment, timeZone) {
+  const parts = Object.fromEntries(formatterOf(timeZone).formatToParts(moment).map((part) => [part.type, Number(part.value)]));
+  return { year: parts.year, month: parts.month - 1, day: parts.day, hour: parts.hour, minute: parts.minute, second: parts.second };
+}
+function localDate(moment, timeZone) {
+  const { year, month, day } = wallClock(moment, timeZone);
+  return { year, month, day };
+}
+function offsetMs(epochMs, timeZone) {
+  const wall = wallClock(new Date(epochMs), timeZone);
+  const wallAsUtc = Date.UTC(wall.year, wall.month, wall.day, wall.hour, wall.minute, wall.second);
+  return wallAsUtc - Math.floor(epochMs / 1e3) * 1e3;
+}
+var DAY_MS = 864e5;
+function localMidnight(year, month, day, timeZone) {
+  const wallMidnight = Date.UTC(year, month, day);
+  const target = new Date(wallMidnight);
+  const candidates = [offsetMs(wallMidnight - DAY_MS, timeZone), offsetMs(wallMidnight + DAY_MS, timeZone)].map((offset) => wallMidnight - offset).filter((moment) => {
+    const wall = wallClock(new Date(moment), timeZone);
+    return wall.year === target.getUTCFullYear() && wall.month === target.getUTCMonth() && wall.day === target.getUTCDate();
+  });
+  return new Date(candidates.length > 0 ? Math.min(...candidates) : wallMidnight - offsetMs(wallMidnight, timeZone)).toISOString();
+}
+
+// src/window-reading.ts
+var HOUR_MS = 36e5;
+function windowStateKey(window, subject) {
+  if (window.scope === "service") return `window:service:${window.id}`;
+  if (window.scope === "user") return `window:user:${subject.userId}:${window.id}`;
+  return subject.chatId === void 0 ? null : `window:chat:${subject.chatId}:${window.id}`;
+}
+function usageFilterOf(window, subject) {
+  if (window.scope === "service") return {};
+  if (window.scope === "user") return { ownerId: subject.userId };
+  return { ownerId: subject.userId, chatId: subject.chatId };
+}
+function currentSpan(window, saved, now, open) {
+  if (window.kind === "total") return { start: null, end: null, active: true };
+  if (window.kind === "calendar") {
+    const bounds = calendarBounds(window.unit, now, window.timeZone, window.weekStartsOn);
+    return { start: bounds.start, end: bounds.end, active: true };
+  }
+  const hoursMs = window.hours * HOUR_MS;
+  if (saved?.start && now.getTime() < Date.parse(saved.start) + hoursMs) {
+    return { start: saved.start, end: new Date(Date.parse(saved.start) + hoursMs).toISOString(), active: true };
+  }
+  if (open) return { start: now.toISOString(), end: new Date(now.getTime() + hoursMs).toISOString(), active: true };
+  return { start: null, end: null, active: false };
+}
+async function readWindow(input) {
+  const { window, subject, now, store } = input;
+  const stateKey = windowStateKey(window, subject);
+  if (stateKey === null) return null;
+  const filter = usageFilterOf(window, subject);
+  const saved = store ? await store.read(stateKey) : null;
+  const span = currentSpan(window, saved, now, input.open);
+  const sameWindow = saved !== null && span.active && saved.start === span.start;
+  const limitUsd = input.limitUsd ?? null;
+  let carriedUsd = 0;
+  if (sameWindow) carriedUsd = saved.carriedUsd;
+  else if (window.carryOverrun && limitUsd !== null) carriedUsd = await carryInto({ ...input, filter, saved, spanStart: span.start, limitUsd });
+  const since = latest(span.start, sameWindow ? saved.resetAt : void 0);
+  const recorded = span.active ? await input.sumSince(filter, since) : 0;
+  const spentUsd = recorded + carriedUsd + Math.max(0, input.pendingUsd ?? 0);
+  const judged = limitUsd === null ? { state: "ok", share: null } : spendingState({ spentUsd, limitUsd, warnAt: input.warnAt });
+  const changed = !sameWindow && span.active && store !== null && (window.kind === "rolling" || carriedUsd > 0 || saved !== null);
+  return {
+    window,
+    stateKey,
+    limitUsd,
+    start: span.start,
+    resetsAt: span.end,
+    waiting: !span.active,
+    spentUsd,
+    carriedUsd,
+    state: judged.state,
+    share: judged.share,
+    nextState: changed ? { start: span.start, carriedUsd, notified: [] } : null,
+    savedStart: saved === null ? void 0 : saved.start
+  };
+}
+async function carryInto(input) {
+  const { window, saved, filter, limitUsd } = input;
+  if (window.kind === "total") return 0;
+  if (window.kind === "rolling") {
+    if (!saved?.start) return 0;
+    const end = new Date(Date.parse(saved.start) + window.hours * HOUR_MS).toISOString();
+    const spent2 = await spentBetween(input, filter, latest(saved.start, saved.resetAt), end) + saved.carriedUsd;
+    return Math.max(0, spent2 - limitUsd);
+  }
+  const start = input.spanStart;
+  const previous = calendarBounds(window.unit, new Date(Date.parse(start) - 1), window.timeZone, window.weekStartsOn);
+  const known = saved !== null && saved.start === previous.start;
+  const since = latest(previous.start, known ? saved.resetAt : void 0);
+  const spent = await spentBetween(input, filter, since, start) + (known ? saved.carriedUsd : 0);
+  return Math.max(0, spent - limitUsd);
+}
+async function spentBetween(input, filter, since, until) {
+  if (since !== null && since >= until) return 0;
+  const [fromStart, fromEnd] = await Promise.all([input.sumSince(filter, since), input.sumSince(filter, until)]);
+  return fromStart - fromEnd;
+}
+function latest(start, other) {
+  if (other === void 0) return start;
+  if (start === null) return other;
+  return other > start ? other : start;
+}
+
+// src/message-windows.ts
+function usedIn(saved, start) {
+  return saved !== null && saved.start === start ? saved.messages ?? 0 : 0;
+}
+async function readMessageWindow(input) {
+  const { window, limit } = input;
+  const stateKey = windowStateKey(window, input.subject);
+  if (stateKey === null) return null;
+  const saved = await input.store.read(stateKey);
+  const span = currentSpan(window, saved, input.now, false);
+  const used = span.active ? usedIn(saved, span.start) : 0;
+  const judged = spendingState({ spentUsd: used, limitUsd: limit, warnAt: input.warnAt });
+  return { window, limit, used, start: span.start, resetsAt: span.end, state: judged.state, share: judged.share };
+}
+async function takeMessageSlots(input) {
+  const { store, now } = input;
+  const taken = [];
+  const refused = [];
+  const crossed = [];
+  try {
+    for (const { window, limit } of input.windows) {
+      const stateKey = windowStateKey(window, input.subject);
+      if (stateKey === null) continue;
+      if (refused.length > 0) {
+        const saved = await store.read(stateKey);
+        const span = currentSpan(window, saved, now, true);
+        if (usedIn(saved, span.start) >= limit) refused.push({ window, resetsAt: span.end });
+        continue;
+      }
+      let outcome = { end: null, full: false, used: 0 };
+      await store.update(stateKey, (current) => {
+        const span = currentSpan(window, current, now, true);
+        const used = usedIn(current, span.start);
+        outcome = { end: span.end, full: used >= limit, used: used + 1 };
+        if (outcome.full) return null;
+        const sameWindow = current !== null && current.start === span.start;
+        const base = sameWindow ? current : { start: span.start, carriedUsd: 0, notified: [] };
+        const count = sameWindow && current.count || crypto.randomUUID();
+        const share = limit === 0 ? 1 : (used + 1) / limit;
+        const reached = input.thresholds.filter((threshold) => share >= threshold && !base.notified.includes(threshold));
+        outcome.slot = { stateKey, start: span.start, count, openedWindow: window.kind === "rolling" && !sameWindow, crossed: reached };
+        return { ...base, start: span.start, messages: used + 1, count, notified: [...base.notified, ...reached] };
+      });
+      if (outcome.full) {
+        refused.push({ window, resetsAt: outcome.end });
+        continue;
+      }
+      const slot = outcome.slot;
+      taken.push(slot);
+      for (const threshold of slot.crossed) crossed.push({ window, threshold, used: outcome.used, limit, start: slot.start, resetsAt: outcome.end });
+    }
+  } catch (failure) {
+    await giveBackMessageSlots(store, taken, { unmarkThresholds: true });
+    throw failure;
+  }
+  if (refused.length > 0) {
+    await giveBackMessageSlots(store, taken, { unmarkThresholds: true });
+    return { taken: [], refused, crossed: [] };
+  }
+  return { taken, refused, crossed };
+}
+async function giveBackMessageSlots(store, taken, options = {}) {
+  await Promise.all(
+    taken.map(
+      (slot) => store.update(slot.stateKey, (current) => {
+        if (current === null || current.start !== slot.start || current.count !== slot.count || !current.messages) return null;
+        const messages = current.messages - 1;
+        if (slot.openedWindow && messages === 0) return { carriedUsd: 0, notified: [], start: null };
+        const notified = options.unmarkThresholds ? current.notified.filter((threshold) => !slot.crossed.includes(threshold)) : current.notified;
+        return { ...current, messages, notified };
+      })
+    )
+  );
+}
+
+// src/spending-windows.ts
+import { resolveTimeZone } from "@ykurilov/agent-chat-core";
+var SCOPES = ["user", "chat", "service"];
+var UNITS = ["day", "week", "month"];
+function normalizeWindows(configs, defaultTimeZone) {
+  const seen = /* @__PURE__ */ new Set();
+  return configs.map((config) => {
+    const where = `\u041E\u043A\u043D\u043E \u043B\u0438\u043C\u0438\u0442\u0430 \xAB${String(config.id)}\xBB`;
+    if (typeof config.id !== "string" || config.id === "") throw new Error("\u041E\u043A\u043D\u043E \u043B\u0438\u043C\u0438\u0442\u0430: \u043D\u0443\u0436\u043D\u043E \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0435 \u0438\u043C\u044F id");
+    if (seen.has(config.id)) throw new Error(`${where}: \u0438\u043C\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u0442\u0441\u044F`);
+    seen.add(config.id);
+    if (!SCOPES.includes(config.scope)) throw new Error(`${where}: scope \u2014 user, chat \u0438\u043B\u0438 service, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(config.scope)}`);
+    const hasUsd = config.limitUsd !== void 0;
+    if (hasUsd === (config.limitMessages !== void 0)) throw new Error(`${where}: \u043D\u0443\u0436\u0435\u043D \u0440\u043E\u0432\u043D\u043E \u043E\u0434\u0438\u043D \u043B\u0438\u043C\u0438\u0442 \u2014 limitUsd \u0438\u043B\u0438 limitMessages`);
+    const measure = hasUsd ? "usd" : "messages";
+    if (measure === "messages" && config.carryOverrun === true) throw new Error(`${where}: carryOverrun \u0431\u044B\u0432\u0430\u0435\u0442 \u0442\u043E\u043B\u044C\u043A\u043E \u0443 \u043E\u043A\u043D\u0430 \u0434\u0435\u043D\u0435\u0433 (limitUsd)`);
+    const limit = checkedLimit(hasUsd ? config.limitUsd : config.limitMessages, measure, where);
+    const base = { id: config.id, scope: config.scope, carryOverrun: config.carryOverrun === true, measure, limit, weekStartsOn: 1 };
+    if (config.kind === "rolling") {
+      if (!(Number.isFinite(config.hours) && config.hours > 0)) throw new Error(`${where}: hours \u2014 \u0447\u0438\u0441\u043B\u043E \u0447\u0430\u0441\u043E\u0432 \u0431\u043E\u043B\u044C\u0448\u0435 0, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(config.hours)}`);
+      return { ...base, kind: "rolling", hours: config.hours, timeZone: "UTC", period: "rolling" };
+    }
+    if (config.kind === "total") return { ...base, kind: "total", timeZone: "UTC", period: "none" };
+    if (config.kind !== "calendar") throw new Error(`${where}: kind \u2014 calendar, rolling \u0438\u043B\u0438 total, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(config.kind)}`);
+    if (!UNITS.includes(config.unit)) throw new Error(`${where}: unit \u2014 day, week \u0438\u043B\u0438 month, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(config.unit)}`);
+    const weekStartsOn = config.weekStartsOn ?? 1;
+    if (!(Number.isInteger(weekStartsOn) && weekStartsOn >= 1 && weekStartsOn <= 7)) {
+      throw new Error(`${where}: weekStartsOn \u2014 \u043E\u0442 1 (\u043F\u043E\u043D\u0435\u0434\u0435\u043B\u044C\u043D\u0438\u043A) \u0434\u043E 7 (\u0432\u043E\u0441\u043A\u0440\u0435\u0441\u0435\u043D\u044C\u0435), \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(weekStartsOn)}`);
+    }
+    const timeZone = config.timeZone ?? defaultTimeZone ?? "UTC";
+    if (resolveTimeZone(timeZone) === void 0) throw new Error(`${where}: \xAB${timeZone}\xBB \u2014 \u043D\u0435 \u0447\u0430\u0441\u043E\u0432\u043E\u0439 \u043F\u043E\u044F\u0441 IANA`);
+    return { ...base, kind: "calendar", unit: config.unit, timeZone, weekStartsOn, period: config.unit };
+  });
+}
+function checkedLimit(limit, measure, where) {
+  if (typeof limit === "function") {
+    return async (subject) => {
+      const amount2 = await limit(subject);
+      if (amount2 === void 0 || amount2 === null) return void 0;
+      return validLimit(amount2, measure, where);
+    };
+  }
+  const amount = validLimit(limit, measure, where);
+  return async () => amount;
+}
+function validLimit(amount, measure, where) {
+  if (measure === "messages") {
+    if (typeof amount === "number" && Number.isInteger(amount) && amount >= 0) return amount;
+    throw new Error(`${where}: limitMessages \u2014 \u0446\u0435\u043B\u043E\u0435 \u043D\u0435\u043E\u0442\u0440\u0438\u0446\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0439, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(amount)}`);
+  }
+  if (typeof amount === "number" && Number.isFinite(amount) && amount >= 0) return amount;
+  throw new Error(`${where}: limitUsd \u2014 \u043D\u0435\u043E\u0442\u0440\u0438\u0446\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u0434\u043E\u043B\u043B\u0430\u0440\u043E\u0432, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(amount)}`);
+}
+
+// src/create-spending-limits.ts
+var DEFAULT_PERIOD = "month";
+var DEFAULT_WARN_AT = 0.8;
+var DEFAULT_THRESHOLDS = [0.8, 1];
+var STATE_SEVERITY = { ok: 0, warning: 1, exhausted: 2 };
+function createSpendingLimits(options) {
+  const { storage } = options;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const logError = options.logError ?? ((message) => console.error(message));
+  const warnAt = options.warnAt ?? DEFAULT_WARN_AT;
+  if (!(Number.isFinite(warnAt) && warnAt > 0 && warnAt < 1)) {
+    throw new Error(`warnAt \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0447\u0438\u0441\u043B\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u0435 0 \u0438 \u043C\u0435\u043D\u044C\u0448\u0435 1, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(warnAt)}`);
+  }
+  const timeZone = checkedTimeZone(options.timeZone);
+  const zone = timeZone === void 0 ? {} : { timeZone };
+  const thresholds = checkedThresholds(options.thresholds);
+  const turn = checkedTurnRules(options.turn);
+  const store = limitStateStore(storage);
+  const legacy = options.windows === void 0;
+  if (!legacy && options.budget) throw new Error("\u041B\u0438\u043C\u0438\u0442\u044B \u0437\u0430\u0434\u0430\u044E\u0442\u0441\u044F \u043E\u0434\u043D\u0438\u043C \u0441\u043F\u043E\u0441\u043E\u0431\u043E\u043C: windows \u0438\u043B\u0438 budget \u0441 period, \u043D\u0435 \u043E\u0431\u043E\u0438\u043C\u0438");
+  if (legacy && !options.budget) throw new Error("\u041D\u0443\u0436\u043D\u044B \u043E\u043A\u043D\u0430 \u043B\u0438\u043C\u0438\u0442\u043E\u0432 (windows) \u0438\u043B\u0438 \u0431\u044E\u0434\u0436\u0435\u0442 (budget)");
+  const allWindows = legacy ? legacyWindows(options.period, timeZone) : normalizeWindows(options.windows, timeZone);
+  const windows = allWindows.filter((window) => window.measure === "usd");
+  const messageWindows = allWindows.filter((window) => window.measure === "messages");
+  const needsState = allWindows.find((window) => window.kind === "rolling" || window.measure === "messages");
+  if (!store && needsState) {
+    const why = needsState.measure === "messages" ? "\u0441\u0447\u0438\u0442\u0430\u0435\u0442 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F" : "\u0441\u043A\u043E\u043B\u044C\u0437\u044F\u0449\u0435\u0435";
+    throw new Error(`\u041E\u043A\u043D\u043E \xAB${needsState.id}\xBB ${why}: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0443 \u043D\u0443\u0436\u043D\u044B \u043C\u0435\u0442\u043E\u0434\u044B getSpendingLimitState \u0438 saveSpendingLimitState`);
+  }
+  if (!store && options.onThreshold) throw new Error("onThreshold: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0443 \u043D\u0443\u0436\u043D\u044B \u043C\u0435\u0442\u043E\u0434\u044B getSpendingLimitState \u0438 saveSpendingLimitState");
+  const unpriced = findUnpricedModels(options.catalog);
+  if (unpriced.length > 0) {
+    if ((options.unpricedModels ?? "reject") === "reject") {
+      throw new Error(
+        `\u041D\u0435\u0442 \u0446\u0435\u043D\u044B \u0443 \u043C\u043E\u0434\u0435\u043B\u0435\u0439: ${unpriced.join(", ")}. \u0417\u0430\u0434\u0430\u0439\u0442\u0435 pricing \u0432 \u043F\u0440\u043E\u0444\u0438\u043B\u0435 \u0438\u043B\u0438 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u043B\u0438\u043C\u0438\u0442\u044B \u0441 unpricedModels: "ignore" (\u0440\u0430\u0441\u0445\u043E\u0434 \u0442\u0430\u043A\u0438\u0445 \u043C\u043E\u0434\u0435\u043B\u0435\u0439 \u043D\u0435 \u0441\u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F).`
+      );
+    }
+    logError(`\u041D\u0435\u0442 \u0446\u0435\u043D\u044B \u0443 \u043C\u043E\u0434\u0435\u043B\u0435\u0439: ${unpriced.join(", ")}. \u0418\u0445 \u0445\u043E\u0434\u044B \u0437\u0430\u043F\u0438\u0441\u044B\u0432\u0430\u044E\u0442\u0441\u044F \u0441\u043E \u0441\u0442\u043E\u0438\u043C\u043E\u0441\u0442\u044C\u044E 0 \u0438 \u0432 \u043B\u0438\u043C\u0438\u0442\u044B \u043D\u0435 \u0432\u0445\u043E\u0434\u044F\u0442`);
+  }
+  function requireStore() {
+    if (!store) throw new Error("\u041B\u0438\u0447\u043D\u044B\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 \u0438 \u0441\u0431\u0440\u043E\u0441 \u043E\u043A\u043E\u043D: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0443 \u043D\u0443\u0436\u043D\u044B \u043C\u0435\u0442\u043E\u0434\u044B getSpendingLimitState \u0438 saveSpendingLimitState");
+    return store;
+  }
+  async function budgetFor(subject) {
+    try {
+      const budget = await options.budget({ userId: subject.userId, ...subject.chatId !== void 0 && { chatId: subject.chatId } });
+      for (const scope of ["user", "chat"]) {
+        const amount = budget[scope];
+        if (amount !== void 0 && !(typeof amount === "number" && Number.isFinite(amount) && amount >= 0)) {
+          throw new Error(`\u0411\u044E\u0434\u0436\u0435\u0442 \xAB${scope}\xBB \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435\u043E\u0442\u0440\u0438\u0446\u0430\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(amount)}`);
+        }
+      }
+      return budget;
+    } catch (failure) {
+      logError(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C \u0431\u044E\u0434\u0436\u0435\u0442 \u0440\u0430\u0441\u0445\u043E\u0434\u043E\u0432 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 ${subject.userId}: ${failure instanceof Error ? failure.message : "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430"}`);
+      throw failure;
+    }
+  }
+  async function personOf(userId) {
+    return (store && await store.read(`person:${userId}`)) ?? {};
+  }
+  async function isExempt(subject) {
+    if (!options.exemptUsers) return false;
+    try {
+      return await options.exemptUsers({ userId: subject.userId, ...subject.chatId !== void 0 && { chatId: subject.chatId } }) === true;
+    } catch (failure) {
+      logError(`exemptUsers \u0443\u043F\u0430\u043B (\u0447\u0435\u043B\u043E\u0432\u0435\u043A ${subject.userId}): ${failure instanceof Error ? failure.message : "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430"}`);
+      throw failure;
+    }
+  }
+  async function limitsFor(subject, person) {
+    if (await isExempt(subject)) return /* @__PURE__ */ new Map();
+    if (legacy) {
+      const budget = await budgetFor(subject);
+      return /* @__PURE__ */ new Map([["user", budget.user], ["chat", budget.chat]]);
+    }
+    const entries = await Promise.all(
+      allWindows.map(async (window) => {
+        const own = window.scope === "service" ? void 0 : person.limits?.[window.id];
+        if (own !== void 0) return [window.id, own === null ? void 0 : own];
+        return [window.id, await window.limit(subject)];
+      })
+    );
+    return new Map(entries);
+  }
+  async function sumSince(filter, since) {
+    const sums = await storage.sumUsage({ ...filter, ...since !== null && { since } });
+    return sums.reduce((total, sum) => total + sum.costUsd, 0);
+  }
+  async function readAll(subject, person, read) {
+    const limits = read.limits ?? await limitsFor(subject, person);
+    const moment = now();
+    const readings = await Promise.all(
+      windows.map((window) => {
+        const limitUsd = limits.get(window.id);
+        if (limitUsd === void 0 && !read.withoutLimit?.(window)) return null;
+        const pendingUsd = read.pending && (window.scope === "chat" ? read.pending.chat : read.pending.user);
+        return readWindow({ window, subject, limitUsd, now: moment, store, sumSince, warnAt, open: read.open, ...pendingUsd !== void 0 && { pendingUsd } });
+      })
+    );
+    return readings.filter((reading) => reading !== null);
+  }
+  async function saveTransitions(readings) {
+    if (!store) return;
+    await Promise.all(
+      readings.filter((reading) => reading.nextState !== null).map(
+        (reading) => store.update(reading.stateKey, (current) => {
+          const currentStart2 = current === null ? void 0 : current.start;
+          return currentStart2 === reading.savedStart ? reading.nextState : null;
+        })
+      )
+    );
+  }
+  function refusal(reading, reason) {
+    const { window } = reading;
+    return new SpendingLimitReachedError({
+      scope: window.scope,
+      period: window.period,
+      resetsAt: reading.resetsAt,
+      ...zone,
+      ...!legacy && { reason, windowId: window.id, ...window.hours !== void 0 && { hours: window.hours } }
+    });
+  }
+  async function notifyThresholds(reading, subject) {
+    if (!store || !options.onThreshold || reading.waiting || reading.limitUsd === null || reading.share === null) return;
+    const share = reading.share;
+    let crossed = [];
+    await store.update(reading.stateKey, (current) => {
+      const base = current !== null && current.start === reading.start ? current : { start: reading.start, carriedUsd: reading.carriedUsd, notified: [] };
+      crossed = thresholds.filter((threshold) => share >= threshold && !base.notified.includes(threshold));
+      return crossed.length === 0 ? null : { ...base, notified: [...base.notified, ...crossed] };
+    });
+    const { window } = reading;
+    for (const threshold of crossed) {
+      const event = {
+        windowId: window.id,
+        scope: window.scope,
+        period: window.period,
+        ...window.hours !== void 0 && { hours: window.hours },
+        threshold,
+        share,
+        spentUsd: reading.spentUsd,
+        limitUsd: reading.limitUsd,
+        windowStart: reading.start,
+        resetsAt: reading.resetsAt,
+        userId: subject.userId,
+        ...subject.chatId !== void 0 && { chatId: subject.chatId }
+      };
+      const report = (failure) => logError(`onThreshold \u0443\u043F\u0430\u043B (\u043E\u043A\u043D\u043E ${window.id}, \u043F\u043E\u0440\u043E\u0433 ${threshold}): ${failure instanceof Error ? failure.message : String(failure)}`);
+      try {
+        void Promise.resolve(options.onThreshold(event)).catch(report);
+      } catch (failure) {
+        report(failure);
+      }
+    }
+  }
+  function notifyMessageThreshold(crossing, subject) {
+    const { window, threshold, used, limit } = crossing;
+    const event = {
+      windowId: window.id,
+      scope: window.scope,
+      period: window.period,
+      ...window.hours !== void 0 && { hours: window.hours },
+      threshold,
+      share: limit === 0 ? 1 : used / limit,
+      used,
+      limit,
+      remaining: Math.max(0, limit - used),
+      windowStart: crossing.start,
+      resetsAt: crossing.resetsAt,
+      userId: subject.userId,
+      ...subject.chatId !== void 0 && { chatId: subject.chatId }
+    };
+    const report = (failure) => logError(`onMessageThreshold \u0443\u043F\u0430\u043B (\u043E\u043A\u043D\u043E ${window.id}, \u043F\u043E\u0440\u043E\u0433 ${threshold}): ${failure instanceof Error ? failure.message : String(failure)}`);
+    try {
+      void Promise.resolve(options.onMessageThreshold(event)).catch(report);
+    } catch (failure) {
+      report(failure);
+    }
+  }
+  function shortOfReserve(readings) {
+    const reserve = turn?.minRemainingUsd;
+    if (reserve === void 0 || readings.some((reading) => reading.state === "exhausted")) return null;
+    const short = readings.filter((reading) => remainingOf(reading) < reserve - 1e-9);
+    if (short.length === 0) return null;
+    return short.reduce((least, reading) => remainingOf(reading) < remainingOf(least) ? reading : least);
+  }
+  async function readMessages(subject, limits) {
+    if (messageWindows.length === 0) return [];
+    const moment = now();
+    const readings = await Promise.all(
+      messageWindows.map((window) => {
+        const limit = limits.get(window.id);
+        return limit === void 0 ? null : readMessageWindow({ window, subject, limit, now: moment, store, warnAt });
+      })
+    );
+    return readings.filter((reading) => reading !== null);
+  }
+  function findWindow(windowId) {
+    const window = allWindows.find((candidate) => candidate.id === windowId);
+    if (!window) throw new Error(`\u041D\u0435\u0442 \u043E\u043A\u043D\u0430 \u043B\u0438\u043C\u0438\u0442\u0430 \xAB${windowId}\xBB`);
+    return window;
+  }
+  return {
+    ...zone,
+    async assertWithinLimit({ userId, chatId, pendingUsd }) {
+      const subject = { userId, chatId };
+      const person = await personOf(userId);
+      if (person.blocked) {
+        throw new SpendingLimitReachedError({ scope: "user", period: "none", resetsAt: null, ...zone, reason: "blocked" });
+      }
+      const readings = await readAll(subject, person, { open: pendingUsd === void 0, ...pendingUsd && { pending: pendingUsd } });
+      const exhausted = readings.filter((reading) => reading.state === "exhausted");
+      const short = pendingUsd === void 0 && exhausted.length === 0 ? shortOfReserve(readings) : null;
+      if (exhausted.length > 0 || short) {
+        await saveTransitions(readings.filter((reading) => (reading.nextState?.carriedUsd ?? 0) > 0));
+      }
+      if (exhausted.length > 0) {
+        throw refusal(exhausted.reduce((latest2, reading) => resetsLater(reading, latest2) ? reading : latest2), "limit");
+      }
+      if (short) throw refusal(short, "reserve");
+      await saveTransitions(readings);
+    },
+    async status({ userId, chatId }) {
+      const subject = { userId, chatId };
+      const person = await personOf(userId);
+      const limits = await limitsFor(subject, person);
+      const [readings, messageReadings] = await Promise.all([readAll(subject, person, { open: false, limits }), readMessages(subject, limits)]);
+      const marked = messageWindows.length > 0;
+      const windowStatuses = legacy ? void 0 : [...readings.map((reading) => toWindowStatus(reading, marked)), ...messageReadings.map(toMessageWindowStatus)];
+      const listed = windowStatuses ? { windows: windowStatuses } : {};
+      if (person.blocked) return { state: "exhausted", reason: "blocked", blocked: true, ...zone, ...listed };
+      const judged = [...readings, ...messageReadings];
+      if (judged.length === 0) return { state: "ok", ...listed };
+      const short = shortOfReserve(readings);
+      const worst = short ?? judged.reduce((current, reading) => isWorse(reading, current) ? reading : current);
+      const state = short ? "exhausted" : worst.state;
+      const { window } = worst;
+      return {
+        state,
+        ...!legacy && state === "exhausted" && { reason: short ? "reserve" : "limit" },
+        scope: window.scope,
+        period: window.period,
+        share: worst.share,
+        resetsAt: worst.resetsAt,
+        ...zone,
+        ...!legacy && { windowId: window.id, ...window.hours !== void 0 && { hours: window.hours } },
+        ..."used" in worst && { unit: "messages", remaining: Math.max(0, worst.limit - worst.used) },
+        ...listed
+      };
+    },
+    async chatDeleted({ userId, chatId }) {
+      const keys = allWindows.filter((window) => window.scope === "chat").map((window) => windowStateKey(window, { userId, chatId }));
+      await storage.deleteSpendingLimitStates?.(keys);
+    },
+    async takeMessage({ userId, chatId }) {
+      if (messageWindows.length === 0) return void 0;
+      const subject = { userId, chatId };
+      const limits = await limitsFor(subject, await personOf(userId));
+      const limited = messageWindows.flatMap((window) => {
+        const limit = limits.get(window.id);
+        return limit === void 0 ? [] : [{ window, limit }];
+      });
+      if (limited.length === 0) return void 0;
+      const { taken, refused, crossed } = await takeMessageSlots({
+        windows: limited,
+        subject,
+        now: now(),
+        store,
+        thresholds: options.onMessageThreshold ? thresholds : []
+      });
+      if (refused.length > 0) {
+        const latest2 = refused.reduce((current, candidate) => resetsLater(candidate, current) ? candidate : current);
+        const { window } = latest2;
+        throw new SpendingLimitReachedError({
+          scope: window.scope,
+          period: window.period,
+          resetsAt: latest2.resetsAt,
+          ...zone,
+          reason: "limit",
+          windowId: window.id,
+          ...window.hours !== void 0 && { hours: window.hours },
+          unit: "messages"
+        });
+      }
+      for (const crossing of crossed) notifyMessageThreshold(crossing, subject);
+      return taken.length > 0 ? () => giveBackMessageSlots(store, taken) : void 0;
+    },
+    async turnRules({ userId, chatId }) {
+      if (!turn) return void 0;
+      let maxCostUsd = turn.maxCostUsd;
+      if (turn.overrun === "stop") {
+        const readings = await readAll({ userId, chatId }, await personOf(userId), { open: false });
+        for (const reading of readings) {
+          if (reading.limitUsd === null) continue;
+          maxCostUsd = Math.min(maxCostUsd ?? Infinity, remainingOf(reading));
+        }
+      }
+      const rules = {
+        ...maxCostUsd !== void 0 && Number.isFinite(maxCostUsd) && { maxCostUsd },
+        ...turn.maxToolCalls !== void 0 && { maxToolCalls: turn.maxToolCalls }
+      };
+      return Object.keys(rules).length > 0 ? rules : void 0;
+    },
+    async afterSpending({ userId, chatId }) {
+      const subject = { userId, chatId };
+      const readings = await readAll(subject, await personOf(userId), { open: false });
+      await saveTransitions(readings);
+      await Promise.all(readings.map((reading) => notifyThresholds(reading, subject)));
+    },
+    async getSpending({ userId, chatId }) {
+      const subject = { userId, ...chatId !== void 0 && { chatId } };
+      const person = await personOf(userId);
+      const limits = await limitsFor(subject, person);
+      const readings = await readAll(subject, person, { open: false, limits, withoutLimit: (window) => legacy && (window.scope === "user" || chatId !== void 0) });
+      const firstOf = (scope) => readings.find((reading) => reading.window.scope === scope);
+      const user = firstOf("user");
+      const chat = chatId === void 0 ? void 0 : firstOf("chat");
+      const report = {
+        user: user ? toScopeSpending(user) : await unlimitedUser(userId),
+        ...chat && { chat: toScopeSpending(chat) },
+        ...zone
+      };
+      if (legacy) return report;
+      const messages = messageWindows.length > 0 && { messageWindows: (await readMessages(subject, limits)).map(toMessageWindowSpending) };
+      return { ...report, windows: readings.filter((reading) => reading.limitUsd !== null).map(toWindowSpending), ...messages, blocked: person.blocked === true };
+    },
+    async getUserSettings(userId) {
+      const person = store ? await personOf(userId) : {};
+      return { blocked: person.blocked === true, limits: { ...person.limits } };
+    },
+    async setUserSettings(userId, patch) {
+      const state = requireStore();
+      if (legacy && patch.limits && Object.keys(patch.limits).length > 0) {
+        throw new Error("\u0421\u0432\u043E\u0438 \u043B\u0438\u043C\u0438\u0442\u044B \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u0437\u0430\u0434\u0430\u044E\u0442\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u0434\u043B\u044F \u043E\u043A\u043E\u043D (windows); \u0441 budget \u043B\u0438\u043C\u0438\u0442 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u2014 \u0432 \u0441\u0430\u043C\u043E\u0439 \u0444\u0443\u043D\u043A\u0446\u0438\u0438 budget");
+      }
+      for (const [windowId, amount] of Object.entries(patch.limits ?? {})) {
+        const window = findWindow(windowId);
+        if (window.scope === "service") throw new Error(`\u041E\u043A\u043D\u043E \xAB${windowId}\xBB \u2014 \u043E\u0431\u0449\u0435\u0435 \u0434\u043B\u044F \u0441\u0435\u0440\u0432\u0438\u0441\u0430: \u0441\u0432\u043E\u0435\u0433\u043E \u043B\u0438\u043C\u0438\u0442\u0430 \u0443 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u0432 \u043D\u0451\u043C \u043D\u0435\u0442`);
+        if (amount !== null && amount !== "default") validLimit(amount, window.measure, `\u0421\u0432\u043E\u0439 \u043B\u0438\u043C\u0438\u0442 \u043E\u043A\u043D\u0430 \xAB${windowId}\xBB (\u0447\u0438\u0441\u043B\u043E, null \u0438\u043B\u0438 "default")`);
+      }
+      const { value } = await state.update(`person:${userId}`, (current) => {
+        const limits = { ...current?.limits };
+        for (const [windowId, amount] of Object.entries(patch.limits ?? {})) {
+          if (amount === "default") delete limits[windowId];
+          else limits[windowId] = amount;
+        }
+        return { blocked: patch.blocked ?? current?.blocked ?? false, limits };
+      });
+      return { blocked: value?.blocked === true, limits: { ...value?.limits } };
+    },
+    async resetWindow({ windowId, userId, chatId }) {
+      const state = requireStore();
+      const window = findWindow(windowId);
+      if (window.scope === "user" && userId === void 0) throw new Error(`\u041E\u043A\u043D\u043E \xAB${windowId}\xBB \u2014 \u043E\u043A\u043D\u043E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430: \u043D\u0443\u0436\u0435\u043D userId`);
+      if (window.scope === "chat" && chatId === void 0) throw new Error(`\u041E\u043A\u043D\u043E \xAB${windowId}\xBB \u2014 \u043E\u043A\u043D\u043E \u0447\u0430\u0442\u0430: \u043D\u0443\u0436\u0435\u043D chatId`);
+      const subject = { userId: userId ?? "", ...chatId !== void 0 && { chatId } };
+      const key = windowStateKey(window, subject);
+      const resetAt = now().toISOString();
+      await state.update(key, () => {
+        if (window.kind === "rolling") return { start: null, carriedUsd: 0, notified: [] };
+        const reading = currentStart(window, now());
+        return { start: reading, carriedUsd: 0, resetAt, notified: [] };
+      });
+    }
+  };
+  async function unlimitedUser(userId) {
+    const spentUsd = await sumSince({ ownerId: userId }, null);
+    return { limitUsd: null, spentUsd, remainingUsd: null, share: null, state: "ok", period: "none", periodStart: null, resetsAt: null };
+  }
+}
+function currentStart(window, moment) {
+  if (window.kind !== "calendar") return null;
+  return readWindowStart(window, moment);
+}
+function readWindowStart(window, moment) {
+  return calendarBounds(window.unit, moment, window.timeZone, window.weekStartsOn).start;
+}
+function legacyWindows(period, timeZone) {
+  const periods = typeof period === "object" ? { user: period.user ?? DEFAULT_PERIOD, chat: period.chat ?? DEFAULT_PERIOD } : { user: period ?? DEFAULT_PERIOD, chat: period ?? DEFAULT_PERIOD };
+  return ["user", "chat"].map((scope) => {
+    const scopePeriod = periods[scope];
+    const base = { id: scope, scope, carryOverrun: false, measure: "usd", weekStartsOn: 1, timeZone: timeZone ?? "UTC", limit: async () => void 0 };
+    if (scopePeriod === "none") return { ...base, kind: "total", period: "none" };
+    if (scopePeriod !== "day" && scopePeriod !== "month" && scopePeriod !== "week") {
+      throw new Error(`period: ${String(scopePeriod)} \u2014 \u0434\u043B\u044F budget \u0442\u043E\u043B\u044C\u043A\u043E month, week, day \u0438\u043B\u0438 none; \u0441\u043A\u043E\u043B\u044C\u0437\u044F\u0449\u0438\u0435 \u043E\u043A\u043D\u0430 \u2014 \u0447\u0435\u0440\u0435\u0437 windows`);
+    }
+    return { ...base, kind: "calendar", unit: scopePeriod, period: scopePeriod };
+  });
+}
+function checkedTimeZone(timeZone) {
+  if (timeZone === void 0) return void 0;
+  if (resolveTimeZone2(timeZone) === void 0) {
+    throw new Error(`timeZone: \xAB${String(timeZone)}\xBB \u2014 \u043D\u0435 \u0447\u0430\u0441\u043E\u0432\u043E\u0439 \u043F\u043E\u044F\u0441 IANA; \u043D\u0443\u0436\u0435\u043D, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440, \xABEurope/Moscow\xBB`);
+  }
+  return timeZone;
+}
+function checkedThresholds(thresholds) {
+  const list = [...thresholds ?? DEFAULT_THRESHOLDS];
+  for (const threshold of list) {
+    if (!(Number.isFinite(threshold) && threshold > 0 && threshold <= 1)) {
+      throw new Error(`thresholds: \u0434\u043E\u043B\u0438 \u043B\u0438\u043C\u0438\u0442\u0430 \u0431\u043E\u043B\u044C\u0448\u0435 0 \u0438 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 1, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(threshold)}`);
+    }
+  }
+  return [...new Set(list)].sort((a, b) => a - b);
+}
+function checkedTurnRules(turn) {
+  if (!turn) return void 0;
+  for (const field of ["minRemainingUsd", "maxCostUsd"]) {
+    const amount = turn[field];
+    if (amount !== void 0 && !(Number.isFinite(amount) && amount >= 0)) throw new Error(`turn.${field}: \u043D\u0435\u043E\u0442\u0440\u0438\u0446\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u0434\u043E\u043B\u043B\u0430\u0440\u043E\u0432, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(amount)}`);
+  }
+  if (turn.maxToolCalls !== void 0 && !(Number.isInteger(turn.maxToolCalls) && turn.maxToolCalls >= 0)) {
+    throw new Error(`turn.maxToolCalls: \u0446\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u043E\u0442 0, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(turn.maxToolCalls)}`);
+  }
+  if (turn.overrun !== void 0 && turn.overrun !== "finish" && turn.overrun !== "stop") {
+    throw new Error(`turn.overrun: finish \u0438\u043B\u0438 stop, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${String(turn.overrun)}`);
+  }
+  return turn;
+}
+function findUnpricedModels(catalog) {
+  const missing = [];
+  for (const model of catalog.models) {
+    for (const providerId of Object.keys(model.providerModelIds)) {
+      if (!model.pricing?.[providerId]) missing.push(`${model.id} \xD7 ${providerId}`);
+    }
+  }
+  return missing;
+}
+function remainingOf(reading) {
+  return reading.limitUsd === null ? Infinity : reading.limitUsd - reading.spentUsd;
+}
+function resetsLater(candidate, current) {
+  if (candidate.resetsAt === null) return current.resetsAt !== null;
+  if (current.resetsAt === null) return false;
+  return candidate.resetsAt > current.resetsAt;
+}
+function isWorse(candidate, current) {
+  const bySeverity = STATE_SEVERITY[candidate.state] - STATE_SEVERITY[current.state];
+  if (bySeverity !== 0) return bySeverity > 0;
+  return (candidate.share ?? 0) > (current.share ?? 0);
+}
+function toWindowStatus(reading, marked) {
+  const { window } = reading;
+  return {
+    id: window.id,
+    scope: window.scope,
+    period: window.period,
+    ...window.hours !== void 0 && { hours: window.hours },
+    state: reading.state,
+    share: reading.share ?? 0,
+    resetsAt: reading.resetsAt,
+    ...marked && { unit: "usd" }
+  };
+}
+function toMessageWindowStatus(reading) {
+  const { window } = reading;
+  return {
+    id: window.id,
+    scope: window.scope,
+    period: window.period,
+    ...window.hours !== void 0 && { hours: window.hours },
+    state: reading.state,
+    share: reading.share,
+    resetsAt: reading.resetsAt,
+    unit: "messages",
+    limit: reading.limit,
+    used: reading.used,
+    remaining: Math.max(0, reading.limit - reading.used)
+  };
+}
+function toMessageWindowSpending(reading) {
+  const { window } = reading;
+  return {
+    id: window.id,
+    scope: window.scope,
+    period: window.period,
+    ...window.hours !== void 0 && { hours: window.hours },
+    limit: reading.limit,
+    used: reading.used,
+    remaining: Math.max(0, reading.limit - reading.used),
+    share: reading.share,
+    state: reading.state,
+    start: reading.start,
+    resetsAt: reading.resetsAt
+  };
+}
+function toWindowSpending(reading) {
+  const { window } = reading;
+  return {
+    id: window.id,
+    scope: window.scope,
+    period: window.period,
+    ...window.hours !== void 0 && { hours: window.hours },
+    limitUsd: reading.limitUsd,
+    spentUsd: reading.spentUsd,
+    remainingUsd: Math.max(0, reading.limitUsd - reading.spentUsd),
+    share: reading.share,
+    state: reading.state,
+    start: reading.start,
+    resetsAt: reading.resetsAt,
+    carriedUsd: reading.carriedUsd
+  };
+}
+function toScopeSpending(reading) {
+  return {
+    limitUsd: reading.limitUsd,
+    spentUsd: reading.spentUsd,
+    remainingUsd: reading.limitUsd === null ? null : Math.max(0, reading.limitUsd - reading.spentUsd),
+    share: reading.share,
+    state: reading.state,
+    period: reading.window.period,
+    periodStart: reading.start,
+    resetsAt: reading.resetsAt
+  };
+}
+export {
+  createSpendingLimits
+};
+//# sourceMappingURL=index.js.map