@sema-agent/core 1.451.0 → 2.0.0

package/dist/prompts/default.js

@@ -351,7 +351,6 @@ export const TOOL_PARAM_JSON = `
 ## Tool-call arguments
 An object or array parameter value must be a single JSON value — never write parameter-tag markup (XML-ish <param> tags) inside a JSON value. Pass the structured value directly as JSON.`;
 export const CODE_SYSTEM_PROMPT = CODE_AGENT_PROMPT + AUTONOMY_SELF_AUDIT + ANTI_VERBOSITY + TOOL_PARAM_JSON;
-export const FULL_BODY_SYSTEM_PROMPT = CODE_SYSTEM_PROMPT;
 function joinParts(parts) {
     return parts.filter((p) => Boolean(p && p.trim())).join("\n\n");
 }
@@ -389,9 +388,6 @@ function defaultStableSystem(ctx) {
 }
 export const defaultPromptProvider = {
     stableSystem: defaultStableSystem,
-    system(ctx) {
-        return composeSystemPrompt(defaultStableSystem(ctx), ctx.memoryBlock);
-    },
 };
 const PROBE_MEMORY_A = "<user_memory>\nAAAA durable fact alpha (2026-01-01 00:00 UTC)\n</user_memory>";
 const PROBE_MEMORY_B = "<user_memory>\nBBBB durable fact bravo (2099-12-31 23:59 UTC)\n</user_memory>";
