@bytesbrains/cruise 0.0.0-stage → 0.12.0

package/dist/chunk-LALZUKEC.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/d1-util.ts
+var D1_TRANSIENT_PATTERN = /network connection lost/i;
+var RETRY_ATTEMPTS = 2;
+var RETRY_DELAY_MS = 50;
+async function withD1Retry(fn) {
+  let lastError;
+  for (let attempt = 0; attempt <= RETRY_ATTEMPTS; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!D1_TRANSIENT_PATTERN.test(message)) throw err;
+      lastError = err;
+      if (attempt < RETRY_ATTEMPTS) {
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/capabilities.ts
+function requiredCapabilities(body) {
+  const needed = [];
+  const hasTools = Array.isArray(body.tools) && body.tools.length > 0;
+  if (hasTools) needed.push("tools");
+  if (body.parallel_tool_calls === true) needed.push("parallel_tool_calls");
+  if (hasTools && forcesToolChoice(body.tool_choice)) needed.push("tool_choice_forced");
+  if (asksToSearch(body)) needed.push("web_search");
+  if (body.stream === true) needed.push("streaming");
+  const format = body.response_format;
+  if (format?.type === "json_schema") needed.push("json_schema");
+  if (Array.isArray(body.messages)) {
+    for (const message of body.messages) {
+      if (!Array.isArray(message?.content)) continue;
+      for (const part of message.content) {
+        if (part?.type === "image_url" || part?.type === "input_image") {
+          needed.push("vision");
+          break;
+        }
+      }
+      if (needed.includes("vision")) break;
+    }
+  }
+  return needed;
+}
+function forcesToolChoice(choice) {
+  if (choice === "required") return true;
+  return typeof choice === "object" && choice !== null && choice.type === "function";
+}
+function asksToSearch(body) {
+  if (Array.isArray(body.tools)) {
+    for (const tool of body.tools) {
+      if (typeof tool?.type === "string" && tool.type.startsWith("web_search")) return true;
+    }
+  }
+  return body.web_search_options !== void 0 && body.web_search_options !== null;
+}
+
+// src/routing.ts
+var MODALITIES = ["chat", "image", "speech", "embedding"];
+var flag = (value) => value === null ? null : value === 1;
+function toRoutedModel(row) {
+  return {
+    id: row.id,
+    upstreamId: row.upstream_id,
+    upstreamModel: row.upstream_model,
+    upstreamKind: row.upstream_kind,
+    upstreamBaseUrl: row.upstream_base_url,
+    upstreamPathPrefix: row.upstream_path_prefix,
+    enabled: row.enabled === 1,
+    modality: row.modality,
+    pricedBy: row.priced_by,
+    tools: flag(row.tools),
+    parallelToolCalls: flag(row.parallel_tool_calls),
+    streaming: flag(row.streaming),
+    usageReported: flag(row.usage_reported),
+    vision: flag(row.vision),
+    jsonSchema: flag(row.json_schema),
+    toolChoiceForced: flag(row.tool_choice_forced),
+    webSearch: flag(row.web_search),
+    maxContext: row.max_context,
+    maxOutput: row.max_output,
+    maxInputChars: row.max_input_chars,
+    dimensions: row.dimensions,
+    defaultOutput: row.default_output,
+    dataRetention: row.data_retention,
+    measuredAt: row.measured_at,
+    measurementNote: row.measurement_note ?? null,
+    measurementSource: row.measurement_source,
+    createdAt: row.created_at
+  };
+}
+var SELECT_MODEL = `SELECT m.id, m.upstream_id, m.upstream_model, m.enabled, m.modality, m.priced_by,
+              m.tools, m.parallel_tool_calls, m.streaming, m.usage_reported, m.vision, m.json_schema, m.tool_choice_forced, m.web_search,
+              m.max_context, m.max_output, m.max_input_chars, m.dimensions,
+              COALESCE(m.default_output, u.default_output) AS default_output,
+              m.data_retention, m.measured_at,
+              m.measurement_source, m.measurement_note, m.created_at, u.kind AS upstream_kind,
+              u.base_url AS upstream_base_url, u.provider_path_prefix AS upstream_path_prefix
+         FROM models m
+         JOIN upstreams u ON u.id = m.upstream_id
+        WHERE u.enabled = 1`;
+async function lookupModel(db, id) {
+  const row = await withD1Retry(() => db.prepare(`${SELECT_MODEL} AND m.id = ?`).bind(id).first());
+  return row === null ? null : toRoutedModel(row);
+}
+var MEASUREMENT_MAX_AGE_DAYS = 30;
+var FRESHLY_MEASURED_SQL = `measured_at IS NOT NULL
+        AND julianday('now') - julianday(measured_at) <= ${MEASUREMENT_MAX_AGE_DAYS}`;
+function checkLimits(model, body) {
+  const requested = body.max_tokens ?? body.max_completion_tokens;
+  if (typeof requested !== "number") return { ok: true };
+  if (model.maxOutput !== null && requested > model.maxOutput) {
+    return {
+      ok: false,
+      message: `Model '${model.id}' supports at most ${model.maxOutput} output tokens, and ${requested} were requested.`
+    };
+  }
+  if (model.maxOutput === null && model.maxContext !== null && requested > model.maxContext) {
+    return {
+      ok: false,
+      message: `Model '${model.id}' has a context window of ${model.maxContext} tokens, and ${requested} output tokens were requested. No separate output limit is published for it.`
+    };
+  }
+  return { ok: true };
+}
+
+export {
+  requiredCapabilities,
+  MODALITIES,
+  lookupModel,
+  checkLimits
+};

package/dist/chunk-N3YKWKOA.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/demo-catalogue.ts
+var DEMO_ENVIRONMENT = "demo";
+
+export {
+  DEMO_ENVIRONMENT
+};

package/dist/chunk-O7TNRKSA.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.

package/dist/chunk-RT4R2W6H.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/demo-charge.ts
+function demoChargeStatements(db, projectId, micros, actor) {
+  if (!Number.isInteger(micros) || micros < 0) throw new Error(`demo charge must be integer micros >= 0, got ${micros}`);
+  return [
+    db.prepare(
+      `UPDATE budgets SET demo_charge_micros = ?2, reserve_micros = 0, updated_by = ?3, updated_at = datetime('now')
+          WHERE scope = 'project' AND subject = ?1`
+    ).bind(projectId, micros, actor),
+    db.prepare(
+      `INSERT INTO audit_events (id, actor, action, subject, detail, tenant_id)
+         SELECT ?1, ?2, 'budget.demo_charge', ?3, ?4, (SELECT tenant_id FROM projects WHERE id = ?3)`
+    ).bind(crypto.randomUUID(), actor, projectId, JSON.stringify({ demo_charge_micros: micros, reserve_micros: 0 }))
+  ];
+}
+
+export {
+  demoChargeStatements
+};

package/dist/chunk-SYTYOTO4.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  sha256Hex
+} from "./chunk-5TVD3ZAI.mjs";
+
+// src/reliability.ts
+var RATE_LIMIT_COOLDOWN_MS = 5 * 6e4;
+
+// src/affinity.ts
+var SESSION_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var isSessionId = (raw) => SESSION_RE.test(raw);
+var sessionDigest = (session) => sha256Hex(session);
+
+export {
+  isSessionId,
+  sessionDigest
+};

package/dist/chunk-T3ICD43U.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/cache-pool.ts
+var CACHE_POOLS = ["platform", "tenant", "project"];
+var DEFAULT_CACHE_POOL = "project";
+function isCachePool(value) {
+  return typeof value === "string" && CACHE_POOLS.includes(value);
+}
+
+export {
+  CACHE_POOLS,
+  DEFAULT_CACHE_POOL,
+  isCachePool
+};

package/dist/chunk-THEXUHQC.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/budget.ts
+var MICROS_PER_USD = 1e6;
+function usdToMicros(usd) {
+  return Math.round(usd * MICROS_PER_USD);
+}
+function microsToUsd(micros) {
+  return micros / MICROS_PER_USD;
+}
+function formatUsd(micros, decimals = 2) {
+  return microsToUsd(micros).toFixed(decimals);
+}
+function periodStartExpr(period) {
+  if (period === "minute") return `strftime('%Y-%m-%d %H:%M', 'now')`;
+  return period === "month" ? `strftime('%Y-%m-01', 'now')` : `date('now')`;
+}
+async function readBudget(db, projectId) {
+  const configured = await db.prepare(
+    `SELECT b.period, b.soft_micros, b.hard_micros, b.session_hard_micros, p.budget_behaviour
+         FROM projects p
+         LEFT JOIN budgets b ON b.scope = 'project' AND b.subject = p.id
+        WHERE p.id = ?`
+  ).bind(projectId).first();
+  if (configured === null) return null;
+  const period = configured.period ?? "day";
+  const spendRow = await db.prepare(
+    `SELECT ${periodStartExpr(period)} AS period_start,
+              COALESCE((SELECT spend_micros FROM spend
+                         WHERE scope = 'project' AND subject = ?1 AND period = ?2
+                           AND period_start = ${periodStartExpr(period)}), 0) AS spend_micros`
+  ).bind(projectId, period).first();
+  const spendMicros = spendRow?.spend_micros ?? 0;
+  const softMicros = configured.soft_micros;
+  const hardMicros = configured.hard_micros;
+  let state = "ok";
+  if (hardMicros !== null && spendMicros >= hardMicros) state = "hard";
+  else if (softMicros !== null && spendMicros >= softMicros) state = "soft";
+  const behaviour = configured.budget_behaviour;
+  let action = "serve";
+  if (state === "hard") action = behaviour === "degrade" ? "degrade" : "refuse";
+  return {
+    projectId,
+    period,
+    periodStart: spendRow?.period_start ?? "",
+    spendMicros,
+    softMicros,
+    hardMicros,
+    sessionHardMicros: configured.session_hard_micros,
+    state,
+    behaviour,
+    action
+  };
+}
+async function setBudget(db, projectId, limits, actor, also = []) {
+  const period = limits.period ?? "day";
+  await db.batch([
+    db.prepare(
+      `INSERT INTO budgets (scope, subject, period, soft_micros, hard_micros, session_hard_micros, updated_by)
+         VALUES ('project', ?1, ?2, ?3, ?4, CASE WHEN ?6 THEN ?7 END, ?5)
+         ON CONFLICT (scope, subject) DO UPDATE
+           SET period = ?2, soft_micros = ?3, hard_micros = ?4,
+               session_hard_micros = CASE WHEN ?6 THEN ?7 ELSE session_hard_micros END,
+               updated_by = ?5, updated_at = datetime('now')`
+    ).bind(
+      projectId,
+      period,
+      limits.softMicros ?? null,
+      limits.hardMicros ?? null,
+      actor,
+      limits.sessionHardMicros === void 0 ? 0 : 1,
+      limits.sessionHardMicros ?? null
+    ),
+    db.prepare(
+      `INSERT INTO audit_events (id, actor, action, subject, detail, tenant_id)
+         SELECT ?1, ?2, 'budget.set', ?3, ?4, (SELECT tenant_id FROM projects WHERE id = ?3)`
+    ).bind(
+      crypto.randomUUID(),
+      actor,
+      projectId,
+      JSON.stringify({
+        period,
+        soft_micros: limits.softMicros ?? null,
+        hard_micros: limits.hardMicros ?? null,
+        ...limits.sessionHardMicros === void 0 ? {} : { session_hard_micros: limits.sessionHardMicros }
+      })
+    ),
+    ...also
+  ]);
+}
+
+export {
+  usdToMicros,
+  formatUsd,
+  readBudget,
+  setBudget
+};

package/dist/chunk-UNXM6FSM.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/reservation-journal.ts
+var ABANDONED_AFTER_SECONDS = 2 * 60 * 60;
+var JOB_ABANDONED_AFTER_SECONDS = 48 * 60 * 60;
+async function sweepAbandonedHolds(db, now, olderThanSeconds = ABANDONED_AFTER_SECONDS, jobsOlderThanSeconds = JOB_ABANDONED_AFTER_SECONDS) {
+  const before = (seconds) => new Date(now.getTime() - seconds * 1e3).toISOString().replace("T", " ").slice(0, 19);
+  const { results } = await db.prepare(
+    `SELECT id FROM reservations
+        WHERE (job_id IS NULL AND at < ?1) OR (job_id IS NOT NULL AND at < ?2)
+        ORDER BY at`
+  ).bind(before(olderThanSeconds), before(jobsOlderThanSeconds)).all();
+  let swept = 0;
+  for (const { id } of results) {
+    const claim = await db.prepare(`UPDATE reservations SET swept_at = COALESCE(swept_at, datetime('now')) WHERE id = ?`).bind(id).run();
+    if ((claim.meta.changes ?? 0) === 0) continue;
+    const closing = await db.batch([
+      db.prepare(
+        `INSERT OR IGNORE INTO ledger
+             (id, at, tenant_id, project_id, traffic_class, lane, account, model, upstream_id, key_prefix,
+              cost_micros, list_micros, priced, outcome, streamed, requested_model, session_digest)
+           SELECT r.id, r.at, p.tenant_id, r.project_id, r.traffic_class, r.lane, r.account, r.model,
+                  r.upstream_id, r.key_prefix, r.reserved_micros, r.reserved_micros, 0, 'no_usage',
+                  r.streamed, r.requested_model,
+                  -- The run's digest is the subject's tail (sessionSubject), so
+                  -- an abandoned turn still counts toward its run (#651, #617).
+                  substr(r.session_subject, -64)
+             FROM reservations r JOIN projects p ON p.id = r.project_id
+            WHERE r.id = ?`
+      ).bind(id),
+      // At the hold's own time, so reconcile counts it in the window it drifted.
+      db.prepare(
+        `INSERT OR IGNORE INTO reservation_failures (id, at, project_id, reserved, stage, detail)
+           SELECT 'abandoned:' || r.id, r.at, r.project_id, r.reserved_micros, 'abandoned',
+                  'never settled; ledger row ' || r.id || ' charged the hold'
+             FROM reservations r WHERE r.id = ?`
+      ).bind(id),
+      // A job whose hold is abandoned is a job nothing is running (#714): it
+      // fails, and its hook is owed that news. Before the delete, because the
+      // job is found through the row; a hold with no job matches nothing.
+      db.prepare(
+        `UPDATE jobs
+              SET status = 'failed', error = 'abandoned: its hold outlived the job threshold unsettled',
+                  completed_at = datetime('now'), updated_at = datetime('now'),
+                  delivery = CASE WHEN webhook_endpoint_id IS NULL THEN delivery ELSE 'pending' END,
+                  next_delivery_at = CASE WHEN webhook_endpoint_id IS NULL THEN next_delivery_at ELSE datetime('now') END
+            WHERE id = (SELECT job_id FROM reservations WHERE id = ?1)
+              AND status IN ('queued', 'running')
+              AND EXISTS (SELECT 1 FROM ledger WHERE id = ?1)`
+      ).bind(id),
+      db.prepare(`DELETE FROM reservations WHERE id = ?1 AND EXISTS (SELECT 1 FROM ledger WHERE id = ?1)`).bind(id)
+    ]);
+    if ((closing[closing.length - 1]?.meta.changes ?? 0) > 0) swept++;
+  }
+  return swept;
+}
+
+// src/session-budget.ts
+var SESSION_IDLE_DAYS = 30;
+async function pruneIdleSessions(db) {
+  const result = await db.prepare(
+    `DELETE FROM spend
+        WHERE scope = 'session' AND updated_at < datetime('now', ?1)
+          AND NOT EXISTS (SELECT 1 FROM reservations r WHERE r.session_subject = spend.subject)`
+  ).bind(`-${SESSION_IDLE_DAYS} days`).run();
+  return result.meta.changes ?? 0;
+}
+
+// src/ratelimit.ts
+var WINDOW_SECONDS = 60;
+async function sweepRateBuckets(db, now) {
+  const bucket = Math.floor(Math.floor(now.getTime() / 1e3) / WINDOW_SECONDS);
+  const result = await db.prepare(`DELETE FROM rate_buckets WHERE bucket < ?`).bind(bucket - 1).run();
+  return result.meta.changes ?? 0;
+}
+
+export {
+  sweepAbandonedHolds,
+  SESSION_IDLE_DAYS,
+  pruneIdleSessions,
+  sweepRateBuckets
+};

package/dist/chunk-WS6NFRIU.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  MODALITIES
+} from "./chunk-LALZUKEC.mjs";
+
+// src/conformance-plan.ts
+function shardOf(items, index, total) {
+  if (!Number.isInteger(total) || total < 1) throw new Error(`--shard total must be a positive integer, got ${total}`);
+  if (!Number.isInteger(index) || index < 1 || index > total) {
+    throw new Error(`--shard index must be between 1 and ${total}, got ${index}`);
+  }
+  return items.filter((_, i) => i % total === index - 1);
+}
+function planShard(models, index, total) {
+  const stable = [...models].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return shardOf(stable, index, total).sort(stalestFirst);
+}
+function stalestFirst(a, b) {
+  if (a.measured_at === b.measured_at) return a.id < b.id ? -1 : 1;
+  if (a.measured_at === null) return -1;
+  if (b.measured_at === null) return 1;
+  return a.measured_at < b.measured_at ? -1 : 1;
+}
+function selectModels(models, selection) {
+  const ids = selection.ids ?? [];
+  const modalities = selection.modalities ?? [];
+  const unknown = modalities.filter((m) => !MODALITIES.includes(m));
+  if (unknown.length > 0) {
+    throw new Error(`--modality does not know ${unknown.join(", ")}. The closed set is ${MODALITIES.join(", ")}.`);
+  }
+  const present = new Set(models.map((m) => m.id));
+  const missing = ids.filter((id) => !present.has(id));
+  if (missing.length > 0) {
+    throw new Error(
+      `--models names ${missing.join(", ")}, which no enabled model on an enabled upstream matches. A run that quietly skipped them would report as a run that passed.`
+    );
+  }
+  const wanted = new Set(ids);
+  const chosen = models.filter(
+    (m) => (ids.length === 0 || wanted.has(m.id)) && (modalities.length === 0 || modalities.includes(m.modality))
+  );
+  if (chosen.length === 0 && (ids.length > 0 || modalities.length > 0)) {
+    throw new Error(
+      `no enabled model matches ${[ids.length > 0 ? `--models ${ids.join(",")}` : "", modalities.length > 0 ? `--modality ${modalities.join(",")}` : ""].filter((part) => part !== "").join(" and ")}.`
+    );
+  }
+  return chosen;
+}
+function listFlag(raw, flag) {
+  if (raw === void 0) return void 0;
+  if (raw === true || raw.trim() === "") {
+    throw new Error(`--${flag} needs a comma-separated value. Given nothing, it would run as though it were absent.`);
+  }
+  const parts = raw.split(",").map((part) => part.trim());
+  if (parts.some((part) => part === "")) {
+    throw new Error(`--${flag} has an empty entry in '${raw}'. An unset shell variable reads exactly like this.`);
+  }
+  return parts;
+}
+
+export {
+  planShard,
+  selectModels,
+  listFlag
+};

