@llblab/pi-actors 0.42.2 → 0.43.0

package/dist/lib/rooms.js

@@ -1,647 +0,0 @@
-/**
- * Actor room persistence.
- * Zones: room timelines, rosters, branch inboxes, cross-branch discovery state
- * Owns file-backed room and branch-mailbox state; routing policy stays in tools/runtime adapters.
- */
-import * as fs from "node:fs";
-import { randomUUID } from "node:crypto";
-import * as path from "node:path";
-import * as Limits from "./limits.js";
-import { notifyRuntimeWake } from "./runtime-notifier.js";
-import { formatStateReadDiagnostics, readJsonFileResilient, readJsonlFileResilient, } from "./state-readers.js";
-const STATE_LOCK_MAX_AGE_MS = 5 * 60 * 1000;
-const STATE_LOCK_TIMEOUT_MS = 5000;
-const DEFAULT_ROOM_MAX_MESSAGES = 10000;
-const DEFAULT_BRANCH_INBOX_TERMINAL_RETAINED = 2000;
-const DEFAULT_SNAPSHOT_MIN_INTERVAL_MS = 250;
-function roomDir(stateDir, room) {
-    return path.join(stateDir, "rooms", room);
-}
-function messagesFile(stateDir, room) {
-    return path.join(roomDir(stateDir, room), "messages.jsonl");
-}
-function rosterFile(stateDir, room) {
-    return path.join(roomDir(stateDir, room), "roster.json");
-}
-function snapshotFile(stateDir) {
-    return path.join(stateDir, "communication.json");
-}
-function branchSnapshotFile(stateDir, branch) {
-    return path.join(stateDir, "branches", branch, "communication.json");
-}
-function branchInboxFile(stateDir, branch) {
-    return path.join(stateDir, "branches", branch, "inbox.jsonl");
-}
-function branchIdFromAddress(address, run) {
-    if (!address)
-        return undefined;
-    const match = new RegExp(`^branch:${run}/(.+)$`).exec(address);
-    return match?.[1];
-}
-function ensureRoomDir(stateDir, room) {
-    fs.mkdirSync(roomDir(stateDir, room), { recursive: true });
-}
-function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function acquireStateLock(parentDir, name, label) {
-    fs.mkdirSync(parentDir, { recursive: true });
-    const lockDir = path.join(parentDir, name);
-    const started = Date.now();
-    while (true) {
-        try {
-            fs.mkdirSync(lockDir);
-            fs.writeFileSync(path.join(lockDir, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: new Date().toISOString() })}\n`);
-            return () => fs.rmSync(lockDir, { recursive: true, force: true });
-        }
-        catch (error) {
-            try {
-                const stat = fs.statSync(lockDir);
-                if (Date.now() - stat.mtimeMs > STATE_LOCK_MAX_AGE_MS) {
-                    fs.rmSync(lockDir, { recursive: true, force: true });
-                    continue;
-                }
-            }
-            catch {
-                continue;
-            }
-            if (Date.now() - started > STATE_LOCK_TIMEOUT_MS) {
-                throw new Error(`${label} lock timed out.`, { cause: error });
-            }
-            sleepSync(10);
-        }
-    }
-}
-function acquireRoomLock(stateDir, room) {
-    return acquireStateLock(roomDir(stateDir, room), ".append.lock", `Room append ${room}`);
-}
-function acquireBranchInboxLock(stateDir, branch) {
-    return acquireStateLock(path.dirname(branchInboxFile(stateDir, branch)), ".inbox.lock", `Branch inbox ${branch}`);
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-function runFromRoomAddress(address) {
-    const match = /^room:([^/]+)(?:\/main)?$/.exec(address);
-    return match?.[1];
-}
-function readJsonFile(file, fallback) {
-    return readJsonFileResilient(file, fallback).value;
-}
-function writeJsonFile(file, value) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
-}
-function notifyActorWake(stateDir, actor, reason, metadata = {}) {
-    try {
-        notifyRuntimeWake(stateDir, { actor, metadata, reason });
-    }
-    catch {
-        // Runtime wakes are advisory; durable room/inbox state remains canonical.
-    }
-}
-function positiveEnvInt(name, fallback) {
-    const value = Number(process.env[name] ?? fallback);
-    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-function roomMaxMessages() {
-    return positiveEnvInt("PI_ACTORS_ROOM_MAX_MESSAGES", DEFAULT_ROOM_MAX_MESSAGES);
-}
-function snapshotMinIntervalMs() {
-    return positiveEnvInt("PI_ACTORS_COMMUNICATION_SNAPSHOT_MIN_MS", DEFAULT_SNAPSHOT_MIN_INTERVAL_MS);
-}
-function rosterMinIntervalMs() {
-    return positiveEnvInt("PI_ACTORS_ROOM_ROSTER_MIN_MS", DEFAULT_SNAPSHOT_MIN_INTERVAL_MS);
-}
-function compactRoomMessages(stateDir, room) {
-    const maxMessages = roomMaxMessages();
-    const file = messagesFile(stateDir, room);
-    const lines = readJsonlTailLines(file, maxMessages + 1);
-    if (lines.length <= maxMessages)
-        return;
-    const kept = lines.slice(-maxMessages);
-    fs.writeFileSync(file, `${kept.join("\n")}\n`);
-    const keptMessages = kept.flatMap((line) => {
-        try {
-            return [JSON.parse(line)];
-        }
-        catch {
-            return [];
-        }
-    });
-    writeJsonFile(path.join(roomDir(stateDir, room), "compaction.json"), {
-        compacted_at: new Date().toISOString(),
-        dropped_count: lines.length - kept.length,
-        ...(keptMessages[0]?.received_at
-            ? { first_kept_at: keptMessages[0].received_at }
-            : {}),
-        ...(keptMessages.at(-1)?.received_at
-            ? { last_kept_at: keptMessages.at(-1)?.received_at }
-            : {}),
-        max_messages: maxMessages,
-    });
-}
-function readJsonlLineCount(file) {
-    const stat = fs.statSync(file);
-    if (stat.size === 0)
-        return 0;
-    const fd = fs.openSync(file, "r");
-    try {
-        const chunkSize = 64 * 1024;
-        const chunk = Buffer.allocUnsafe(chunkSize);
-        let position = 0;
-        let count = 0;
-        let lastByte;
-        while (position < stat.size) {
-            const bytesRead = fs.readSync(fd, chunk, 0, Math.min(chunkSize, stat.size - position), position);
-            if (bytesRead <= 0)
-                break;
-            position += bytesRead;
-            for (let index = 0; index < bytesRead; index += 1) {
-                if (chunk[index] === 10)
-                    count += 1;
-            }
-            lastByte = chunk[bytesRead - 1];
-        }
-        return lastByte === 10 ? count : count + 1;
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function readRoomMessageCount(stateDir, room) {
-    try {
-        return readJsonlLineCount(messagesFile(stateDir, room));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return 0;
-        throw error;
-    }
-}
-function readJsonlTailLines(file, limit) {
-    const lineLimit = Math.max(1, limit);
-    const stat = fs.statSync(file);
-    if (stat.size === 0)
-        return [];
-    const fd = fs.openSync(file, "r");
-    try {
-        const chunkSize = 64 * 1024;
-        const chunks = [];
-        let position = stat.size;
-        let newlines = 0;
-        while (position > 0 && newlines <= lineLimit) {
-            const size = Math.min(chunkSize, position);
-            position -= size;
-            const chunk = Buffer.allocUnsafe(size);
-            fs.readSync(fd, chunk, 0, size, position);
-            chunks.unshift(chunk);
-            for (let index = size - 1; index >= 0; index -= 1) {
-                if (chunk[index] === 10)
-                    newlines += 1;
-            }
-        }
-        return Buffer.concat(chunks)
-            .toString("utf8")
-            .split("\n")
-            .filter(Boolean)
-            .slice(-lineLimit);
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-export function readRoomRoster(stateDir, room) {
-    return readJsonFile(rosterFile(stateDir, room), {});
-}
-function writeRoomRoster(stateDir, room, roster) {
-    ensureRoomDir(stateDir, room);
-    writeJsonFile(rosterFile(stateDir, room), roster);
-}
-function shouldDebounceFile(file, minIntervalMs) {
-    try {
-        return Date.now() - fs.statSync(file).mtimeMs < minIntervalMs;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-function shouldDebounceSnapshot(file) {
-    return shouldDebounceFile(file, snapshotMinIntervalMs());
-}
-function comparableRosterMember(member) {
-    if (!member)
-        return "";
-    const { last_seen: _lastSeen, ...semantic } = member;
-    return JSON.stringify(semantic);
-}
-function shouldWriteRoomRosterMember(stateDir, room, before, after) {
-    if (!before)
-        return true;
-    if (comparableRosterMember(before) !== comparableRosterMember(after)) {
-        return true;
-    }
-    return !shouldDebounceFile(rosterFile(stateDir, room), rosterMinIntervalMs());
-}
-function updateRosterForMessage(stateDir, room, message, receivedAt) {
-    const roster = readRoomRoster(stateDir, room);
-    if (!message.from)
-        return roster;
-    const body = asRecord(message.body);
-    const current = roster[message.from];
-    const next = message.type === "actor.leave"
-        ? {
-            address: message.from,
-            joined_at: current?.joined_at ?? receivedAt,
-            last_seen: receivedAt,
-            ...(current?.caps !== undefined ? { caps: current.caps } : {}),
-            ...(current?.claim !== undefined ? { claim: current.claim } : {}),
-            ...(current?.display !== undefined
-                ? { display: current.display }
-                : {}),
-            ...(current?.parent !== undefined ? { parent: current.parent } : {}),
-            ...(current?.role !== undefined
-                ? { role: current.role }
-                : { role: "actor" }),
-            status: String(body.status ?? "left"),
-        }
-        : {
-            address: message.from,
-            joined_at: current?.joined_at ?? receivedAt,
-            last_seen: receivedAt,
-            ...(body.caps !== undefined
-                ? { caps: body.caps }
-                : current?.caps !== undefined
-                    ? { caps: current.caps }
-                    : {}),
-            ...(body.claim !== undefined
-                ? { claim: body.claim }
-                : current?.claim !== undefined
-                    ? { claim: current.claim }
-                    : {}),
-            ...(body.display !== undefined
-                ? { display: body.display }
-                : current?.display !== undefined
-                    ? { display: current.display }
-                    : {}),
-            ...(body.parent !== undefined
-                ? { parent: body.parent }
-                : current?.parent !== undefined
-                    ? { parent: current.parent }
-                    : {}),
-            ...(body.role !== undefined
-                ? { role: body.role }
-                : current?.role !== undefined
-                    ? { role: current.role }
-                    : { role: "actor" }),
-            status: String(body.status ?? current?.status ?? "present"),
-        };
-    roster[message.from] = next;
-    if (shouldWriteRoomRosterMember(stateDir, room, current, next)) {
-        writeRoomRoster(stateDir, room, roster);
-    }
-    return roster;
-}
-function readBranchInboxFile(stateDir, run, address, limit = 40) {
-    const branch = branchIdFromAddress(address, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
-    try {
-        const lines = readJsonlTailLines(branchInboxFile(stateDir, branch), limit);
-        const messages = [];
-        let corrupted = 0;
-        for (const line of lines) {
-            try {
-                messages.push(JSON.parse(line));
-            }
-            catch {
-                corrupted += 1;
-            }
-        }
-        return { corrupted, messages };
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { corrupted: 0, messages: [] };
-        throw error;
-    }
-}
-function readAllBranchInboxLines(stateDir, run, address) {
-    const branch = branchIdFromAddress(address, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
-    try {
-        const content = fs.readFileSync(branchInboxFile(stateDir, branch), "utf8");
-        return content
-            .split("\n")
-            .filter((line) => line.length > 0)
-            .map((line) => {
-            try {
-                return { message: JSON.parse(line) };
-            }
-            catch {
-                return { raw: line };
-            }
-        });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-export function readBranchInboxMessages(stateDir, run, address, limit = 40) {
-    return readBranchInboxFile(stateDir, run, address, limit).messages;
-}
-export function readBranchInboxDiagnostics(stateDir, run, address, limit = 40) {
-    return readBranchInboxFile(stateDir, run, address, limit);
-}
-export function getBranchInboxTerminalRetainLimit() {
-    const value = Number(process.env.PI_ACTORS_BRANCH_INBOX_TERMINAL_RETAINED ?? "");
-    return Number.isInteger(value) && value >= 0
-        ? value
-        : DEFAULT_BRANCH_INBOX_TERMINAL_RETAINED;
-}
-function compactBranchInboxMessages(messages) {
-    const retainTerminal = getBranchInboxTerminalRetainLimit();
-    const active = messages.filter((message) => message.status !== "handled" && message.status !== "failed");
-    const terminal = messages.filter((message) => message.status === "handled" || message.status === "failed");
-    return [...terminal.slice(-retainTerminal), ...active];
-}
-export function appendBranchInboxMessage(stateDir, run, address, message) {
-    const branch = branchIdFromAddress(address, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
-    const releaseLock = acquireBranchInboxLock(stateDir, branch);
-    try {
-        fs.writeFileSync(branchInboxFile(stateDir, branch), `${JSON.stringify({ ...message, id: randomUUID(), queued_at: new Date().toISOString(), status: "queued" })}\n`, { flag: "a" });
-        notifyActorWake(stateDir, address, "branch.message", {
-            ...(message.from ? { from: message.from } : {}),
-            type: message.type,
-        });
-    }
-    finally {
-        releaseLock();
-    }
-}
-export function claimBranchInboxMessage(stateDir, run, address, owner = "runtime", statuses = ["queued"]) {
-    const branch = branchIdFromAddress(address, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
-    const releaseLock = acquireBranchInboxLock(stateDir, branch);
-    try {
-        const file = branchInboxFile(stateDir, branch);
-        const records = readAllBranchInboxLines(stateDir, run, address);
-        let claimed;
-        const now = new Date().toISOString();
-        const updated = records.map((record) => {
-            if (claimed || !("message" in record))
-                return record;
-            const status = record.message.status ?? "queued";
-            if (!statuses.includes(status))
-                return record;
-            claimed = {
-                ...record.message,
-                claimed_at: now,
-                claimed_by: owner,
-                status: "claimed",
-            };
-            return { message: claimed };
-        });
-        if (!claimed)
-            return undefined;
-        fs.writeFileSync(file, `${updated.map((record) => ("raw" in record ? record.raw : JSON.stringify(record.message))).join("\n")}\n`);
-        notifyActorWake(stateDir, address, "branch.inbox.claim", {
-            id: claimed.id,
-            owner,
-        });
-        return claimed;
-    }
-    finally {
-        releaseLock();
-    }
-}
-export function updateBranchInboxMessageStatus(stateDir, run, address, id, status, metadata = {}) {
-    const branch = branchIdFromAddress(address, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
-    const releaseLock = acquireBranchInboxLock(stateDir, branch);
-    try {
-        const file = branchInboxFile(stateDir, branch);
-        const records = readAllBranchInboxLines(stateDir, run, address);
-        let changed = false;
-        const timestampKey = `${status}_at`;
-        const updated = records.map((record) => {
-            if (!("message" in record) || record.message.id !== id)
-                return record;
-            changed = true;
-            return {
-                message: {
-                    ...record.message,
-                    ...metadata,
-                    [timestampKey]: new Date().toISOString(),
-                    status,
-                },
-            };
-        });
-        if (!changed)
-            return false;
-        const validMessages = updated.flatMap((record) => "message" in record ? [record.message] : []);
-        const compactedIds = new Set(compactBranchInboxMessages(validMessages).map((message) => message.id));
-        const lines = updated.flatMap((record) => {
-            if ("raw" in record)
-                return [record.raw];
-            if (record.message.id && !compactedIds.has(record.message.id))
-                return [];
-            return [JSON.stringify(record.message)];
-        });
-        fs.writeFileSync(file, lines.length ? `${lines.join("\n")}\n` : "");
-        notifyActorWake(stateDir, address, "branch.inbox.status", { id, status });
-        return true;
-    }
-    finally {
-        releaseLock();
-    }
-}
-export function appendRoomMessage(stateDir, room, message) {
-    const releaseLock = acquireRoomLock(stateDir, room);
-    try {
-        const receivedAt = new Date().toISOString();
-        const entry = { ...message, received_at: receivedAt };
-        fs.appendFileSync(messagesFile(stateDir, room), `${JSON.stringify(entry)}\n`);
-        compactRoomMessages(stateDir, room);
-        const roster = updateRosterForMessage(stateDir, room, message, receivedAt);
-        const run = runFromRoomAddress(message.to);
-        if (run) {
-            writeCommunicationSnapshot(stateDir, run);
-            notifyActorWake(stateDir, message.to, "room.message", {
-                ...(message.from ? { from: message.from } : {}),
-                type: message.type,
-            });
-            if (message.from && branchIdFromAddress(message.from, run)) {
-                writeBranchCommunicationSnapshotDebounced(stateDir, run, message.from);
-            }
-        }
-        return {
-            message_count: readRoomMessageCount(stateDir, room),
-            room,
-            roster_count: Object.keys(roster).length,
-            sent: true,
-        };
-    }
-    finally {
-        releaseLock();
-    }
-}
-export function readRoomMessages(stateDir, room, limit = 40) {
-    try {
-        const lines = readJsonlTailLines(messagesFile(stateDir, room), limit);
-        return lines.flatMap((line) => {
-            try {
-                return [JSON.parse(line)];
-            }
-            catch {
-                return [];
-            }
-        });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-function previewValue(value, maxLength = Limits.ROOM_MESSAGE_PREVIEW_CHARS) {
-    if (value === undefined)
-        return undefined;
-    const text = typeof value === "string" ? value : JSON.stringify(value);
-    const compact = text.replaceAll(/\s+/g, " ").trim();
-    if (!compact)
-        return undefined;
-    return compact.length > maxLength
-        ? `${compact.slice(0, Math.max(0, maxLength - 1))}…`
-        : compact;
-}
-export function readRoomMessagePreviews(stateDir, room, limit = 40) {
-    return readRoomMessages(stateDir, room, limit).map((message) => ({
-        ...(previewValue(message.body)
-            ? { body_preview: previewValue(message.body) }
-            : {}),
-        ...(message.from ? { from: message.from } : {}),
-        ...(message.summary ? { summary: message.summary } : {}),
-        timestamp: message.received_at,
-        to: message.to,
-        type: message.type,
-    }));
-}
-export function getRoomStatus(stateDir, room) {
-    const messageCount = readRoomMessageCount(stateDir, room);
-    const [last] = readRoomMessages(stateDir, room, 1);
-    const compactionRead = readJsonFileResilient(path.join(roomDir(stateDir, room), "compaction.json"), undefined);
-    const rosterRead = readJsonFileResilient(rosterFile(stateDir, room), {});
-    const messageRead = readJsonlFileResilient(messagesFile(stateDir, room));
-    const diagnostics = [
-        ...messageRead.diagnostics,
-        ...rosterRead.diagnostics,
-        ...compactionRead.diagnostics,
-    ];
-    return {
-        ...(last
-            ? {
-                last_message_at: last.received_at,
-                ...(last.from ? { last_message_from: last.from } : {}),
-                ...(last.summary ? { last_message_summary: last.summary } : {}),
-                last_message_type: last.type,
-            }
-            : {}),
-        ...(compactionRead.value ? { compaction: compactionRead.value } : {}),
-        ...(diagnostics.length
-            ? {
-                diagnostics: formatStateReadDiagnostics(diagnostics),
-                diagnostics_count: diagnostics.length,
-            }
-            : {}),
-        message_count: messageCount,
-        room,
-        roster_count: Object.keys(rosterRead.value).length,
-    };
-}
-export function ensureRoomMember(stateDir, run, room, address, body, summary) {
-    const roster = readRoomRoster(stateDir, room);
-    if (roster[address]) {
-        return {
-            message_count: readRoomMessageCount(stateDir, room),
-            room,
-            roster_count: Object.keys(roster).length,
-            sent: true,
-        };
-    }
-    return appendRoomMessage(stateDir, room, {
-        body,
-        from: address,
-        summary,
-        to: `room:${run}`,
-        type: "actor.join",
-    });
-}
-export function ensureDefaultRoom(stateDir, run) {
-    return ensureRoomMember(stateDir, run, "main", `run:${run}`, { role: "run", status: "present" }, "Run joined default room");
-}
-export function readCommunicationSnapshot(stateDir) {
-    return readJsonFileResilient(snapshotFile(stateDir), undefined).value;
-}
-export function readRoomContacts(stateDir, room, self) {
-    return Object.values(readRoomRoster(stateDir, room))
-        .filter((member) => member.address !== self)
-        .map((member) => ({
-        address: member.address,
-        ...(member.caps !== undefined ? { caps: member.caps } : {}),
-        ...(member.claim !== undefined ? { claim: member.claim } : {}),
-        ...(member.parent !== undefined ? { parent: member.parent } : {}),
-        ...(member.role !== undefined ? { role: member.role } : {}),
-        ...(member.status !== undefined ? { status: member.status } : {}),
-    }));
-}
-function buildCommunicationSnapshot(stateDir, run, self) {
-    const mainRoster = Object.values(readRoomRoster(stateDir, "main"));
-    const contacts = readRoomContacts(stateDir, "main", self);
-    return {
-        ...(contacts.length > 0 ? { contacts } : {}),
-        ...(self !== `run:${run}` ? { parent: `run:${run}` } : {}),
-        root: `run:${run}`,
-        self,
-        rooms: [
-            {
-                address: `room:${run}`,
-                ...(mainRoster.length > 0 ? { members: mainRoster } : {}),
-                name: "main",
-            },
-        ],
-        updated_at: new Date().toISOString(),
-    };
-}
-export function writeCommunicationSnapshot(stateDir, run) {
-    const snapshot = buildCommunicationSnapshot(stateDir, run, `run:${run}`);
-    writeJsonFile(snapshotFile(stateDir), snapshot);
-    return snapshot;
-}
-export function writeBranchCommunicationSnapshot(stateDir, run, self) {
-    const branch = branchIdFromAddress(self, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${self}`);
-    const snapshot = buildCommunicationSnapshot(stateDir, run, self);
-    writeJsonFile(branchSnapshotFile(stateDir, branch), snapshot);
-    return snapshot;
-}
-function writeBranchCommunicationSnapshotDebounced(stateDir, run, self) {
-    const branch = branchIdFromAddress(self, run);
-    if (!branch)
-        throw new Error(`Expected branch:${run}/<branch>; got ${self}`);
-    if (shouldDebounceSnapshot(branchSnapshotFile(stateDir, branch)))
-        return undefined;
-    return writeBranchCommunicationSnapshot(stateDir, run, self);
-}

