llm-relay 0.68.8 → 0.69.0

package/dist/accounting-store.d.ts

@@ -9,7 +9,24 @@
  *  - Read-only queries (`readOnly: true`) never mutate or create writer leases.
  */
 import { type AccountingRecorder } from "./accounting.js";
-import { type SnapshotJournalHooks, type SnapshotMutationResult, type SnapshotWriterResult } from "./accounting-store-io.js";
+export interface SnapshotMutationResult {
+    readonly status: "none" | "committed" | "recovered" | "recovery-loss" | "invalid" | "failed";
+    readonly transactionId: string | null;
+    readonly lowerBoundLoss: boolean;
+    readonly error: string | null;
+    readonly quarantinedPath: string | null;
+    readonly retryable: boolean;
+}
+export interface SnapshotWriterResult {
+    readonly status: "acquired" | "released" | "closed" | "failed";
+    readonly error: string | null;
+    readonly retryable: boolean;
+}
+export interface SnapshotJournalHooks {
+    readonly beforeRead?: (path: string) => void;
+    readonly beforeStep?: (step: unknown) => void;
+    readonly afterStep?: (step: unknown) => void;
+}
 import { type AccountingDayShard, type AccountingLifetime, type AccountingRequestPacket } from "./accounting-store-schema.js";
 export { ACCOUNTING_DAY_SCHEMA, ACCOUNTING_DEDUP_SCHEMA, ACCOUNTING_LIFETIME_SCHEMA, ACCOUNTING_MAX_DAY_ROWS, ACCOUNTING_MAX_DEDUP_IDS, ACCOUNTING_MAX_DETAIL_ATTEMPTS, ACCOUNTING_MAX_FILE_BYTES, ACCOUNTING_MAX_LOSS_MARKERS, ACCOUNTING_MAX_MONTHS, ACCOUNTING_MAX_PACKET_ATTEMPTS, ACCOUNTING_MAX_RECENT_ROWS, ACCOUNTING_MAX_ROWS_PER_CELL, ACCOUNTING_MAX_SAMPLES, ACCOUNTING_MINUTE_SCHEMA, ACCOUNTING_RECENT_SCHEMA, ACCOUNTING_STORE_VERSION, } from "./accounting-store-schema.js";
 export type { AccountingAggregateTokenCellV1 as AggregateTokenCell, AccountingAggregateTokenTotalsV1 as AggregateTokenTotals, AccountingAggregateV1 as AccountingAggregate, AccountingAttemptPacketV1 as AccountingAttemptPacket, AccountingCoverageV1 as AccountingCoverage, AccountingDayShard, AccountingDimensionRowV1 as AccountingAggregateRow, AccountingLifetime, AccountingMetricCellV1 as AggregateMetric, AccountingMinuteShardV1 as AccountingMinuteCell, AccountingRequestPacket, } from "./accounting-store-schema.js";

package/dist/accounting-store.js