package/dist/chunk-XOH3XKM3.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/ledger-components.ts
+async function spendByComponent(db, month, tenantId) {
+  const scope = tenantId === void 0 ? "" : "AND l.tenant_id = ?2";
+  const window = `(?1 = 'all' OR strftime('%Y-%m', l.at) = ?1)`;
+  const statement = db.prepare(
+    `SELECT CASE WHEN c.variant = '' THEN c.component ELSE c.component || ':' || c.variant END AS bucket,
+            count(DISTINCT l.id) AS requests,
+            COALESCE(sum(c.micros), 0) AS micros,
+            COALESCE(sum(c.micros), 0) AS listMicros,
+            0 AS tokens,
+            COALESCE(sum(c.count), 0) AS units
+       FROM ledger_components c
+       JOIN ledger l ON l.id = c.ledger_id
+      WHERE ${window} ${scope}
+      GROUP BY bucket
+      ORDER BY micros DESC`
+  );
+  const { results } = await (tenantId === void 0 ? statement.bind(month) : statement.bind(month, tenantId)).all();
+  return results;
+}
+
+// src/ledger.ts
+function outcomeOf(body, priced, hadUsage) {
+  const choice = body?.choices?.[0];
+  if (choice?.message?.refusal != null) return "refusal";
+  if (String(choice?.finish_reason ?? "").toLowerCase().includes("refus")) return "refusal";
+  const content = typeof choice?.message?.content === "string" ? choice.message.content : "";
+  if (content.trim() === "" && String(choice?.finish_reason ?? "") !== "tool_calls") return "empty";
+  if (!hadUsage) return "no_usage";
+  return priced ? "served" : "unpriced";
+}
+var ALL_MONTHS = "all";
+var MONTH_PATTERN = "\\d{4}-(0[1-9]|1[0-2])";
+var CALENDAR_MONTH = new RegExp(`^${MONTH_PATTERN}$`);
+var GROUPABLE = /* @__PURE__ */ new Set([
+  "project_id",
+  "model",
+  "account",
+  "lane",
+  "traffic_class",
+  "upstream_id",
+  "outcome",
+  // The hit rate beside the discount it earned (#98): requests per status,
+  // and `micros` against `listMicros` is what the discount came to.
+  "cache_status",
+  // How wide the cache that answered was allowed to be (#276, 0068). Every
+  // miss buckets under NULL, so this is the hit breakdown rather than a
+  // second spelling of `cache_status`: it is the dimension that tells a
+  // model-scope saving from a lane-scope one, and those are different
+  // products — one is a repeat, the other is an answer somebody else paid
+  // for. Blending them would report the second as the first.
+  "cache_scope",
+  // What has this key spent (#147 gap 3, asked for by the dashboard).
+  //
+  // The first question anyone asks before revoking a key, and the second one
+  // after a leak — where the answer decides whether it is an inconvenience or
+  // an incident. The dashboard could issue a key and revoke a key and could
+  // not answer it.
+  //
+  // The bucket is the **prefix**, which is the half designed to be seen: it is
+  // what a key listing returns, what `audit_events.actor` records, and what a
+  // leaked string is classified by on sight. The key itself is stored hashed
+  // and is not here to leak.
+  //
+  // A revoked key keeps its rows and keeps answering, which is the point. The
+  // ledger references ids that must outlive the thing they name, so "what did
+  // the key I just revoked spend" is a question with an answer rather than a
+  // gap where the row used to be.
+  "key_prefix",
+  // Not a column of `ledger` at all (#228): the per-unit lines a request's
+  // total is made of, from `ledger_components`. Answered by its own query
+  // because it joins a child table, and listed here so the refusal below
+  // names every dimension there is.
+  "component"
+]);
+async function spendBy(db, dimension, month, tenantId) {
+  if (!GROUPABLE.has(dimension)) {
+    throw new Error(`Cannot group by '${dimension}'. Try one of: ${[...GROUPABLE].join(", ")}`);
+  }
+  if (dimension === "component") return spendByComponent(db, month, tenantId);
+  const scope = tenantId === void 0 ? "" : "AND tenant_id = ?2";
+  const window = `(?1 = '${ALL_MONTHS}' OR strftime('%Y-%m', at) = ?1)`;
+  const statement = db.prepare(
+    `SELECT ${dimension} AS bucket,
+            count(*) AS requests,
+            COALESCE(sum(cost_micros), 0) AS micros,
+            COALESCE(sum(list_micros), 0) AS listMicros,
+            COALESCE(sum(prompt_tokens + completion_tokens), 0) AS tokens,
+            NULL AS units
+       FROM ledger
+      WHERE ${window} ${scope}
+      GROUP BY ${dimension}
+      ORDER BY micros DESC`
+  );
+  const { results } = await (tenantId === void 0 ? statement.bind(month) : statement.bind(month, tenantId)).all();
+  return results;
+}
+async function effectiveRates(db, month, tenantId) {
+  const scope = tenantId === void 0 ? "" : "AND l.tenant_id = ?2";
+  const statement = db.prepare(
+    `SELECT l.model AS model,
+            count(*) AS requests,
+            CASE WHEN sum(l.prompt_tokens + l.completion_tokens) > 0
+                 THEN CAST(sum(l.list_micros) * 1000000.0
+                           / sum(l.prompt_tokens + l.completion_tokens) AS INTEGER)
+                 ELSE NULL END AS observedInputMicrosPerMtok,
+            (SELECT p.input_micros_per_mtok FROM model_prices p
+              WHERE p.model = l.model AND p.prompt_tokens_from = 0 AND p.peak_utc = ''
+              ORDER BY p.effective_from DESC LIMIT 1)
+              AS tableInputMicrosPerMtok
+       FROM ledger l
+      WHERE strftime('%Y-%m', l.at) = ?1 AND l.priced = 1 ${scope}
+      GROUP BY l.model`
+  );
+  const { results } = await (tenantId === void 0 ? statement.bind(month) : statement.bind(month, tenantId)).all();
+  return results;
+}
+
+export {
+  outcomeOf,
+  spendBy,
+  effectiveRates
+};

