@hasna/economy 0.5.10 → 0.5.12

package/dist/chunks/index-pgt6fhkb.js

@@ -0,0 +1,1069 @@
+// @bun
+import {
+  syncAnthropicBilling,
+  syncGeminiBilling,
+  syncOpenAIBilling
+} from "./index-gtjqy0kd.js";
+import {
+  syncAll
+} from "./index-a5gdrfby.js";
+import {
+  MAX_INGEST_BYTES,
+  MAX_INGEST_ROWS,
+  cacheDir,
+  canonicalIngestBodyHash,
+  ensurePricingSeeded,
+  getMachineId,
+  queryZeroCostTokenizedModels,
+  rollupSession,
+  stableJson,
+  validateIngest
+} from "./index-zgvmrqyc.js";
+import {
+  __require
+} from "./index-p35cyhc4.js";
+
+// src/lib/sync-maintenance.ts
+function backfillMachineId(db) {
+  const machine = getMachineId();
+  const reqCount = db.prepare(`UPDATE requests SET machine_id = ? WHERE (machine_id = '' OR machine_id IS NULL)
+    AND NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id = requests.id)`).run(machine);
+  const sessCount = db.prepare(`UPDATE sessions SET machine_id = ? WHERE machine_id = '' OR machine_id IS NULL`).run(machine);
+  return { requests: Number(reqCount.changes), sessions: Number(sessCount.changes) };
+}
+async function recalculateZeroCostRequests(db) {
+  const { assessCostFromDb } = await import("./pricing-bn88mhqk.js");
+  const zeroRows = db.prepare(`SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cache_create_5m_tokens, cache_create_1h_tokens
+     FROM requests
+     WHERE cost_usd = 0
+       AND NOT EXISTS (SELECT 1 FROM economy_legacy_active a WHERE a.request_id = requests.id)
+       AND (input_tokens > 0 OR output_tokens > 0 OR cache_read_tokens > 0 OR cache_create_tokens > 0)`).all();
+  let fixed = 0;
+  for (const r of zeroRows) {
+    const cache5m = r.cache_create_5m_tokens ?? r.cache_create_tokens;
+    const assessment = assessCostFromDb(db, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, cache5m, r.cache_create_1h_tokens ?? 0);
+    const cost = assessment.usd;
+    if (cost !== null && cost > 0) {
+      db.prepare(`UPDATE requests SET cost_usd = ?, cost_basis = CASE WHEN cost_basis = 'unknown' THEN 'estimated' ELSE cost_basis END WHERE id = ?`).run(cost, r.id);
+      fixed++;
+    }
+  }
+  if (fixed > 0) {
+    const touchedSessions = new Set(zeroRows.map((r) => {
+      const row = db.prepare(`SELECT session_id FROM requests WHERE id = ?`).get(r.id);
+      return row?.session_id;
+    }).filter(Boolean));
+    for (const sid of touchedSessions)
+      rollupSession(db, sid);
+  }
+  return { fixed, total: zeroRows.length, buckets: queryZeroCostTokenizedModels(db, 8) };
+}
+
+// src/lib/cloud-ingest.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join4 } from "path";
+
+// src/lib/ingest-batches.ts
+import { createHash } from "crypto";
+function* ingestBatches(body) {
+  let rows = {};
+  let count = 0;
+  let bytes = 0;
+  const finish = () => {
+    const digest = createHash("sha256").update(stableJson(rows)).digest("hex");
+    const batch = { ...rows, schema_version: 1, idempotency_key: `scan-${digest}` };
+    rows = {};
+    count = 0;
+    bytes = 0;
+    if (Buffer.byteLength(JSON.stringify(batch)) > MAX_INGEST_BYTES)
+      throw new Error("Ingest batch exceeds the server byte limit");
+    return batch;
+  };
+  const rowLimit = Math.min(MAX_INGEST_ROWS, 500);
+  const byteLimit = MAX_INGEST_BYTES - 4096;
+  for (const table of Object.keys(body).sort()) {
+    const sorted = body[table].map((row) => ({ row, canonical: stableJson(row) })).sort((a, b) => a.canonical < b.canonical ? -1 : a.canonical > b.canonical ? 1 : 0);
+    for (const { row, canonical } of sorted) {
+      const size = Buffer.byteLength(canonical) + 1;
+      if (size > byteLimit)
+        throw new Error("One ingestion row exceeds the server byte limit");
+      if (count > 0 && (count >= rowLimit || bytes + size > byteLimit))
+        yield finish();
+      (rows[table] ??= []).push(row);
+      count++;
+      bytes += size;
+    }
+  }
+  if (count > 0)
+    yield finish();
+}
+
+class IngestBatchFailure extends Error {
+  pending_key;
+  completed;
+  pending_command;
+  constructor(pending_key, completed, pending_command) {
+    super("Ingest batch did not return a verified receipt; retain the exact staged command and reconcile before retrying");
+    this.pending_key = pending_key;
+    this.completed = completed;
+    this.pending_command = pending_command;
+    this.name = "IngestBatchFailure";
+  }
+}
+
+// src/lib/ingest-journal.ts
+import { constants, closeSync, fsyncSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, opendirSync, realpathSync, writeFileSync } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { join, resolve } from "path";
+import { HasnaHttpError } from "@hasna/contracts/client";
+var MAX_COMMANDS = 1000;
+var MAX_BYTES = 64 * 1024 * 1024;
+var RECEIPT_RESERVE = 4096;
+var MAINTENANCE_RESERVE = 16384;
+var sha = (s) => createHash2("sha256").update(s).digest("hex");
+
+class PendingIngestError extends Error {
+  pending_keys;
+  code = "INGEST_RECONCILIATION_REQUIRED";
+  constructor(pending_keys) {
+    super("Pending ingestion requires hosted receipt reconciliation; no command was replayed");
+    this.pending_keys = pending_keys;
+    this.name = "PendingIngestError";
+  }
+}
+function definitiveIngestRefusal(status, body) {
+  const reasons = { 400: "invalid_ingest", 409: "ingest_conflict", 413: "ingest_too_large", 422: "unprocessable_ingest" };
+  if (!Object.hasOwn(reasons, status))
+    return null;
+  const legacy = body?.expected === "legacy_aggregate_requires_migration";
+  return {
+    status,
+    code: legacy ? "legacy_aggregate_requires_migration" : "ingest_refused",
+    reason: legacy ? "legacy_aggregate_requires_migration" : reasons[status]
+  };
+}
+function getIngestJournalPath() {
+  return process.env.HASNA_ECONOMY_INGEST_JOURNAL ?? join(cacheDir({ app: "economy", home: process.env.HOME || process.env.USERPROFILE }), "pending-ingest");
+}
+function targetId(cloud) {
+  const url = new URL(cloud.client.transport.baseUrl);
+  if (url.username || url.password || url.search || url.hash)
+    throw new Error("Ingest authority must not contain URL credentials or capabilities");
+  return sha(url.toString().replace(/\/+$/, ""));
+}
+function secureDirectory(path) {
+  mkdirSync(path, { recursive: true, mode: 448 });
+  const stat = lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
+    throw new Error("Ingest journal must be a private owner directory");
+}
+function readJson(path, max) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const st = fstatSync(fd);
+    if (!st.isFile() || st.size > max || (st.mode & 63) !== 0 || process.getuid && st.uid !== process.getuid())
+      throw new Error("Unsafe ingest journal record");
+    return JSON.parse(readFileSync(fd, "utf8"));
+  } finally {
+    closeSync(fd);
+  }
+}
+function createExact(path, value) {
+  const bytes = JSON.stringify(value);
+  let fd;
+  try {
+    fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return false;
+    throw error;
+  }
+  try {
+    writeFileSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  if (JSON.stringify(readJson(path, MAX_INGEST_BYTES + 4096)) !== bytes)
+    throw new Error("Ingest journal readback failed");
+  const directory = openSync(resolve(path, ".."), constants.O_RDONLY);
+  try {
+    fsyncSync(directory);
+  } finally {
+    closeSync(directory);
+  }
+  return true;
+}
+function unwrap(raw) {
+  return raw && typeof raw === "object" && "data" in raw ? raw.data : raw;
+}
+function verifyIngestReceipt(raw, command) {
+  const receipt = unwrap(raw);
+  if (!receipt || typeof receipt !== "object" || !receipt.ingested || typeof receipt.ingested !== "object" || Array.isArray(receipt.ingested) || !Number.isSafeInteger(receipt.total) || receipt.total < 0 || typeof receipt.operation_key !== "string" || !/^[a-f0-9]{64}$/.test(receipt.operation_key) || typeof receipt.replayed !== "boolean")
+    throw new Error("Invalid ingest receipt");
+  let sum = 0;
+  for (const [table, count] of Object.entries(receipt.ingested)) {
+    if (!Array.isArray(command[table]) || typeof count !== "number" || !Number.isSafeInteger(count) || count < 0 || count > command[table].length)
+      throw new Error("Invalid ingest receipt");
+    sum += count;
+  }
+  if (sum !== receipt.total)
+    throw new Error("Invalid ingest receipt");
+  const projected = {
+    ingested: Object.fromEntries(Object.entries(receipt.ingested)),
+    total: receipt.total,
+    operation_key: receipt.operation_key,
+    replayed: receipt.replayed,
+    stale: receipt.stale ?? 0,
+    unchanged: receipt.unchanged ?? 0
+  };
+  const rows = Object.values(command).reduce((n, v) => n + (Array.isArray(v) ? v.length : 0), 0);
+  if (![projected.stale, projected.unchanged].every((n) => Number.isSafeInteger(n) && n >= 0 && n <= rows) || Buffer.byteLength(JSON.stringify(projected)) > RECEIPT_RESERVE - 256)
+    throw new Error("Invalid ingest receipt");
+  return projected;
+}
+function sameReceipt(left, right) {
+  const meaning = (value) => ({ ingested: value?.ingested, total: value?.total, operation_key: value?.operation_key, stale: value?.stale ?? 0, unchanged: value?.unchanged ?? 0 });
+  return stableJson(meaning(left)) === stableJson(meaning(right));
+}
+async function lookupJournalReceipt(cloud, key, bodyHash, timeoutMs = 1e4) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new RangeError("Receipt lookup requires a positive finite timeout");
+  const query = new URLSearchParams({ idempotency_key: key, body_hash: bodyHash });
+  const deadline = performance.now() + timeoutMs;
+  let failures = 0, lastError;
+  for (;; ) {
+    const remaining = Math.floor(deadline - performance.now());
+    if (remaining <= 0)
+      throw lastError ?? new Error("Receipt lookup deadline expired");
+    let response;
+    try {
+      const abort = new AbortController;
+      let timer;
+      try {
+        const expired = new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            abort.abort();
+            reject(new Error("Receipt lookup deadline expired"));
+          }, remaining);
+        });
+        response = await Promise.race([
+          cloud.client.transport.get(`/ingest/receipts?${query}`, { retry: false, timeoutMs: remaining, signal: abort.signal }),
+          expired
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (error) {
+      if (!(error instanceof HasnaHttpError) || error.status !== 503)
+        throw error;
+      lastError = error;
+      failures++;
+      const delay = 100 * failures;
+      if (failures >= 3 || deadline - performance.now() <= delay)
+        throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      continue;
+    }
+    if (performance.now() >= deadline)
+      throw new Error("Receipt lookup deadline expired");
+    const raw = unwrap(response);
+    if (!raw || raw.body_hash !== bodyHash)
+      throw new Error("Invalid reconciliation response");
+    if (raw.status === "absent")
+      return null;
+    if (raw.status !== "committed")
+      throw new Error("Invalid reconciliation response");
+    return raw.receipt;
+  }
+}
+
+class IngestJournal {
+  directory;
+  target;
+  inventoryBytes = 0;
+  freshlyStaged = new Set;
+  constructor(cloud, path = getIngestJournalPath()) {
+    this.target = targetId(cloud);
+    secureDirectory(path);
+    this.directory = join(realpathSync(path), this.target);
+    secureDirectory(this.directory);
+  }
+  names() {
+    const names = [];
+    const directory = opendirSync(this.directory);
+    try {
+      for (let entry;entry = directory.readSync(); ) {
+        if (entry.name === ".lease" || entry.name === ".maintenance" || entry.name === ".authority.json" || entry.name === ".recovery")
+          continue;
+        names.push(entry.name);
+        if (names.length > MAX_COMMANDS * 2)
+          throw new Error("Ingest journal capacity reached; preserve and reconcile records");
+      }
+    } finally {
+      directory.closeSync();
+    }
+    this.inventoryBytes = 0;
+    const set = new Set(names);
+    for (const name of names) {
+      if (!/^[a-f0-9]{64}\.(intent|receipt|refusal)\.json$/.test(name))
+        throw new Error("Unexpected ingest journal entry");
+      if (!name.endsWith(".intent.json") && !set.has(name.replace(/\.(receipt|refusal)\./, ".intent.")))
+        throw new Error("Orphaned ingest outcome requires maintenance recovery");
+      if (name.endsWith(".refusal.json") && set.has(name.replace(".refusal.", ".receipt.")))
+        throw new Error("Conflicting ingest receipt and refusal");
+      const stat = lstatSync(join(this.directory, name));
+      if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 63) !== 0)
+        throw new Error("Unsafe ingest journal record");
+      if (stat.size > MAX_INGEST_BYTES + 4096)
+        throw new Error("Oversized ingest journal record");
+      this.inventoryBytes += stat.size;
+      if (name.endsWith(".refusal.json"))
+        this.refusal(this.intent(name.replace(".refusal.", ".intent.")).command);
+    }
+    return names;
+  }
+  file(key, kind) {
+    return join(this.directory, `${sha(key)}.${kind}.json`);
+  }
+  intent(name) {
+    const record = readJson(join(this.directory, name), MAX_INGEST_BYTES + 4096);
+    if (record.version !== 1 || record.target !== this.target || !record.command || typeof record.command.idempotency_key !== "string" || record.body_hash !== canonicalIngestBodyHash(record.command) || name !== `${sha(record.command.idempotency_key)}.intent.json`)
+      throw new Error("Invalid ingest journal intent");
+    validateIngest(record.command);
+    return record;
+  }
+  status() {
+    const names = this.names(), intents = names.filter((n) => n.endsWith(".intent.json"));
+    const set = new Set(names);
+    const completed = intents.filter((name) => set.has(name.replace(".intent.", ".receipt."))).length;
+    const rejected = intents.filter((name) => set.has(name.replace(".intent.", ".refusal."))).length;
+    const bytes = this.inventoryBytes;
+    return { target: this.target, commands: intents.length, completed, rejected, pending: intents.length - completed - rejected, bytes, reserved_bytes: bytes + (intents.length - completed - rejected) * RECEIPT_RESERVE + MAINTENANCE_RESERVE };
+  }
+  canStage(command, status = this.status()) {
+    const name = `${sha(command.idempotency_key)}.intent.json`;
+    try {
+      if (this.intent(name).body_hash !== canonicalIngestBodyHash(command))
+        throw new Error("Ingest command key is already bound to different content");
+      return true;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), command };
+    return status.commands < MAX_COMMANDS && status.reserved_bytes + Buffer.byteLength(JSON.stringify(record)) + RECEIPT_RESERVE <= MAX_BYTES;
+  }
+  receipt(command) {
+    if (this.refusal(command))
+      throw new Error("Conflicting ingest receipt and refusal");
+    const record = readJson(this.file(command.idempotency_key, "receipt"), RECEIPT_RESERVE);
+    if (record.version !== 1 || record.target !== this.target || record.body_hash !== canonicalIngestBodyHash(command))
+      throw new Error("Invalid receipt journal binding");
+    return verifyIngestReceipt(record.receipt, command);
+  }
+  stage(command) {
+    validateIngest(command);
+    const path = this.file(command.idempotency_key, "intent");
+    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), command };
+    if (!this.canStage(command))
+      throw new Error("Ingest journal capacity reached; run economy ingest journal maintain; originals preserved");
+    if (createExact(path, record)) {
+      this.freshlyStaged.add(command.idempotency_key);
+      return true;
+    }
+    this.freshlyStaged.delete(command.idempotency_key);
+    const old = this.intent(`${sha(command.idempotency_key)}.intent.json`);
+    if (old.body_hash !== record.body_hash)
+      throw new Error("Ingest command key is already bound to different content");
+    return false;
+  }
+  accept(command, raw) {
+    if (this.refusal(command))
+      throw new Error("A refused command cannot accept a receipt");
+    this.freshlyStaged.delete(command.idempotency_key);
+    const receipt = verifyIngestReceipt(raw, command);
+    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`);
+    if (intent.body_hash !== canonicalIngestBodyHash(command))
+      throw new Error("Ingest receipt content conflicts with exact intent");
+    const record = { version: 1, target: this.target, body_hash: canonicalIngestBodyHash(command), receipt };
+    const path = this.file(command.idempotency_key, "receipt");
+    if (!this.names().includes(`${sha(command.idempotency_key)}.receipt.json`) && this.inventoryBytes + Buffer.byteLength(JSON.stringify(record)) > MAX_BYTES)
+      throw new Error("Receipt capacity exhausted; exact intent retained for reconciliation");
+    if (!createExact(path, record)) {
+      const old = readJson(path, MAX_INGEST_BYTES);
+      if (old.body_hash !== record.body_hash || old.target !== this.target || !sameReceipt(old.receipt, receipt))
+        throw new Error("Ingest receipt journal conflict");
+    }
+    return receipt;
+  }
+  recordRefusal(command, refusal) {
+    if (!this.freshlyStaged.delete(command.idempotency_key))
+      throw new Error("Refusal requires this invocation's fresh command");
+    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`);
+    if (intent.body_hash !== canonicalIngestBodyHash(command))
+      throw new Error("Refusal conflicts with exact intent");
+    const expected = definitiveIngestRefusal(refusal.status, refusal.code === "legacy_aggregate_requires_migration" ? { expected: refusal.code } : null);
+    if (!expected || stableJson(expected) !== stableJson(refusal))
+      throw new Error("Invalid definitive refusal");
+    const names = this.names();
+    if (names.includes(`${sha(command.idempotency_key)}.receipt.json`))
+      throw new Error("A completed command cannot be refused");
+    const record = { version: 1, target: this.target, body_hash: intent.body_hash, refusal };
+    if (Buffer.byteLength(JSON.stringify(record)) > RECEIPT_RESERVE || this.inventoryBytes + Buffer.byteLength(JSON.stringify(record)) > MAX_BYTES)
+      throw new Error("Refusal capacity exhausted; exact intent retained");
+    if (!createExact(this.file(command.idempotency_key, "refusal"), record))
+      throw new Error("Existing refusal requires inspection");
+    this.refusal(command);
+  }
+  refusal(command) {
+    let record;
+    try {
+      record = readJson(this.file(command.idempotency_key, "refusal"), RECEIPT_RESERVE);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+    const intent = this.intent(`${sha(command.idempotency_key)}.intent.json`), r = record?.refusal;
+    const expected = definitiveIngestRefusal(r?.status, r?.code === "legacy_aggregate_requires_migration" ? { expected: r.code } : null);
+    if (record?.version !== 1 || record.target !== this.target || record.body_hash !== intent.body_hash || intent.body_hash !== canonicalIngestBodyHash(command) || !expected || stableJson(expected) !== stableJson(r))
+      throw new Error("Invalid refusal journal binding");
+    try {
+      lstatSync(this.file(command.idempotency_key, "receipt"));
+      throw new Error("Conflicting ingest receipt and refusal");
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    return expected;
+  }
+  async reconcileCommand(cloud, command, timeoutMs = 1e4) {
+    const receipt = await this.lookupReceipt(cloud, command, timeoutMs);
+    return receipt ? this.accept(command, receipt) : null;
+  }
+  assertCloud(cloud) {
+    if (targetId(cloud) !== this.target)
+      throw new Error("Ingest journal authority changed");
+  }
+  async lookupReceipt(cloud, command, timeoutMs = 1e4) {
+    this.assertCloud(cloud);
+    const receipt = await lookupJournalReceipt(cloud, command.idempotency_key, canonicalIngestBodyHash(command), timeoutMs);
+    return receipt === null ? null : verifyIngestReceipt(receipt, command);
+  }
+  async reconcilePending(cloud) {
+    const names = this.names(), unresolved = [];
+    const deadline = performance.now() + 30000;
+    for (const name of names.filter((n) => n.endsWith(".intent.json"))) {
+      const intent = this.intent(name);
+      if (names.includes(`${sha(intent.command.idempotency_key)}.refusal.json`)) {
+        this.refusal(intent.command);
+        continue;
+      }
+      if (names.includes(`${sha(intent.command.idempotency_key)}.receipt.json`)) {
+        const record = readJson(this.file(intent.command.idempotency_key, "receipt"), MAX_INGEST_BYTES);
+        if (record.target !== this.target || record.body_hash !== intent.body_hash)
+          throw new Error("Invalid receipt journal binding");
+        verifyIngestReceipt(record.receipt, intent.command);
+        continue;
+      }
+      if (performance.now() >= deadline) {
+        unresolved.push(intent.command.idempotency_key);
+        continue;
+      }
+      try {
+        if (!await this.reconcileCommand(cloud, intent.command, Math.max(1, Math.min(1e4, deadline - performance.now()))))
+          unresolved.push(intent.command.idempotency_key);
+      } catch {
+        unresolved.push(intent.command.idempotency_key);
+      }
+    }
+    if (unresolved.length)
+      throw new PendingIngestError(unresolved);
+  }
+}
+
+// src/lib/ingest-journal-maintenance.ts
+import { constants as constants2, closeSync as closeSync2, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { join as join2 } from "path";
+var uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+var digest = /^[a-f0-9]{64}$/;
+var sha2 = (bytes) => createHash3("sha256").update(bytes).digest("hex");
+
+class JournalMaintenanceError extends Error {
+  reason;
+  target;
+  code = "INGEST_JOURNAL_MAINTENANCE_REQUIRED";
+  constructor(reason, target) {
+    super(`Ingest journal maintenance required (${reason}); run economy ingest journal maintain; originals or Trash recovery state preserved`);
+    this.reason = reason;
+    this.target = target;
+    this.name = "JournalMaintenanceError";
+  }
+}
+function exists(path) {
+  try {
+    lstatSync2(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function snapshot(path) {
+  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const stat = fstatSync2(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > 4 * 1024 * 1024 + 4096 || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
+      throw new Error("Unsafe maintenance source");
+    const bytes = readFileSync2(fd), after = fstatSync2(fd);
+    if (after.ctimeMs !== stat.ctimeMs || bytes.length !== stat.size)
+      throw new Error("Maintenance source changed");
+    return { sha256: sha2(bytes), sizeBytes: stat.size, mode: stat.mode & 511, device: String(stat.dev), inode: String(stat.ino), ctime: stat.ctimeMs };
+  } finally {
+    closeSync2(fd);
+  }
+}
+function sameSource(path, expected) {
+  const { capture_sha256: _capture, ...original } = expected;
+  if (JSON.stringify(snapshot(path)) !== JSON.stringify(original))
+    throw new Error("Maintenance source changed; preserve for inspection");
+}
+function validAnchor(value, target) {
+  const a = value;
+  if (a?.version !== 1 || a.target !== target || !/^[A-Za-z0-9._:-]{1,200}$/.test(a.key) || !digest.test(a.body_hash) || !digest.test(a.receipt?.operation_key))
+    throw new Error("Invalid journal authority anchor");
+  return a;
+}
+async function confirm(cloud, anchor, deadline) {
+  if (Date.now() >= deadline)
+    throw new Error("Maintenance deadline reached");
+  const current = await lookupJournalReceipt(cloud, anchor.key, anchor.body_hash, Math.max(1, Math.min(1e4, deadline - Date.now())));
+  if (current === null || !sameReceipt(current, anchor.receipt))
+    throw new Error("Exact Economy receipt is unavailable or changed");
+}
+async function verifyJournalAuthority(journal, cloud) {
+  journal.assertCloud(cloud);
+  const path = join2(journal.directory, ".authority.json");
+  if (!exists(path)) {
+    const names = journal.names();
+    const name = names.find((n) => n.endsWith(".intent.json") && names.includes(n.replace(".intent.", ".receipt.")));
+    if (!name)
+      return;
+    const intent = journal.intent(name), receipt = journal.receipt(intent.command);
+    createExact(path, { version: 1, target: journal.target, key: intent.command.idempotency_key, body_hash: intent.body_hash, receipt });
+  }
+  await confirm(cloud, validAnchor(readJson(path, 4096), journal.target), Date.now() + 1e4);
+}
+function recoveryFactory(cloud, env = process.env) {
+  return async (operationRoot, checkpoint, deadline) => {
+    if (env.HASNA_ECONOMY_INGEST_RECOVERY !== "trash")
+      throw new Error("recovery_not_configured");
+    const economy = new URL(cloud.client.transport.baseUrl);
+    const fleet = economy.origin === "https://api.hasna.com" && /^\/economy(?:\/v1)?\/?$/.test(economy.pathname);
+    if (!fleet && !env.HASNA_TRASH_API_URL)
+      throw new Error("self_host_trash_authority_required");
+    const sdk = await import("@hasna/trash/sdk");
+    if (sdk.VERSION !== "0.2.3")
+      throw new Error("trash_version_mismatch");
+    const boundedFetch = (input, init) => {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0)
+        throw new Error("maintenance_deadline");
+      const signal = AbortSignal.timeout(remaining);
+      return fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal, redirect: "error" });
+    };
+    return Object.assign(sdk.createTrash({ env, operationRoot, checkpoint, fetchImpl: boundedFetch, transferFetch: boundedFetch, lockTimeoutMs: 100 }), { snapshot: sdk.snapshotIdentity });
+  };
+}
+
+class IngestJournalMaintenance {
+  journal;
+  cloud;
+  factory;
+  control;
+  operationRoot;
+  constructor(journal, cloud, factory = recoveryFactory(cloud)) {
+    this.journal = journal;
+    this.cloud = cloud;
+    this.factory = factory;
+    journal.assertCloud(cloud);
+    this.control = join2(journal.directory, ".maintenance");
+    this.operationRoot = join2(journal.directory, ".recovery");
+  }
+  manifest() {
+    secureDirectory(this.control);
+    const names = readdirSync(this.control);
+    if (names.some((n) => !["manifest.json", "intent.operation.json", "receipt.operation.json"].includes(n)))
+      throw new Error("Unexpected maintenance entry");
+    let size = 0;
+    for (const name of names)
+      size += lstatSync2(join2(this.control, name)).size;
+    if (size > MAINTENANCE_RESERVE)
+      throw new Error("Maintenance metadata exceeds reserve");
+    const m = validAnchor(readJson(join2(this.control, "manifest.json"), 8192), this.journal.target);
+    for (const part of [m.intent, m.receipt_file])
+      if (!part || !digest.test(part.sha256) || !digest.test(part.capture_sha256 ?? "") || !Number.isSafeInteger(part.sizeBytes) || part.sizeBytes < 1 || part.sizeBytes > 4198400 || part.mode !== 384 || !/^\d+$/.test(part.device) || !/^\d+$/.test(part.inode) || !Number.isFinite(part.ctime))
+        throw new Error("Invalid maintenance snapshot");
+    return m;
+  }
+  pending(backend) {
+    const pending = backend.pending(4);
+    if (pending.length > 3 || pending.some((p) => !uuid.test(p.id) || p.phase === "unreadable"))
+      throw new Error("Unexpected Trash recovery state");
+    return pending;
+  }
+  async backend(deadline) {
+    const backend = await this.factory(this.operationRoot, async (point, operation) => {
+      if (operation.path === this.control)
+        return;
+      const m = this.manifest();
+      const kind = operation.path === this.journal.file(m.key, "receipt") ? "receipt" : operation.path === this.journal.file(m.key, "intent") ? "intent" : null;
+      if (!kind || operation.kind !== "capture" || !uuid.test(operation.id) || operation.id !== operation.entryId)
+        throw new Error("Unexpected Trash operation");
+      const expected = kind === "receipt" ? m.receipt_file : m.intent;
+      if (point === "afterSnapshot") {
+        if (!operation.receipt || operation.receipt.sha256 !== expected.capture_sha256 || operation.receipt.sizeBytes !== expected.sizeBytes || operation.receipt.mode !== expected.mode)
+          throw new Error("Trash snapshot mismatch");
+        sameSource(operation.path, expected);
+        const path = join2(this.control, `${kind}.operation.json`);
+        createExact(path, { id: operation.id });
+        if (readJson(path, 1024).id !== operation.id)
+          throw new Error("Conflicting Trash operation");
+      }
+      if (point === "beforeStage") {
+        await confirm(this.cloud, m, deadline);
+        sameSource(operation.path, expected);
+      }
+    }, deadline);
+    const status = await backend.doctor();
+    if (!status.station || !uuid.test(status.station.id) || !Number.isInteger(status.retentionDays) || status.retentionDays < 1)
+      throw new Error("Trash station authority unavailable");
+    return backend;
+  }
+  async entry(backend, id, path, expected) {
+    const e = await backend.api.get(id);
+    if (e.id !== id || e.originalPath !== path || e.kind !== "file" || e.sha256 !== expected.capture_sha256 || e.sizeBytes !== expected.sizeBytes || e.mode !== expected.mode || e.state !== "trashed")
+      throw new Error("Trash preservation readback refused");
+    if (exists(path))
+      throw new Error("Retired source reappeared; preserve for inspection");
+  }
+  async pairFile(backend, m, kind, deadline) {
+    await confirm(this.cloud, m, deadline);
+    const path = this.journal.file(m.key, kind), expected = kind === "receipt" ? m.receipt_file : m.intent;
+    const saved = join2(this.control, `${kind}.operation.json`);
+    let id;
+    if (exists(saved))
+      id = readJson(saved, 1024).id;
+    const pending = this.pending(backend);
+    const matches = pending.filter((p) => p.path === path);
+    if (matches.length > 1 || id && !uuid.test(id))
+      throw new Error("Conflicting Trash operation");
+    if (matches[0]) {
+      if (id && id !== matches[0].id)
+        throw new Error("Conflicting Trash operation");
+      id = matches[0].id;
+      const operation = backend.journal.read(id);
+      if (operation.kind !== "capture" || operation.path !== path || operation.entryId !== id)
+        throw new Error("Invalid Trash operation binding");
+      if (exists(path))
+        sameSource(path, expected);
+      await backend.recover(id, { takeAbandonedLock: true });
+    } else if (!id) {
+      sameSource(path, expected);
+      const status = await backend.doctor();
+      const e = await backend.put(path, { retentionDays: status.retentionDays });
+      id = e.id;
+      if (!exists(saved) || readJson(saved, 1024).id !== id)
+        throw new Error("Trash did not persist its capture binding");
+    }
+    await this.entry(backend, id, path, expected);
+  }
+  async recover() {
+    if (!exists(this.control) && !exists(this.operationRoot))
+      return;
+    if (exists(this.operationRoot))
+      secureDirectory(this.operationRoot);
+    if (!exists(this.control) && readdirSync(this.operationRoot).every((n) => n === ".locks"))
+      return;
+    const deadline = Date.now() + 30000;
+    try {
+      await this.finish(await this.backend(deadline), deadline);
+    } catch (error) {
+      if (error instanceof JournalMaintenanceError)
+        throw error;
+      throw new JournalMaintenanceError("recovery_unresolved", this.journal.target);
+    }
+  }
+  async finish(backend, deadline) {
+    const pending = this.pending(backend);
+    const control = pending.filter((p) => p.path === this.control);
+    if (control.length) {
+      if (control.length !== 1 || pending.length !== 1)
+        throw new Error("Conflicting maintenance cleanup");
+      const op = backend.journal.read(control[0].id);
+      if (op.kind !== "capture" || op.path !== this.control)
+        throw new Error("Invalid maintenance cleanup");
+      await backend.recover(op.id, { takeAbandonedLock: true });
+      if (exists(this.control) || this.pending(backend).length)
+        throw new Error("Maintenance cleanup unresolved");
+      return;
+    }
+    if (!exists(this.control)) {
+      if (pending.length)
+        throw new Error("Orphaned maintenance operation");
+      return;
+    }
+    if (readdirSync(this.control).length === 0) {
+      if (pending.length)
+        throw new Error("Orphaned maintenance operation");
+      const status2 = await backend.doctor();
+      await backend.put(this.control, { retentionDays: status2.retentionDays });
+      return;
+    }
+    const m = this.manifest();
+    if (pending.some((p) => p.path !== this.journal.file(m.key, "receipt") && p.path !== this.journal.file(m.key, "intent")))
+      throw new Error("Unexpected recovery path");
+    await this.pairFile(backend, m, "receipt", deadline);
+    await this.pairFile(backend, m, "intent", deadline);
+    if (this.pending(backend).length)
+      throw new Error("Unfinished pair capture");
+    await confirm(this.cloud, m, deadline);
+    const status = await backend.doctor();
+    await backend.put(this.control, { retentionDays: status.retentionDays });
+    if (exists(this.control) || this.pending(backend).length)
+      throw new Error("Maintenance cleanup unresolved");
+  }
+  async maintain(limit = 32) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 32)
+      throw new Error("Journal maintenance limit must be 1\u201332");
+    await this.recover();
+    await verifyJournalAuthority(this.journal, this.cloud);
+    const sweepDeadline = Date.now() + 30000;
+    let retired = 0, bytes = 0;
+    let backend;
+    try {
+      const names = this.journal.names();
+      for (const name of names.filter((n) => n.endsWith(".intent.json"))) {
+        if (retired >= limit || Date.now() >= sweepDeadline || retired > 0 && bytes >= 1048576)
+          break;
+        if (!names.includes(name.replace(".intent.", ".receipt.")))
+          continue;
+        const intent = this.journal.intent(name), receipt = this.journal.receipt(intent.command);
+        const deadline = Date.now() + 30000;
+        backend = await this.backend(deadline);
+        const m = {
+          version: 1,
+          target: this.journal.target,
+          key: intent.command.idempotency_key,
+          body_hash: intent.body_hash,
+          receipt,
+          intent: snapshot(join2(this.journal.directory, name)),
+          receipt_file: snapshot(this.journal.file(intent.command.idempotency_key, "receipt"))
+        };
+        await confirm(this.cloud, m, deadline);
+        m.intent.capture_sha256 = backend.snapshot(this.journal.file(m.key, "intent")).sha256;
+        m.receipt_file.capture_sha256 = backend.snapshot(this.journal.file(m.key, "receipt")).sha256;
+        secureDirectory(this.control);
+        if (!createExact(join2(this.control, "manifest.json"), m))
+          throw new Error("Existing maintenance transaction");
+        await this.finish(backend, deadline);
+        retired++;
+        bytes += m.intent.sizeBytes + m.receipt_file.sizeBytes;
+      }
+      return { retired, remaining: this.journal.status().completed };
+    } catch (error) {
+      if (error instanceof JournalMaintenanceError)
+        throw error;
+      const reason = error instanceof Error && ["recovery_not_configured", "self_host_trash_authority_required", "trash_version_mismatch"].includes(error.message) ? error.message : backend ? "recovery_unresolved" : "recovery_authority_unavailable";
+      throw new JournalMaintenanceError(reason, this.journal.target);
+    }
+  }
+  async admit(command) {
+    const status = this.journal.status();
+    const fits = this.journal.canStage(command, status);
+    if (status.commands < 64 && status.reserved_bytes < 50331648 && fits)
+      return;
+    try {
+      await this.maintain();
+    } catch (error) {
+      const deferrable = error instanceof JournalMaintenanceError && ["recovery_not_configured", "self_host_trash_authority_required", "trash_version_mismatch", "recovery_authority_unavailable"].includes(error.reason);
+      if (!deferrable || exists(this.control) || !this.journal.canStage(command))
+        throw error;
+    }
+    if (!this.journal.canStage(command))
+      throw new JournalMaintenanceError("capacity", this.journal.target);
+  }
+}
+
+// src/lib/ingest-journal-lock.ts
+import { constants as constants3, closeSync as closeSync3, fstatSync as fstatSync3, lstatSync as lstatSync3, openSync as openSync3 } from "fs";
+import { join as join3 } from "path";
+async function withIngestJournalLock(directory, action) {
+  if (process.platform !== "linux" && process.platform !== "darwin")
+    throw new Error("Ingest journal locking requires Linux or macOS");
+  const { dlopen, FFIType } = await import("bun:ffi");
+  const library = dlopen(process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", {
+    flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 }
+  });
+  const path = join3(directory, ".lease");
+  let fd;
+  try {
+    fd = openSync3(path, constants3.O_RDWR | constants3.O_CREAT | constants3.O_NOFOLLOW | constants3.O_NONBLOCK, 384);
+    const stat = fstatSync3(fd), current = lstatSync3(path);
+    if (!stat.isFile() || stat.size !== 0 || stat.nlink !== 1 || stat.ino !== current.ino || stat.dev !== current.dev || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
+      throw new Error("Unsafe ingest journal lease");
+    if (library.symbols.flock(fd, 6) !== 0) {
+      const error = new Error("Ingest journal is busy; retry after the current operation finishes");
+      Object.assign(error, { code: "INGEST_JOURNAL_BUSY" });
+      throw error;
+    }
+    return await action();
+  } finally {
+    if (fd !== undefined)
+      closeSync3(fd);
+    library.close();
+  }
+}
+
+// src/lib/ingest-journal-operation.ts
+import { existsSync, readdirSync as readdirSync2 } from "fs";
+import { z } from "zod";
+var ingestJournalOperationSchema = z.discriminatedUnion("action", [
+  z.object({ action: z.literal("status") }).strict(),
+  z.object({ action: z.literal("reconcile") }).strict(),
+  z.object({ action: z.literal("maintain"), confirm: z.literal(true), limit: z.number().int().min(1).max(32).default(32) }).strict()
+]);
+async function runIngestJournalOperation(cloud, input) {
+  const options = ingestJournalOperationSchema.parse(input);
+  const journal = new IngestJournal(cloud);
+  return withIngestJournalLock(journal.directory, async () => {
+    const maintenance = new IngestJournalMaintenance(journal, cloud);
+    const unfinished = existsSync(maintenance.control) || existsSync(maintenance.operationRoot) && readdirSync2(maintenance.operationRoot).some((n) => n !== ".locks");
+    if (options.action === "status" && unfinished)
+      throw new JournalMaintenanceError("recovery_pending", journal.target);
+    if (options.action !== "status") {
+      await maintenance.recover();
+      if (options.action === "reconcile")
+        await journal.reconcilePending(cloud);
+      await verifyJournalAuthority(journal, cloud);
+    }
+    const sweep = options.action === "maintain" ? await maintenance.maintain(options.limit) : { retired: 0 };
+    return { schema: "economy.ingest-journal.v1", action: options.action, ...journal.status(), ...sweep };
+  });
+}
+
+// src/lib/cloud-ingest.ts
+import { HasnaHttpError as HasnaHttpError2 } from "@hasna/contracts/client";
+var CLOUD_INGEST_TABLES = ["requests", "sessions", "billing_daily", "usage_snapshots", "subscriptions", "scan_receipts"];
+function getIngestCachePath() {
+  if (process.env["HASNA_ECONOMY_INGEST_CACHE"])
+    return process.env["HASNA_ECONOMY_INGEST_CACHE"];
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || undefined;
+  return join4(cacheDir({ app: "economy", home }), "ingest-cache.json");
+}
+function readIngestCache(path) {
+  let text;
+  try {
+    text = readFileSync3(path, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const rows = Array.isArray(parsed?.ingest_state) ? parsed.ingest_state : [];
+    return rows.filter((row) => typeof row === "object" && row !== null && typeof row.source === "string" && typeof row.key === "string" && typeof row.value === "string");
+  } catch {
+    return [];
+  }
+}
+function writeIngestCache(path, rows) {
+  mkdirSync2(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync2(tmp, JSON.stringify({ version: 1, ingest_state: rows }), { mode: 384 });
+  renameSync(tmp, path);
+}
+function loadIngestState(scratch, rows) {
+  scratch.prepare(`DELETE FROM ingest_state`).run();
+  const insert = scratch.prepare(`INSERT INTO ingest_state (source, key, value) VALUES (?, ?, ?)`);
+  for (const row of rows)
+    insert.run(row.source, row.key, row.value);
+}
+function dumpIngestState(scratch) {
+  return scratch.prepare(`SELECT source, key, value FROM ingest_state`).all();
+}
+function exportIngestRows(db) {
+  const body = {};
+  for (const table of CLOUD_INGEST_TABLES) {
+    const rows = db.prepare(`SELECT * FROM ${table}`).all();
+    if (rows.length > 0)
+      body[table] = rows;
+  }
+  return body;
+}
+
+class IngestRefused extends Error {
+  status;
+  code;
+  reason;
+  constructor(status, code, reason = code) {
+    super(`Ingestion refused: ${reason}; exact command intent retained`);
+    this.status = status;
+    this.code = code;
+    this.reason = reason;
+    this.name = "IngestRefused";
+  }
+}
+async function postIngest(cloud, body) {
+  const journal = new IngestJournal(cloud);
+  return withIngestJournalLock(journal.directory, async () => {
+    const maintenance = new IngestJournalMaintenance(journal, cloud);
+    await maintenance.recover();
+    await journal.reconcilePending(cloud);
+    await verifyJournalAuthority(journal, cloud);
+    const ingested = {};
+    const completed = [];
+    let total = 0;
+    for (const batch of ingestBatches(body)) {
+      try {
+        const refused = journal.refusal(batch);
+        if (refused)
+          throw new IngestRefused(refused.status, refused.code, refused.reason);
+        const known = await journal.lookupReceipt(cloud, batch);
+        let payload;
+        if (known && existsSync2(join4(journal.directory, ".authority.json"))) {
+          payload = existsSync2(journal.file(batch.idempotency_key, "intent")) ? journal.accept(batch, known) : known;
+        } else {
+          await maintenance.admit(batch);
+          const fresh = journal.stage(batch);
+          const sendFresh = async () => {
+            let response;
+            try {
+              response = await cloud.client.transport.post("/ingest", batch, { retry: false });
+            } catch (error) {
+              const refusal = error instanceof HasnaHttpError2 ? definitiveIngestRefusal(error.status, error.body) : null;
+              if (refusal) {
+                journal.recordRefusal(batch, refusal);
+                throw new IngestRefused(refusal.status, refusal.code, refusal.reason);
+              }
+              throw error;
+            }
+            return journal.accept(batch, response);
+          };
+          payload = known ? journal.accept(batch, known) : fresh ? await sendFresh() : await journal.reconcileCommand(cloud, batch);
+        }
+        await verifyJournalAuthority(journal, cloud);
+        if (!payload)
+          throw new PendingIngestError([batch.idempotency_key]);
+        const verified = verifyIngestReceipt(payload, batch);
+        const counts = verified["ingested"];
+        if (!counts || typeof counts !== "object" || Array.isArray(counts) || typeof verified["total"] !== "number" || !Number.isSafeInteger(verified["total"]) || verified["total"] < 0)
+          throw new Error("Invalid ingest receipt");
+        let sum = 0;
+        for (const [table, count] of Object.entries(counts)) {
+          if (!CLOUD_INGEST_TABLES.includes(table) || typeof count !== "number" || !Number.isSafeInteger(count) || count < 0)
+            throw new Error("Invalid ingest receipt");
+          sum += count;
+          ingested[table] = (ingested[table] ?? 0) + count;
+        }
+        if (sum !== verified["total"])
+          throw new Error("Invalid ingest receipt");
+        total += sum;
+        const operation = verified["operation_key"];
+        if (operation !== undefined && (typeof operation !== "string" || !/^[a-f0-9]{64}$/.test(operation)))
+          throw new Error("Invalid ingest receipt");
+        completed.push({
+          idempotency_key: batch.idempotency_key,
+          ...typeof operation === "string" ? { operation_key: operation } : {},
+          replayed: verified["replayed"] === true
+        });
+      } catch (error) {
+        if (error instanceof PendingIngestError || error instanceof JournalMaintenanceError || error instanceof IngestRefused)
+          throw error;
+        if (error instanceof HasnaHttpError2 && error.status >= 400 && error.status < 500 && error.status !== 408) {
+          const body2 = error.body;
+          throw new IngestRefused(error.status, body2?.expected === "legacy_aggregate_requires_migration" ? "legacy_aggregate_requires_migration" : "ingest_refused");
+        }
+        throw new IngestBatchFailure(batch.idempotency_key, completed, batch);
+      }
+    }
+    return { ingested, total, receipts: completed };
+  });
+}
+async function syncAllToCloud(cloud, opts = {}) {
+  await runIngestJournalOperation(cloud, { action: "reconcile" });
+  const { openDatabase } = await import("./sqlite-store-r219qrjt.js");
+  const scratch = openDatabase(":memory:", true);
+  ensurePricingSeeded(scratch);
+  const cachePath = opts.cachePath ?? getIngestCachePath();
+  try {
+    loadIngestState(scratch, opts.force ? [] : readIngestCache(cachePath));
+    const result = await syncAll(scratch, { ...opts, noCrossAppLocalReads: true });
+    if (opts.backfillMachine)
+      backfillMachineId(scratch);
+    if (opts.recalculate)
+      await recalculateZeroCostRequests(scratch);
+    const body = exportIngestRows(scratch);
+    if (Object.keys(body).length === 0) {
+      writeIngestCache(cachePath, dumpIngestState(scratch));
+      return { ...result, posted: false };
+    }
+    const response = await postIngest(cloud, body);
+    writeIngestCache(cachePath, dumpIngestState(scratch));
+    return { ...result, posted: true, ...response };
+  } finally {
+    try {
+      scratch.close();
+    } catch {}
+  }
+}
+async function billingSyncToCloud(cloud, opts = {}) {
+  await runIngestJournalOperation(cloud, { action: "reconcile" });
+  const { openDatabase } = await import("./sqlite-store-r219qrjt.js");
+  const scratch = openDatabase(":memory:", true);
+  try {
+    const days = opts.days ?? 31;
+    const providers = {};
+    const attempts = [
+      ["anthropic", () => syncAnthropicBilling(scratch, { days })],
+      ["openai", () => syncOpenAIBilling(scratch, { days })],
+      ["gemini", () => syncGeminiBilling(scratch, { days })]
+    ];
+    const anySelected = opts.anthropic || opts.openai || opts.gemini;
+    let totalUsd = 0;
+    for (const [provider, run] of attempts) {
+      if (anySelected && !opts[provider])
+        continue;
+      {
+        try {
+          const r = await run();
+          providers[provider] = { ok: true, days: r.days, totalUsd: r.totalUsd };
+          totalUsd += r.totalUsd;
+        } catch {
+          providers[provider] = { ok: false, error: "provider_billing_collection_failed" };
+        }
+      }
+    }
+    const body = exportIngestRows(scratch);
+    if (Object.keys(body).length === 0)
+      return { providers, totalUsd, posted: false };
+    const response = await postIngest(cloud, body);
+    return { providers, totalUsd, posted: true, ...response };
+  } finally {
+    try {
+      scratch.close();
+    } catch {}
+  }
+}
+
+// src/lib/sync-report.ts
+function syncHasFailures(result) {
+  return result.collections?.some((row) => row.status === "failed" || row.status === "unsupported") ?? false;
+}
+function syncOutcomeLines(result) {
+  return (result.collections ?? []).map((row) => `${row.source}: ${row.status}${row.error_code ? ` (${row.error_code})` : ""}`);
+}
+
+export { PendingIngestError, JournalMaintenanceError, ingestJournalOperationSchema, runIngestJournalOperation, backfillMachineId, recalculateZeroCostRequests, getIngestCachePath, syncAllToCloud, billingSyncToCloud, syncHasFailures, syncOutcomeLines };