@@ -3,8 +3,9 @@ import { randomBytes } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ACCOUNTING_UNSPECIFIED_ESTIMATION_METHOD, } from "./accounting.js";
-import { createSnapshotJournalIo, SNAPSHOT_IO_HARD_MAX_JOURNAL_BYTES, } from "./accounting-store-io.js";
-import { emptyAccountingSpendCell, mergeAccountingSpendCells, ACCOUNTING_DAY_SCHEMA, ACCOUNTING_DEDUP_SCHEMA, ACCOUNTING_LIFETIME_SCHEMA, ACCOUNTING_MAX_DAY_ROWS, ACCOUNTING_MAX_DEDUP_IDS, ACCOUNTING_MAX_DETAIL_ATTEMPTS, ACCOUNTING_MAX_FILE_BYTES, ACCOUNTING_MAX_LOSS_MARKERS, ACCOUNTING_MAX_MONTHS, ACCOUNTING_MAX_PACKET_ATTEMPTS, ACCOUNTING_MAX_RECENT_ROWS, ACCOUNTING_MAX_ROWS_PER_CELL, ACCOUNTING_MAX_SAMPLES, ACCOUNTING_MINUTE_SCHEMA, ACCOUNTING_RECENT_SCHEMA, ACCOUNTING_STORE_VERSION, freezeDeep, parseAccountingAttemptPacketV1, parseAccountingDayShardV1, parseAccountingLifetimeV1, parseAccountingRecentV1, parseAccountingRequestPacketV1, isLoadableId, } from "./accounting-store-schema.js";
+import { readFileSync, unlinkSync } from "node:fs";
+import { atomicWriteJsonSync } from "./storage/json-store.js";
+import { emptyAccountingSpendCell, mergeAccountingSpendCells, ACCOUNTING_DAY_SCHEMA, ACCOUNTING_DEDUP_SCHEMA, ACCOUNTING_LIFETIME_SCHEMA, ACCOUNTING_MAX_DAY_ROWS, ACCOUNTING_MAX_DEDUP_IDS, ACCOUNTING_MAX_DETAIL_ATTEMPTS, ACCOUNTING_MAX_LOSS_MARKERS, ACCOUNTING_MAX_MONTHS, ACCOUNTING_MAX_PACKET_ATTEMPTS, ACCOUNTING_MAX_RECENT_ROWS, ACCOUNTING_MAX_ROWS_PER_CELL, ACCOUNTING_MAX_SAMPLES, ACCOUNTING_MINUTE_SCHEMA, ACCOUNTING_RECENT_SCHEMA, ACCOUNTING_STORE_VERSION, freezeDeep, parseAccountingAttemptPacketV1, parseAccountingDayShardV1, parseAccountingLifetimeV1, parseAccountingRecentV1, parseAccountingRequestPacketV1, isLoadableId, } from "./accounting-store-schema.js";
 import { DASHBOARD_REQUEST_ID_PATTERN, isDashboardAttemptId, isDashboardFailureKind, isDashboardOutcome, isDashboardSafeId, isDashboardUtcTimestamp, } from "./dashboard-contract.js";
 import { DEFAULT_FLUSH_DELAY_MS, MAX_FLUSH_DELAY_MS, WriteBehindTimer } from "./write-behind.js";
 export { ACCOUNTING_DAY_SCHEMA, ACCOUNTING_DEDUP_SCHEMA, ACCOUNTING_LIFETIME_SCHEMA, ACCOUNTING_MAX_DAY_ROWS, ACCOUNTING_MAX_DEDUP_IDS, ACCOUNTING_MAX_DETAIL_ATTEMPTS, ACCOUNTING_MAX_FILE_BYTES, ACCOUNTING_MAX_LOSS_MARKERS, ACCOUNTING_MAX_MONTHS, ACCOUNTING_MAX_PACKET_ATTEMPTS, ACCOUNTING_MAX_RECENT_ROWS, ACCOUNTING_MAX_ROWS_PER_CELL, ACCOUNTING_MAX_SAMPLES, ACCOUNTING_MINUTE_SCHEMA, ACCOUNTING_RECENT_SCHEMA, ACCOUNTING_STORE_VERSION, } from "./accounting-store-schema.js";