package/dist/compress-3DWG35BY.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import "./chunk-4447IUTF.mjs";
+import "./chunk-O7TNRKSA.mjs";
+import {
+  connect,
+  environmentOf,
+  parseArgs,
+  requireString,
+  run
+} from "./chunk-7NQHBXVZ.mjs";
+import "./chunk-JZPUTXM7.mjs";
+
+// src/compress-setting.ts
+async function setProjectCompression(db, projectId, enabled, actor) {
+  const to = enabled ? 1 : 0;
+  const [, update] = await db.batch([
+    db.prepare(
+      `INSERT INTO audit_events (id, actor, action, subject, detail, tenant_id)
+         SELECT ?1, ?2, 'project.compression', ?3,
+                json_object('from', json(CASE p.compress WHEN 1 THEN 'true' ELSE 'false' END),
+                            'to', json(CASE ?4 WHEN 1 THEN 'true' ELSE 'false' END)),
+                p.tenant_id
+           FROM projects p WHERE p.id = ?3`
+    ).bind(crypto.randomUUID(), actor, projectId, to),
+    db.prepare(`UPDATE projects SET compress = ?1 WHERE id = ?2`).bind(to, projectId)
+  ]);
+  return (update?.meta.changes ?? 0) === 0 ? null : { enabled };
+}
+
+// scripts/compress.ts
+run(async () => {
+  const [command, ...rest] = process.argv.slice(2);
+  const args = parseArgs(rest);
+  const db = connect(environmentOf(args));
+  if (command === "set") {
+    const project = requireString(args, "project");
+    const actor = requireString(args, "actor");
+    if (args.on === true === (args.off === true)) throw new Error("Pass exactly one of --on or --off.");
+    const written = await setProjectCompression(db, project, args.on === true, actor);
+    if (written === null) throw new Error(`No project with id '${project}'.`);
+    console.log(`${project}: compression ${written.enabled ? "on" : "off"}.`);
+    return;
+  }
+  const { results } = await db.prepare(`SELECT tenant_id, id, compress FROM projects WHERE compress = 1 ORDER BY tenant_id, id`).all();
+  if (results.length === 0) console.log("No project has compression switched on.");
+  for (const row of results) console.log(`${row.tenant_id.padEnd(24)} ${row.id}`);
+  console.log("\nIn effect only where the environment's COMPRESS_MODE is 'on' (wrangler.jsonc); `npm run doctor` reads it as deployed.");
+});