@@ -399,13 +395,9 @@ export function analyzePromptCacheFriendliness(provider, opts = {}) {
     const tools = opts.tools ?? [];
     const minRatio = opts.minStablePrefixRatio ?? 0.5;
     const build = (memoryBlock) => {
-        if (provider.stableSystem) {
-            return composeSystemPrompt(provider.stableSystem({ userSystemPrompt: opts.userSystemPrompt, tools, memoryEnabled: true }), memoryBlock);
-        }
-        if (provider.system) {
-            return provider.system({ userSystemPrompt: opts.userSystemPrompt, memoryBlock, tools, memoryEnabled: true });
-        }
-        throw new Error("PromptProvider implements neither stableSystem nor system");
+        if (!provider.stableSystem)
+            throw new Error("PromptProvider does not implement stableSystem");
+        return composeSystemPrompt(provider.stableSystem({ userSystemPrompt: opts.userSystemPrompt, tools, memoryEnabled: true }), memoryBlock);
     };
     const a = build(PROBE_MEMORY_A);
     const b = build(PROBE_MEMORY_B);

package/dist/scenarios/env.d.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "../internal/harness.js";
+import type { ThinkingLevel } from "../internal/harness-types.js";
 import { type ScenarioId } from "./scenario-registry.js";
 export type OrchestrationMode = "solo" | "teacher";
 export declare const DEFAULT_REASONING_INTENSITY: ThinkingLevel;

package/dist/scenarios/full-body.d.ts

@@ -10,8 +10,5 @@ export interface CodeToolsConfig {
     taskList?: boolean;
     taskListStore?: TaskListStore;
 }
-export type FullBodyToolsConfig = CodeToolsConfig;
 export declare function assembleCodeTools(cfg?: CodeToolsConfig): ToolSpec[];
-export declare const assembleFullBodyTools: typeof assembleCodeTools;
 export declare const CODE_ROLE: RoleSpec;
-export declare const FULL_BODY_ROLE: RoleSpec;

package/dist/scenarios/full-body.js

@@ -17,6 +17,4 @@ export function assembleCodeTools(cfg = {}) {
         tools.push(...createTaskListTools(cfg.taskListStore));
     return tools;
 }
-export const assembleFullBodyTools = assembleCodeTools;
 export const CODE_ROLE = { systemPrompt: CODE_SYSTEM_PROMPT, thinking: "high" };
-export const FULL_BODY_ROLE = CODE_ROLE;

package/dist/stores/cc/mailbox-store.js

@@ -89,9 +89,12 @@ export function createCcFileMailboxStore(opts) {
             leases.set(key, { owner, expiresAt: t + ttlMs, maxSeq });
             return Promise.resolve({ maxSeq, messages: pending });
         },
-        ack: (scope, handle, upToSeq) => {
+        ack: (scope, handle, owner, upToSeq) => {
             requireDefaultScope(scope);
             const path = inboxPath(handle);
+            const held = leases.get(path);
+            if (held === undefined || held.owner !== owner)
+                return Promise.resolve();
             if (!existsSync(path))
                 return Promise.resolve();
             return withCcLock(path, () => {
@@ -105,6 +108,8 @@ export function createCcFileMailboxStore(opts) {
                 }
                 if (changed)
                     saveBox(path, box);
+                if (held.maxSeq <= upToSeq)
+                    leases.delete(path);
             });
         },
         releaseLease: (scope, handle, owner) => {

package/dist/stores/file/background-agent-store.d.ts

@@ -4,25 +4,13 @@ export interface FileBackgroundAgentStoreOptions {
     compactEvery?: number;
 }
 export declare class FileBackgroundAgentStore implements BackgroundAgentStore {
-    private readonly dir;
-    private readonly tmpDir;
-    private readonly ledgerPath;
-    private readonly snapshotPath;
     private readonly fsyncEnabled;
     private readonly compactEvery;
-    private readonly shared;
+    private readonly ledger;
     private closed;
     private get rows();
-    private get locks();
-    private get ledgerEvents();
-    private set ledgerEvents(value);
-    private get log();
-    private set log(value);
     constructor(root: string, opts?: FileBackgroundAgentStoreOptions);
-    private readonly canonicalDir;
-    private key;
-    private replay;
-    private applyEvent;
+    static key(handle: string, scope: string): string;
     private withLock;
     private commit;
     put(record: BackgroundAgentRecord): Promise<void>;
@@ -53,7 +41,6 @@ export declare class FileBackgroundAgentStore implements BackgroundAgentStore {
         keep?: number;
         staleRunningMaxAgeMs?: number;
     }): Promise<number>;
-    private compact;
     compactNow(): void;
     get size(): number;
     close(): void;

package/dist/stores/file/background-agent-store.js

@@ -1,105 +1,49 @@
 import { join } from "node:path";
-import { BackgroundAgentStoreError, } from "../../core/background-agent-store.js";
-import { canonicalStoreKey, AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "./fs-atomic.js";
-const sharedAgentDirs = new Map();
+import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, } from "../../core/background-agent-store.js";
+import { SharedLedgerTable } from "./shared-ledger.js";
+const agentLedgers = new SharedLedgerTable({
+    keyOf: (r) => FileBackgroundAgentStore.key(r.handle, r.scope),
+    apply: (rows, ev) => {
+        if (ev.t === "delete") {
+            rows.delete(ev.k);
+            return;
+        }
+        rows.set(ev.k, ev.r);
+    },
+});
 export class FileBackgroundAgentStore {
-    dir;
-    tmpDir;
-    ledgerPath;
-    snapshotPath;
     fsyncEnabled;
     compactEvery;
-    shared;
+    ledger;
     closed = false;
     get rows() {
-        return this.shared.rows;
-    }
-    get locks() {
-        return this.shared.locks;
-    }
-    get ledgerEvents() {
-        return this.shared.ledgerEvents;
-    }
-    set ledgerEvents(v) {
-        this.shared.ledgerEvents = v;
-    }
-    get log() {
-        return this.shared.log;
-    }
-    set log(v) {
-        this.shared.log = v;
+        return this.ledger.rows;
     }
     constructor(root, opts = {}) {
-        this.dir = join(root, "background-agents");
-        this.tmpDir = join(root, "tmp");
-        this.ledgerPath = join(this.dir, "agents.jsonl");
-        this.snapshotPath = join(this.dir, "agents.snapshot.jsonl");
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 1000;
-        ensureDir(this.dir);
-        ensureDir(this.tmpDir);
-        const canonical = canonicalStoreKey(this.dir);
-        const existing = sharedAgentDirs.get(canonical);
-        if (existing !== undefined) {
-            existing.refs += 1;
-            this.shared = existing;
-            this.canonicalDir = canonical;
-            return;
-        }
-        this.shared = { rows: new Map(), locks: new Map(), ledgerEvents: 0, log: undefined, refs: 1 };
-        this.canonicalDir = canonical;
-        sharedAgentDirs.set(canonical, this.shared);
-        this.replay();
-        this.log = new AppendLog(this.ledgerPath);
+        const dir = join(root, "background-agents");
+        this.ledger = agentLedgers.acquire({
+            dir,
+            tmpDir: join(root, "tmp"),
+            ledgerPath: join(dir, "agents.jsonl"),
+            snapshotPath: join(dir, "agents.snapshot.jsonl"),
+        });
     }
-    canonicalDir;
-    key(handle, scope) {
+    static key(handle, scope) {
         return `${scope}\u0000${handle}`;
     }
-    replay() {
-        for (const snap of readJsonlRecords(this.snapshotPath)) {
-            this.rows.set(this.key(snap.handle, snap.scope), snap);
-        }
-        const events = readJsonlRecords(this.ledgerPath);
-        this.ledgerEvents = events.length;
-        for (const ev of events)
-            this.applyEvent(ev);
-    }
-    applyEvent(ev) {
-        if (ev.t === "delete") {
-            this.rows.delete(ev.k);
-            return;
-        }
-        this.rows.set(ev.k, ev.r);
-    }
     withLock(key, fn) {
-        const prev = this.locks.get(key) ?? Promise.resolve();
-        const run = prev.then(() => fn(), () => fn());
-        const tail = run.then(() => { }, () => { });
-        this.locks.set(key, tail);
-        void tail.then(() => {
-            if (this.locks.get(key) === tail)
-                this.locks.delete(key);
-        });
-        return run;
+        return this.ledger.withLock(key, fn);
     }
     commit(ev) {
-        this.log.append(ev, this.fsyncEnabled);
-        this.applyEvent(ev);
-        this.ledgerEvents++;
-        if (this.ledgerEvents >= this.compactEvery) {
-            try {
-                this.compact();
-            }
-            catch {
-            }
-        }
+        this.ledger.commit(ev, this.fsyncEnabled, this.compactEvery);
     }
     async put(record) {
         if (record.scope === undefined || record.scope === "") {
             throw new Error("BackgroundAgentStore.put: refusing a row without a scope (world-readable through the fallback)");
         }
-        const k = this.key(record.handle, record.scope);
+        const k = FileBackgroundAgentStore.key(record.handle, record.scope);
         return this.withLock(k, () => {
             if (this.rows.has(k)) {
                 throw new BackgroundAgentStoreError("agent_record.already_exists", "agent record already exists");
@@ -110,11 +54,11 @@ export class FileBackgroundAgentStore {
         });
     }
     async get(handle, scope) {
-        const row = this.rows.get(this.key(handle, scope));
+        const row = this.rows.get(FileBackgroundAgentStore.key(handle, scope));
         return row ? structuredClone(row) : null;
     }
     async update(handle, scope, record, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, () => {
             const live = this.rows.get(k);
             if (!live || live.scope !== scope || live.rev !== expect.rev)
@@ -128,7 +72,7 @@ export class FileBackgroundAgentStore {
         });
     }
     async updateIf(handle, scope, record, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, async () => {
             const live = this.rows.get(k);
             if (!live || live.scope !== scope || live.rev !== expect.rev)
@@ -178,7 +122,7 @@ export class FileBackgroundAgentStore {
         return [...new Set([...this.rows.values()].map((r) => r.scope))].sort();
     }
     async delete(handle, scope, expect) {
-        const k = this.key(handle, scope);
+        const k = FileBackgroundAgentStore.key(handle, scope);
         return this.withLock(k, () => {
             const live = this.rows.get(k);
             if (!live)
@@ -205,7 +149,8 @@ export class FileBackgroundAgentStore {
                     const next = structuredClone(live);
                     next.status = "failed";
                     next.stoppedBy = "system";
-                    next.summary = next.summary ?? "host process interrupted (stale running row reaped)";
+                    next.summary = next.summary ?? STALE_RUNNING_REAP_ATTRIBUTION;
+                    next.error = next.error ?? STALE_RUNNING_REAP_ATTRIBUTION;
                     next.settledAt = now;
                     next.updatedAt = now;
                     next.rev = live.rev + 1;
@@ -247,15 +192,8 @@ export class FileBackgroundAgentStore {
         }
         return changed.size;
     }
-    compact() {
-        const lines = [...this.rows.values()].map((r) => JSON.stringify(r)).join("\n");
-        atomicWriteFile(this.tmpDir, this.snapshotPath, lines.length ? `${lines}\n` : "");
-        this.log.closeForSwap();
-        atomicWriteFile(this.tmpDir, this.ledgerPath, "");
-        this.ledgerEvents = 0;
-    }
     compactNow() {
-        this.compact();
+        this.ledger.compact();
     }
     get size() {
         return this.rows.size;
@@ -264,14 +202,7 @@ export class FileBackgroundAgentStore {
         if (this.closed)
             return;
         this.closed = true;
-        const st = sharedAgentDirs.get(this.canonicalDir);
-        if (st !== undefined && st === this.shared) {
-            st.refs -= 1;
-            if (st.refs > 0)
-                return;
-            sharedAgentDirs.delete(this.canonicalDir);
-        }
-        this.log.close();
+        this.ledger.release();
     }
 }
 function toSummary(r) {

package/dist/stores/file/checkpoint-store.d.ts

@@ -4,25 +4,13 @@ export interface FileCheckpointStoreOptions {
     compactEvery?: number;
 }
 export declare class FileCheckpointStore implements CheckpointStore {
-    private readonly dir;
-    private readonly tmpDir;
-    private readonly ledgerPath;
-    private readonly snapshotPath;
     private readonly fsyncEnabled;
     private readonly compactEvery;
-    private readonly shared;
-    private readonly sharedKey;
+    private readonly ledger;
     private closed;
     private get cps();
-    private get locks();
-    private get ledgerEvents();
-    private set ledgerEvents(value);
-    private get log();
-    private set log(value);
     private fault;
     constructor(root: string, opts?: FileCheckpointStoreOptions);
-    private replay;
-    private applyEvent;
     private withLock;
     private commit;
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
@@ -37,7 +25,6 @@ export declare class FileCheckpointStore implements CheckpointStore {
     reap(scope: string, cutoff: number): Promise<number>;
     listByScope(scope: string): Promise<CheckpointSummary[]>;
     listScopes(): Promise<string[]>;
-    private compact;
     compactNow(): void;
     testInjectFault(mode: CheckpointFaultMode | null): void;
     get size(): number;

package/dist/stores/file/checkpoint-store.js

@@ -1,124 +1,64 @@
 import { join } from "node:path";
 import { CheckpointError, summarizeCheckpoint, validatePendingSteer, winnerFromOutcome, } from "../../core/checkpoint-store.js";
-import { canonicalStoreKey, AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "./fs-atomic.js";
-const sharedCheckpointDirs = new Map();
+import { SharedLedgerTable } from "./shared-ledger.js";
+function applyCheckpointEvent(cps, ev) {
+    if (ev.t === "put") {
+        cps.set(ev.token, ev.cp);
+        return;
+    }
+    const cp = cps.get(ev.token);
+    if (!cp)
+        return;
+    switch (ev.t) {
+        case "resolve":
+            cp.status = "resolved";
+            cp.rev = ev.rev;
+            if (ev.resolvedOutcome !== undefined)
+                cp.resolvedOutcome = ev.resolvedOutcome;
+            cp.reopenReason = undefined;
+            break;
+        case "reopen":
+            cp.status = "pending";
+            cp.rev = ev.rev;
+            cp.reopenReason = ev.reason;
+            break;
+        case "expire":
+            cp.status = "expired";
+            break;
+        case "steer":
+            cp.state.pendingSteer = ev.steer;
+            break;
+    }
+}
+const checkpointLedgers = new SharedLedgerTable({
+    keyOf: (cp) => cp.token,
+    apply: applyCheckpointEvent,
+});
 export class FileCheckpointStore {
-    dir;
-    tmpDir;
-    ledgerPath;
-    snapshotPath;
     fsyncEnabled;
     compactEvery;
-    shared;
-    sharedKey;
+    ledger;
     closed = false;
     get cps() {
-        return this.shared.cps;
-    }
-    get locks() {
-        return this.shared.locks;
-    }
-    get ledgerEvents() {
-        return this.shared.ledgerEvents;
-    }
-    set ledgerEvents(v) {
-        this.shared.ledgerEvents = v;
-    }
-    get log() {
-        return this.shared.log;
-    }
-    set log(v) {
-        this.shared.log = v;
+        return this.ledger.rows;
     }
     fault = null;
     constructor(root, opts = {}) {
-        this.dir = join(root, "checkpoints");
-        this.tmpDir = join(root, "tmp");
-        this.ledgerPath = join(this.dir, "checkpoints.jsonl");
-        this.snapshotPath = join(this.dir, "checkpoints.snapshot.jsonl");
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 1000;
-        ensureDir(this.dir);
-        ensureDir(this.tmpDir);
-        const key = canonicalStoreKey(this.dir);
-        this.sharedKey = key;
-        const live = sharedCheckpointDirs.get(key);
-        if (live !== undefined) {
-            live.refs += 1;
-            this.shared = live;
-            return;
-        }
-        this.shared = {
-            cps: new Map(),
-            locks: new Map(),
-            ledgerEvents: 0,
-            log: undefined,
-            refs: 1,
-        };
-        sharedCheckpointDirs.set(key, this.shared);
-        this.replay();
-        this.log = new AppendLog(this.ledgerPath);
-    }
-    replay() {
-        for (const snap of readJsonlRecords(this.snapshotPath)) {
-            this.cps.set(snap.token, snap);
-        }
-        const events = readJsonlRecords(this.ledgerPath);
-        this.ledgerEvents = events.length;
-        for (const ev of events)
-            this.applyEvent(ev);
-    }
-    applyEvent(ev) {
-        if (ev.t === "put") {
-            this.cps.set(ev.token, ev.cp);
-            return;
-        }
-        const cp = this.cps.get(ev.token);
-        if (!cp)
-            return;
-        switch (ev.t) {
-            case "resolve":
-                cp.status = "resolved";
-                cp.rev = ev.rev;
-                if (ev.resolvedOutcome !== undefined)
-                    cp.resolvedOutcome = ev.resolvedOutcome;
-                cp.reopenReason = undefined;
-                break;
-            case "reopen":
-                cp.status = "pending";
-                cp.rev = ev.rev;
-                cp.reopenReason = ev.reason;
-                break;
-            case "expire":
-                cp.status = "expired";
-                break;
-            case "steer":
-                cp.state.pendingSteer = ev.steer;
-                break;
-        }
+        const dir = join(root, "checkpoints");
+        this.ledger = checkpointLedgers.acquire({
+            dir,
+            tmpDir: join(root, "tmp"),
+            ledgerPath: join(dir, "checkpoints.jsonl"),
+            snapshotPath: join(dir, "checkpoints.snapshot.jsonl"),
+        });
     }
     withLock(token, fn) {
-        const prev = this.locks.get(token) ?? Promise.resolve();
-        const run = prev.then(() => fn(), () => fn());
-        const tail = run.then(() => { }, () => { });
-        this.locks.set(token, tail);
-        void tail.then(() => {
-            if (this.locks.get(token) === tail)
-                this.locks.delete(token);
-        });
-        return run;
+        return this.ledger.withLock(token, fn);
     }
     commit(ev, fsync) {
-        this.log.append(ev, fsync);
-        this.applyEvent(ev);
-        this.ledgerEvents++;
-        if (this.ledgerEvents >= this.compactEvery) {
-            try {
-                this.compact();
-            }
-            catch {
-            }
-        }
+        this.ledger.commit(ev, fsync, this.compactEvery);
     }
     async put(token, cp) {
         return this.withLock(token, () => {
@@ -222,15 +162,8 @@ export class FileCheckpointStore {
                 out.add(cp.scope);
         return [...out];
     }
-    compact() {
-        const lines = [...this.cps.values()].map((cp) => JSON.stringify(cp)).join("\n");
-        atomicWriteFile(this.tmpDir, this.snapshotPath, lines.length ? `${lines}\n` : "");
-        this.log.closeForSwap();
-        atomicWriteFile(this.tmpDir, this.ledgerPath, "");
-        this.ledgerEvents = 0;
-    }
     compactNow() {
-        this.compact();
+        this.ledger.compact();
     }
     testInjectFault(mode) {
         this.fault = mode;
@@ -242,11 +175,6 @@ export class FileCheckpointStore {
         if (this.closed)
             return;
         this.closed = true;
-        this.shared.refs -= 1;
-        if (this.shared.refs > 0)
-            return;
-        this.log.close();
-        if (sharedCheckpointDirs.get(this.sharedKey) === this.shared)
-            sharedCheckpointDirs.delete(this.sharedKey);
+        this.ledger.release();
     }
 }

package/dist/stores/file/file-snapshot-store.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../../internal/harness.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 import { type FileSnapshotBounds, type FileSnapshotResult, type FileSnapshotStore } from "../../core/file-snapshot-store.js";
 export declare class FileFileSnapshotStore implements FileSnapshotStore {
     private readonly base;

package/dist/stores/file/mailbox-store.d.ts

@@ -21,7 +21,7 @@ export declare class FileMailboxStore implements MailboxStore {
         sentAt: number;
     }): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
-    ack(scope: string, handle: string, upToSeq: number): Promise<void>;
+    ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
     peekCount(scope: string, handle: string): Promise<number>;
     drop(scope: string, handle: string): Promise<void>;

package/dist/stores/file/mailbox-store.js

@@ -1,6 +1,6 @@
 import { join, resolve, sep } from "node:path";
 import { existsSync, realpathSync } from "node:fs";
-import {} from "../../core/mailbox-store.js";
+import { newestSentAt, } from "../../core/mailbox-store.js";
 import { AppendLog, atomicWriteFile, canonicalStoreKey, ensureDir, readJsonlRecords, sanitizeScope, sanitizePathComponent } from "./fs-atomic.js";
 function realpathSyncSafe(p) {
     try {
@@ -86,7 +86,7 @@ export class FileMailboxStore {
             lines.push(JSON.stringify({ t: "lease", ...b.lease }));
         b.log.closeForSwap();
         atomicWriteFile(this.tmpDir, path, lines.length ? `${lines.join("\n")}\n` : "");
-        b.events = lines.length;
+        b.events = 0;
     }
     async append(scope, handle, msg) {
         if (scope === undefined || scope === "")
@@ -111,9 +111,11 @@ export class FileMailboxStore {
             return { messages: b.messages.map((m) => ({ ...m })), maxSeq };
         });
     }
-    async ack(scope, handle, upToSeq) {
+    async ack(scope, handle, owner, upToSeq) {
         return withPathLock(this.lockKey(scope, handle), () => {
             const b = this.load(scope, handle);
+            if (b.lease === undefined || b.lease.owner !== owner)
+                return;
             this.commit(b, this.boxPath(scope, handle), { t: "ack", upToSeq });
         });
     }
@@ -160,15 +162,15 @@ export class FileMailboxStore {
         for (const [key, b] of [...sharedBoxes]) {
             if (!b.path.startsWith(prefix))
                 continue;
-            const seen = b.messages[b.messages.length - 1];
-            if (seen === undefined || seen.sentAt >= now - maxAgeMs)
+            const seen = newestSentAt(b.messages);
+            if (seen === undefined || seen >= now - maxAgeMs)
                 continue;
             const swept = await withPathLock(key, () => {
                 const live = sharedBoxes.get(key);
                 if (live === undefined || live !== b)
                     return false;
-                const newest = b.messages[b.messages.length - 1];
-                if (newest === undefined || newest.sentAt >= now - maxAgeMs)
+                const newest = newestSentAt(b.messages);
+                if (newest === undefined || newest >= now - maxAgeMs)
                     return false;
                 b.messages = [];
                 delete b.lease;

package/dist/stores/file/shared-ledger.d.ts

@@ -0,0 +1,35 @@
+export interface LedgerPaths {
+    readonly dir: string;
+    readonly tmpDir: string;
+    readonly ledgerPath: string;
+    readonly snapshotPath: string;
+}
+export interface LedgerModel<Row, Ev> {
+    keyOf(row: Row): string;
+    apply(rows: Map<string, Row>, ev: Ev): void;
+}
+export declare class LedgerCore<Row, Ev> {
+    private readonly key;
+    private readonly paths;
+    private readonly model;
+    private readonly table;
+    readonly rows: Map<string, Row>;
+    refs: number;
+    private readonly locks;
+    private events;
+    private handle;
+    constructor(key: string, paths: LedgerPaths, model: LedgerModel<Row, Ev>, table: Map<string, LedgerCore<Row, Ev>>);
+    bootstrap(): void;
+    withLock<T>(key: string, fn: () => Promise<T> | T): Promise<T>;
+    commit(ev: Ev, fsync: boolean, compactEvery: number): void;
+    compact(): void;
+    release(): void;
+    get pendingEvents(): number;
+    private get log();
+}
+export declare class SharedLedgerTable<Row, Ev> {
+    private readonly model;
+    private readonly live;
+    constructor(model: LedgerModel<Row, Ev>);
+    acquire(paths: LedgerPaths): LedgerCore<Row, Ev>;
+}