@@ -481,7 +482,6 @@ function parsedLifetime(value) { const parsed = parseAccountingLifetimeV1(value)
 function parsedRecent(value) { const parsed = parseAccountingRecentV1(value); return parsed.ok ? parsed.value : null; }
 class AccountingStoreImpl {
     directory;
-    io;
     timer = new WriteBehindTimer();
     retentionDays;
     recentLimit;
@@ -493,6 +493,7 @@ class AccountingStoreImpl {
     pendingAttemptLimit;
     now;
     readOnly;
+    ioHooks;
     pending = new Map();
     queued = new Array();
     days = new Map();
@@ -504,10 +505,6 @@ class AccountingStoreImpl {
     recentReadState = "missing";
     dirtyLifetime = false;
     dirtyRecent = false;
-    fixedLoadPending = false;
-    pendingFixedLoss = false;
-    pendingJournalLoss = false;
-    deferredGlobalLosses = [];
     pendingRetention = null;
     pendingRetentionPlan = null;
     retryTimer = null;
@@ -529,28 +526,15 @@ class AccountingStoreImpl {
         this.pendingAttemptLimit = positiveLimit(options.pendingAttemptLimit, ACCOUNTING_MAX_PENDING_ATTEMPTS_PER_REQUEST, ACCOUNTING_MAX_PENDING_ATTEMPTS_PER_REQUEST);
         this.now = options.now ?? (() => Date.now());
         this.readOnly = options.readOnly === true;
-        this.io = createSnapshotJournalIo({
-            rootDir: this.directory,
-            targets: [LIFETIME_TARGET, RECENT_TARGET],
-            acceptTarget: dayTarget,
-            maxFileBytes: ACCOUNTING_MAX_FILE_BYTES,
-            maxJournalBytes: SNAPSHOT_IO_HARD_MAX_JOURNAL_BYTES,
-            maxTargets: 128,
-            ...(options.ioHooks === undefined ? {} : { hooks: options.ioHooks }),
-        });
+        this.ioHooks = options.ioHooks;
         if (this.readOnly) {
             this.writer = { status: "released", error: null, retryable: false };
             this.last = result("none", null, false, false);
             this.loadFixedSnapshotsReadOnly();
             return;
         }
-        this.writer = this.io.acquireWriter();
-        if (this.writer.status === "acquired")
-            this.recoverAndLoad();
-        else {
-            this.last = result("failed", this.writer.error ?? "writer-busy", this.writer.retryable);
-            this.markGlobalLoss("unknown", "truncated", "writer");
-        }
+        this.writer = { status: "acquired", error: null, retryable: false };
+        this.loadFixedSnapshots();
     }
     get closed() { return this._closed; }
     get writerStatus() { return this.writer; }
@@ -590,48 +574,74 @@ class AccountingStoreImpl {
             return result("none", null, false, false);
         this.timer.clear();
         this.clearRetry();
-        if (this.writer.status !== "acquired")
+        if (this.writer.status !== "acquired") {
             return this.setLast(result("failed", this.writer.error ?? "writer-busy", this.writer.retryable));
-        const recovered = this.io.recover();
-        if (recovered.status === "failed" || recovered.status === "invalid")
-            return this.fail(recovered);
-        if (this.fixedLoadPending) {
-            this.recoverAndLoad();
-            if (this.fixedLoadPending)
-                return this.last ?? result("failed", "snapshot-read", true, this.lowerBoundLoss);
-        }
-        if (recovered.lowerBoundLoss || recovered.status === "recovery-loss")
-            this.consumeRecoveryLoss(recovered);
-        if (recovered.status === "recovered" && this.pendingRetentionPlan !== null) {
-            this.reconcileRecoveredRetention(this.pendingRetentionPlan);
         }
         this.drainQueued();
-        if (this.queued.length > 0)
+        if (this.queued.length > 0) {
             return this.fail(result("failed", "day-read", true, this.lowerBoundLoss));
+        }
         if (this.dirtyDays.size === 0 && !this.dirtyLifetime && !this.dirtyRecent) {
-            return this.commitRetention([]) ?? this.setLast(result("none", null, false, this.lowerBoundLoss));
+            const retentionResult = this.commitRetention([]);
+            return retentionResult ?? this.setLast(result("none", null, false, this.lowerBoundLoss));
+        }
+        const daySnapshots = [];
+        for (const date of [...this.dirtyDays].sort()) {
+            const day = this.days.get(date);
+            const parsed = day === undefined ? null : parsedDay(day);
+            if (parsed === null)
+                return this.fail(result("invalid", "schema-or-size", false, this.lowerBoundLoss));
+            daySnapshots.push({ date, data: parsed });
+        }
+        let lifetimeSnapshot = null;
+        if (this.dirtyLifetime) {
+            lifetimeSnapshot = parsedLifetime(this.lifetime);
+            if (lifetimeSnapshot === null)
+                return this.fail(result("invalid", "schema-or-size", false, this.lowerBoundLoss));
+        }
+        let recentSnapshot = null;
+        if (this.dirtyRecent) {
+            recentSnapshot = parsedRecent(this.recent);
+            if (recentSnapshot === null)
+                return this.fail(result("invalid", "schema-or-size", false, this.lowerBoundLoss));
+        }
+        try {
+            for (const { date, data } of daySnapshots) {
+                const filePath = join(this.directory, targetForDay(date));
+                if (!atomicWriteJsonSync(filePath, data, { strict: true })) {
+                    throw new Error(`Failed to write ${targetForDay(date)}`);
+                }
+            }
+            if (lifetimeSnapshot !== null) {
+                const filePath = join(this.directory, LIFETIME_TARGET);
+                if (!atomicWriteJsonSync(filePath, lifetimeSnapshot, { strict: true })) {
+                    throw new Error(`Failed to write ${LIFETIME_TARGET}`);
+                }
+            }
+            if (recentSnapshot !== null) {
+                const filePath = join(this.directory, RECENT_TARGET);
+                if (!atomicWriteJsonSync(filePath, recentSnapshot, { strict: true })) {
+                    throw new Error(`Failed to write ${RECENT_TARGET}`);
+                }
+            }
+        }
+        catch (err) {
+            return this.fail(result("failed", err instanceof Error ? err.message : String(err), true, this.lowerBoundLoss));
         }
-        if (this.dirtyDays.size + 2 > (this.io.maxTargets ?? 0))
-            return this.fail(result("invalid", "transaction-targets", false, this.lowerBoundLoss));
-        const snapshots = this.factSnapshots();
-        if (snapshots === null)
-            return this.fail(result("invalid", "schema-or-size", false, this.lowerBoundLoss));
         const committedDates = [...this.dirtyDays];
-        const written = this.io.commit(snapshots);
-        this.last = written;
-        if (written.status !== "committed" && written.status !== "recovered")
-            return this.fail(written);
         this.dirtyDays.clear();
         this.dirtyLifetime = false;
         this.dirtyRecent = false;
-        if (Object.hasOwn(snapshots, LIFETIME_TARGET))
+        if (lifetimeSnapshot !== null)
             this.lifetimeReadState = "ok";
-        if (Object.hasOwn(snapshots, RECENT_TARGET))
+        if (recentSnapshot !== null)
             this.recentReadState = "ok";
         this.retryDelay = RETRY_MIN_MS;
-        const retention = this.commitRetention(committedDates);
         for (const date of [...committedDates].sort())
             this.rememberKnownDay(date);
+        const written = result("committed", null, false, this.lowerBoundLoss);
+        this.last = written;
+        const retention = this.commitRetention(committedDates);
         return retention ?? written;
     }
     close() {
@@ -642,10 +652,8 @@ class AccountingStoreImpl {
         const flushed = this.flush();
         if (flushed.retryable)
             return flushed;
-        const closed = this.io.close();
-        this._closed = closed.status === "closed";
-        if (closed.status === "failed")
-            return this.setLast(result("failed", closed.error, closed.retryable, flushed.lowerBoundLoss));
+        this._closed = true;
+        this.writer = { status: "closed", error: null, retryable: false };
         return flushed;
     }
     readDay(date) {
@@ -656,17 +664,39 @@ class AccountingStoreImpl {
             const parsed = parsedDay(cached);
             return parsed === null ? { status: "corrupt", value: null, error: "schema" } : { status: "ok", value: this.withDayLoss(parsed) };
         }
-        const read = this.io.readJson(targetForDay(date), (value) => parseAccountingDayShardV1(value).ok, { quarantineCorrupt: !this.readOnly });
+        const read = this.readJsonFile(targetForDay(date), parseAccountingDayShardV1);
         if (read.status === "missing")
             return { status: "missing", value: null };
         if (read.status !== "ok" || read.value === null)
-            return { status: "corrupt", value: null, error: read.error ?? read.status };
-        const parsed = parseAccountingDayShardV1(read.value);
+            return { status: "corrupt", value: null, error: read.error };
+        this.days.set(date, mutableDay(read.value));
+        this.rememberKnownDay(date);
+        return { status: "ok", value: this.withDayLoss(read.value) };
+    }
+    readJsonFile(filename, parse) {
+        const filePath = join(this.directory, filename);
+        this.ioHooks?.beforeRead?.(filePath);
+        let text;
+        try {
+            text = readFileSync(filePath, "utf8");
+        }
+        catch (err) {
+            const code = typeof err === "object" && err !== null && "code" in err ? err.code : undefined;
+            if (code === "ENOENT")
+                return { status: "missing", value: null };
+            return { status: "corrupt", value: null, error: err instanceof Error ? err.message : "read-error" };
+        }
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            return { status: "corrupt", value: null, error: "invalid-json" };
+        }
+        const parsed = parse(json);
         if (!parsed.ok)
             return { status: "corrupt", value: null, error: "schema" };
-        this.days.set(date, mutableDay(parsed.value));
-        this.rememberKnownDay(date);
-        return { status: "ok", value: this.withDayLoss(parsed.value) };
+        return { status: "ok", value: parsed.value };
     }
     readDays(datesOrFrom, toOrOptions, maybeOptions) {
         const options = typeof toOrOptions === "object" ? toOrOptions : maybeOptions;
@@ -724,7 +754,7 @@ class AccountingStoreImpl {
     readDetail(requestId) {
         if (!DASHBOARD_REQUEST_ID_PATTERN.test(requestId))
             return { status: "missing", value: null };
-        if (this.fixedLoadPending || (this.recentReadState === "corrupt" && !this.dirtyRecent)) {
+        if (this.recentReadState === "corrupt" && !this.dirtyRecent) {
             return { status: "corrupt", value: null, error: "snapshot" };
         }
         if (this.recentReadState === "missing" && !this.dirtyRecent)
@@ -862,7 +892,7 @@ class AccountingStoreImpl {
         const pending = this.pending.get(event.requestId) ?? null;
         this.pending.delete(event.requestId);
         const work = { event, pending };
-        if (!this.fixedLoadPending && this.applyTerminal(work))
+        if (this.applyTerminal(work))
             return;
         if (this.queued.length >= this.pendingRequestLimit) {
             this.markGlobalLoss("unknown", "truncated", "pending_terminals");
@@ -895,7 +925,7 @@ class AccountingStoreImpl {
         return created;
     }
     drainQueued() {
-        if (this.fixedLoadPending || this.queued.length === 0)
+        if (this.queued.length === 0)
             return;
         const pending = this.queued.splice(0);
         for (const work of pending)
@@ -903,8 +933,6 @@ class AccountingStoreImpl {
                 this.queued.push(work);
     }
     applyTerminal(work) {
-        if (this.fixedLoadPending)
-            return false;
         const date = dayFor(work.event.endedAt);
         if (date === null || !this.ensureTransactionRoom(date))
             return false;
@@ -1123,177 +1151,79 @@ class AccountingStoreImpl {
     ensureTransactionRoom(date) {
         if (this.dirtyDays.has(date))
             return true;
-        const maximum = this.io.maxTargets;
-        if (maximum === null || maximum < 3)
-            return false;
+        const maximum = 128;
         if (this.dirtyDays.size + 3 <= maximum)
             return true;
         const flushed = this.flush();
-        return (flushed.status === "committed" || flushed.status === "recovered" || flushed.status === "none")
+        return (flushed.status === "committed" || flushed.status === "none")
             && this.dirtyDays.size + 3 <= maximum;
     }
     loadDayForWrite(date) {
         const cached = this.days.get(date);
         if (cached !== undefined)
             return cached;
-        const read = this.io.readJson(targetForDay(date), (value) => parseAccountingDayShardV1(value).ok, { quarantineCorrupt: true });
+        const read = this.readJsonFile(targetForDay(date), parseAccountingDayShardV1);
         if (read.status === "missing") {
             const created = emptyDay(date);
             this.days.set(date, created);
             return created;
         }
         if (read.status !== "ok" || read.value === null) {
-            if (read.status === "corrupt" || read.status === "oversize") {
-                this.markGlobalLoss("corrupt_recovery", "corrupt", "day");
-            }
-            return null;
-        }
-        const parsed = parseAccountingDayShardV1(read.value);
-        if (!parsed.ok) {
             this.markGlobalLoss("corrupt_recovery", "corrupt", "day");
             return null;
         }
-        const mutable = mutableDay(parsed.value);
+        const mutable = mutableDay(read.value);
         this.days.set(date, mutable);
         return mutable;
     }
-    deferFixedLoad(value) {
-        this.fixedLoadPending = true;
-        this.lifetimeReadState = "corrupt";
-        this.recentReadState = "corrupt";
-        this.last = value;
-        if (value.retryable)
-            this.scheduleRetry();
-    }
-    flushDeferredGlobalLosses() {
-        const losses = this.deferredGlobalLosses.splice(0);
-        for (const loss of losses)
-            this.markGlobalLoss(loss.reason, loss.kind, loss.field, loss.count);
-    }
     loadFixedSnapshotsReadOnly() {
-        const lifetime = this.io.readJson(LIFETIME_TARGET, (value) => parseAccountingLifetimeV1(value).ok, { quarantineCorrupt: false });
+        const lifetime = this.readJsonFile(LIFETIME_TARGET, parseAccountingLifetimeV1);
         this.lifetimeReadState = lifetime.status === "ok" && lifetime.value !== null
             ? "ok"
             : lifetime.status === "missing" ? "missing" : "corrupt";
         if (this.lifetimeReadState === "ok")
             this.lifetime = mutableLifetime(lifetime.value);
-        const recent = this.io.readJson(RECENT_TARGET, (value) => parseAccountingRecentV1(value).ok, { quarantineCorrupt: false });
+        const recent = this.readJsonFile(RECENT_TARGET, parseAccountingRecentV1);
         this.recentReadState = recent.status === "ok" && recent.value !== null
             ? "ok"
             : recent.status === "missing" ? "missing" : "corrupt";
         if (this.recentReadState === "ok")
             this.recent = mutableRecent(recent.value);
     }
-    recoverAndLoad() {
-        const recovered = this.io.recover();
-        if (recovered.status === "failed" || recovered.status === "invalid") {
-            this.pendingJournalLoss ||= recovered.lowerBoundLoss;
-            this.deferFixedLoad(recovered);
-            return;
-        }
+    loadFixedSnapshots() {
         let fixedLoss = false;
-        let fixedReadFailed = false;
-        const lifetime = this.io.readJson(LIFETIME_TARGET, (value) => parseAccountingLifetimeV1(value).ok, { quarantineCorrupt: true });
+        const lifetime = this.readJsonFile(LIFETIME_TARGET, parseAccountingLifetimeV1);
         if (lifetime.status === "ok" && lifetime.value !== null) {
-            const parsed = parseAccountingLifetimeV1(lifetime.value);
-            if (parsed.ok) {
-                this.lifetime = mutableLifetime(parsed.value);
-                this.lifetimeReadState = "ok";
-            }
-            else {
-                this.lifetimeReadState = "corrupt";
-                fixedLoss = true;
-            }
+            this.lifetime = mutableLifetime(lifetime.value);
+            this.lifetimeReadState = "ok";
         }
         else if (lifetime.status === "missing") {
             this.lifetimeReadState = "missing";
         }
-        else if (lifetime.status === "failed") {
-            this.lifetimeReadState = "corrupt";
-            fixedReadFailed = true;
-        }
         else {
             this.lifetimeReadState = "corrupt";
             fixedLoss = true;
         }
-        const recent = this.io.readJson(RECENT_TARGET, (value) => parseAccountingRecentV1(value).ok, { quarantineCorrupt: true });
+        const recent = this.readJsonFile(RECENT_TARGET, parseAccountingRecentV1);
         if (recent.status === "ok" && recent.value !== null) {
-            const parsed = parseAccountingRecentV1(recent.value);
-            if (parsed.ok) {
-                this.recent = mutableRecent(parsed.value);
-                this.recentReadState = "ok";
-            }
-            else {
-                this.recentReadState = "corrupt";
-                fixedLoss = true;
-            }
+            this.recent = mutableRecent(recent.value);
+            this.recentReadState = "ok";
         }
         else if (recent.status === "missing") {
             this.recentReadState = "missing";
         }
-        else if (recent.status === "failed") {
-            this.recentReadState = "corrupt";
-            fixedReadFailed = true;
-        }
         else {
             this.recentReadState = "corrupt";
             fixedLoss = true;
         }
-        if (fixedReadFailed) {
-            this.pendingFixedLoss ||= fixedLoss;
-            this.pendingJournalLoss ||= recovered.lowerBoundLoss || recovered.status === "recovery-loss";
-            this.deferFixedLoad(result("failed", "snapshot-read", true, this.lowerBoundLoss || this.pendingJournalLoss));
-            return;
-        }
-        fixedLoss ||= this.pendingFixedLoss;
-        const journalLoss = this.pendingJournalLoss || recovered.lowerBoundLoss || recovered.status === "recovery-loss";
-        this.pendingFixedLoss = false;
-        this.pendingJournalLoss = false;
-        this.fixedLoadPending = false;
-        this.flushDeferredGlobalLosses();
-        if (journalLoss)
-            this.consumeRecoveryLoss(recovered);
-        if (fixedLoss)
+        if (fixedLoss) {
             this.markGlobalLoss("corrupt_recovery", "corrupt", "snapshot");
+        }
         this.seedTrustedDateFromLifetime();
         const today = new Date(this.now()).toISOString().slice(0, 10);
         this.loadDayForWrite(today);
         this.queueRecoveredRetention();
-        this.last = recovered;
-    }
-    factSnapshots() {
-        const snapshots = {};
-        const encode = (name, value) => {
-            let text;
-            try {
-                text = JSON.stringify(value);
-            }
-            catch {
-                return false;
-            }
-            const ceiling = this.io.maxFileBytes;
-            if (ceiling === null || Buffer.byteLength(text, "utf8") > ceiling)
-                return false;
-            snapshots[name] = text;
-            return true;
-        };
-        if (this.dirtyLifetime) {
-            const lifetime = parsedLifetime(this.lifetime);
-            if (lifetime === null || !encode(LIFETIME_TARGET, lifetime))
-                return null;
-        }
-        if (this.dirtyRecent) {
-            const recent = parsedRecent(this.recent);
-            if (recent === null || !encode(RECENT_TARGET, recent))
-                return null;
-        }
-        for (const date of [...this.dirtyDays].sort()) {
-            const day = this.days.get(date);
-            const parsed = day === undefined ? null : parsedDay(day);
-            if (parsed === null || !encode(targetForDay(date), parsed))
-                return null;
-        }
-        return snapshots;
+        this.last = result("none");
     }
     commitRetention(committedDates) {
         if (this.retentionDays === null)
@@ -1310,15 +1240,12 @@ class AccountingStoreImpl {
             this.pendingRetentionPlan = null;
             return null;
         }
-        const maximum = this.io.maxTargets;
-        if (maximum === null || maximum < 1)
-            return this.fail(result("invalid", "retention-targets", false, this.lowerBoundLoss));
         const current = parsedLifetime(this.lifetime);
         if (current === null)
             return this.fail(result("invalid", "lifetime-schema", false, this.lowerBoundLoss));
         const progress = validDate(current.coverage.retentionFrom) ? current.coverage.retentionFrom : null;
         const start = progress ?? dayFor(current.firstRequestAt ?? "");
-        const retention = this.retentionCandidates(start, cutoff, Math.max(0, maximum - 1));
+        const retention = this.retentionCandidates(start, cutoff, 127);
         const candidates = retention.dates;
         if (retention.truncated && candidates.length === 0) {
             return this.fail(result("invalid", "retention-targets", false, this.lowerBoundLoss));
@@ -1335,23 +1262,28 @@ class AccountingStoreImpl {
             markCoverage(next.coverage, "unknown", "truncated", "retention");
         }
         const plan = { cutoff, candidates, next, truncated: retention.truncated };
-        const snapshots = {};
         const retainedLifetime = parsedLifetime(next);
         if (retainedLifetime === null)
             return this.fail(result("invalid", "retention-schema-or-size", false, this.lowerBoundLoss));
-        const serialized = JSON.stringify(retainedLifetime);
-        const ceiling = this.io.maxFileBytes;
-        if (serialized === undefined || ceiling === null || Buffer.byteLength(serialized, "utf8") > ceiling) {
-            return this.fail(result("invalid", "retention-schema-or-size", false, this.lowerBoundLoss));
+        try {
+            const filePath = join(this.directory, LIFETIME_TARGET);
+            if (!atomicWriteJsonSync(filePath, retainedLifetime, { strict: true })) {
+                throw new Error(`Failed to write ${LIFETIME_TARGET}`);
+            }
+            for (const date of candidates) {
+                try {
+                    unlinkSync(join(this.directory, targetForDay(date)));
+                }
+                catch (err) {
+                    const code = typeof err === "object" && err !== null && "code" in err ? err.code : undefined;
+                    if (code !== "ENOENT")
+                        throw err;
+                }
+            }
+        }
+        catch (err) {
+            return this.fail(result("failed", err instanceof Error ? err.message : String(err), true, this.lowerBoundLoss));
         }
-        snapshots[LIFETIME_TARGET] = serialized;
-        for (const date of candidates)
-            snapshots[targetForDay(date)] = null;
-        this.pendingRetentionPlan = plan;
-        const written = this.io.commit(snapshots);
-        this.last = written;
-        if (written.status !== "committed" && written.status !== "recovered")
-            return this.fail(written);
         this.applyRetentionPlan(plan);
         this.pendingRetentionPlan = null;
         if (plan.truncated) {
@@ -1362,6 +1294,8 @@ class AccountingStoreImpl {
         else {
             this.pendingRetention = null;
         }
+        const written = result("committed", null, false, this.lowerBoundLoss);
+        this.last = written;
         return written;
     }
     retentionCandidates(start, cutoff, limit) {
@@ -1500,35 +1434,7 @@ class AccountingStoreImpl {
         const cutoff = new Date(at - (this.retentionDays - 1) * 86_400_000).toISOString().slice(0, 10);
         return validDate(cutoff) ? cutoff : null;
     }
-    consumeRecoveryLoss(_recovered) {
-        if (this.lowerBoundLoss)
-            return;
-        this.lowerBoundLoss = true;
-        this.markGlobalLoss("corrupt_recovery", "corrupt", "journal");
-        this.scheduleFlush();
-    }
     markGlobalLoss(reason, kind, field, count = 1) {
-        if (this.fixedLoadPending) {
-            const existing = this.deferredGlobalLosses.find((loss) => loss.reason === reason && loss.kind === kind && loss.field === field);
-            if (existing !== undefined) {
-                if (!increase(existing, "count", count))
-                    existing.count = Number.MAX_SAFE_INTEGER;
-            }
-            else if (this.deferredGlobalLosses.length < ACCOUNTING_MAX_LOSS_MARKERS) {
-                this.deferredGlobalLosses.push({ reason, kind, field, count });
-            }
-            else {
-                const summary = this.deferredGlobalLosses.find((loss) => loss.field === "deferred_loss");
-                if (summary !== undefined) {
-                    if (!increase(summary, "count", count))
-                        summary.count = Number.MAX_SAFE_INTEGER;
-                }
-                else {
-                    this.deferredGlobalLosses[this.deferredGlobalLosses.length - 1] = { reason: "unknown", kind: "truncated", field: "deferred_loss", count };
-                }
-            }
-            return;
-        }
         if (reason === "corrupt_recovery")
             this.lowerBoundLoss = true;
         markCoverage(this.lifetime.coverage, reason, kind, field, count);