package/dist/lib/runs-mailbox.d.ts

@@ -1,25 +0,0 @@
-/**
- * Async run mailbox state.
- * Owns: durable run inbox records, claim locks, and handler status transitions.
- */
-export type RunInboxStatus = "queued" | "sent" | "claimed" | "handled" | "failed";
-export type RunInboxMessage = Record<string, unknown> & {
-    id?: string;
-    status?: RunInboxStatus | string;
-};
-export interface ProcessRunInboxResult {
-    claimed: number;
-    failed: number;
-    handled: number;
-}
-export declare function runInboxFile(stateDir: string): string;
-export declare function parseRunInboxLine(line: string): RunInboxMessage | undefined;
-export declare function readRunInboxMessagesFromStateDir(stateDir: string): RunInboxMessage[];
-export declare function updateRunInboxMessageStatusInStateDir(stateDir: string, id: string, nextStatus: RunInboxStatus, metadata?: Record<string, unknown>): boolean;
-export declare function claimRunInboxMessageInStateDir(stateDir: string, owner?: string, statuses?: string[]): RunInboxMessage | undefined;
-export declare function appendRunInboxMessageInStateDir(stateDir: string, record: Record<string, unknown>): string;
-export declare function processRunInboxMessagesInStateDir(stateDir: string, handler: (message: RunInboxMessage) => Promise<void> | void, options?: {
-    limit?: number;
-    owner?: string;
-    statuses?: string[];
-}): Promise<ProcessRunInboxResult>;