@stage-labs/metro 0.1.0-beta.306 → 0.1.0-beta.308

package/dist/claude.js

@@ -1,204 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { markOnboardingDone, seedChannels } from './onboarding.js';
-import { writeMcpConfig } from './mcp-config.js';
-import { currentRoute, harnessRunner, permissionMode, routeModelEnv, systemPrompt } from './route.js';
-import { settingsConflicts, settingsFiles } from './claude-settings.js';
-import { localAgent } from './local.js';
-import { PROVIDER_FLAGS } from './provider-flags.js';
-import { localPort, localUrl } from './runtime.js';
-import { keepInSession, resumeSessionId, takeBackConversation } from './background.js';
-import { nativeRecoveryArgs } from './native-recovery.js';
-const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
-const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
-export const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
-const KEY_HEADER = 'x-metro-key';
-const PROBE_MS = 3_000;
-const AUTH_STATUS_MS = 20_000;
-const KILL_GRACE_MS = 30_000;
-export const claudeArgs = (extra, mcpConfig, mode = 'auto', prompt = null) => [
-    ...CHANNEL_FLAGS,
-    '--permission-mode',
-    PERMISSION_MODE_FLAG[mode],
-    ...FRESH_PROMPT_FLAGS,
-    ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
-    ...(prompt === null ? [] : ['--append-system-prompt', prompt]),
-    ...extra,
-];
-const set = (env, name) => (env[name] ?? '').trim() !== '';
-export function pinnedBy(env) {
-    if (set(env, 'ANTHROPIC_BASE_URL'))
-        return 'ANTHROPIC_BASE_URL';
-    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
-}
-export function gatewayEnv(base, agentKey, port) {
-    if (agentKey === null || pinnedBy(base) !== null)
-        return base;
-    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
-    const mine = `${KEY_HEADER}: ${agentKey}`;
-    return {
-        ...base,
-        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
-        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
-        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
-    };
-}
-export const channelEnv = (env) => set(env, 'MCP_PROTOCOL_NEGOTIATION') ? env : { ...env, MCP_PROTOCOL_NEGOTIATION: 'legacy' };
-export const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };
-const RM_PROMPT_OFF = 'CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT';
-export const rmPromptEnv = (env) => set(env, RM_PROMPT_OFF) ? env : { ...env, [RM_PROMPT_OFF]: '1' };
-const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
-export function credentialEnv(env, agentKey, signedIn) {
-    if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
-        return env;
-    return { ...env, ANTHROPIC_AUTH_TOKEN: agentKey };
-}
-function claudeSignedIn() {
-    const run = spawnSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: AUTH_STATUS_MS });
-    if (run.error !== undefined || typeof run.stdout !== 'string')
-        return false;
-    try {
-        const parsed = JSON.parse(run.stdout);
-        return parsed.authenticated === true || parsed.loggedIn === true || typeof parsed.email === 'string' || typeof parsed.organization === 'string';
-    }
-    catch {
-        return false;
-    }
-}
-export function servingDaemon(body) {
-    if (typeof body !== 'object' || body === null)
-        return false;
-    const mode = body;
-    return mode.mode === 'local' && mode.stopped !== true;
-}
-async function daemonServing(base = localUrl()) {
-    try {
-        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
-        return res.ok && servingDaemon(await res.json());
-    }
-    catch {
-        return false;
-    }
-}
-export function agentKey(agent) {
-    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
-}
-async function verdict() {
-    const pinned = pinnedBy(process.env);
-    if (pinned !== null)
-        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
-    const conflicts = settingsConflicts(settingsFiles());
-    if (conflicts.length > 0)
-        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
-    const picked = agentKey(localAgent());
-    if ('skip' in picked)
-        return picked;
-    if (await daemonServing())
-        return picked;
-    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
-}
-function deadline(child, timeoutMs) {
-    if (timeoutMs === undefined)
-        return () => undefined;
-    let kill;
-    const term = setTimeout(() => {
-        child.kill('SIGTERM');
-        kill = setTimeout(() => {
-            child.kill('SIGKILL');
-        }, KILL_GRACE_MS);
-    }, timeoutMs);
-    return () => {
-        clearTimeout(term);
-        clearTimeout(kill);
-    };
-}
-export function runClaude(args, env, headless, command = 'claude') {
-    return new Promise((resolve, reject) => {
-        const leaveToChild = () => undefined;
-        process.on('SIGINT', leaveToChild);
-        process.on('SIGTERM', leaveToChild);
-        const child = spawn(command, args, { stdio: [headless === undefined ? 'inherit' : 'ignore', 'inherit', 'inherit'], env });
-        const stop = deadline(child, headless?.timeoutMs);
-        child.on('error', (err) => {
-            reject(new Error(err.code === 'ENOENT'
-                ? `the \`${command}\` command is not on PATH${command === 'claude' ? ' — install Claude Code first' : ''}`
-                : err.message));
-        });
-        child.on('exit', (code) => {
-            stop();
-            resolve(code ?? 1);
-        });
-    });
-}
-async function servedKey(decision) {
-    if ('key' in decision)
-        return decision.key;
-    const picked = agentKey(localAgent());
-    if ('skip' in picked)
-        return null;
-    return (await daemonServing()) ? picked.key : null;
-}
-function mcpConfigFor(key, port) {
-    if (key === null)
-        return null;
-    const file = writeMcpConfig(key, port);
-    process.stderr.write(`metro claude: the metro MCP server is loaded for this session from the daemon at http://127.0.0.1:${String(port)}/mcp, nothing to add by hand\n`);
-    return file;
-}
-function gatewayLaunchEnv(key, port) {
-    process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
-    const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
-    const routed = toolSearchEnv(pointed);
-    if (routed !== pointed)
-        process.stderr.write('metro claude: MCP tool search is on, so connector tools load when Claude needs them instead of all at start\n');
-    const env = credentialEnv(routed, key, claudeSignedIn());
-    if (env !== routed)
-        process.stderr.write("metro claude: Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex\n");
-    if (seedChannels() === 'marked')
-        process.stderr.write('metro claude: marked Channels as available in Claude Code cached flags, since a box that sends no telemetry never fetches them\n');
-    if (markOnboardingDone() === 'marked')
-        process.stderr.write("metro claude: skipped Claude Code's first-run setup, since it already has a credential here\n");
-    return env;
-}
-function inferenceEnv(decision, port) {
-    if ('key' in decision)
-        return gatewayLaunchEnv(decision.key, port);
-    process.stderr.write(`metro claude: ${decision.skip}\n`);
-    return process.env;
-}
-export async function headlessEnv() {
-    return keepInSession(rmPromptEnv(inferenceEnv(await verdict(), localPort())));
-}
-const continues = (args) => args.includes('-c') || args.includes('--continue');
-async function reclaimConversation(extra) {
-    const sessionId = resumeSessionId(extra);
-    if (sessionId === undefined && !continues(extra))
-        return;
-    try {
-        const note = await takeBackConversation({ sessionId });
-        if (note !== null)
-            process.stderr.write(`metro claude: ${note}\n`);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`metro claude: could not check for a Claude Code background session holding the conversation (${message})\n`);
-    }
-}
-const SDK_HOLDS_CHAT = 'the Harness runs this agent as an Agent SDK session (metro agent), which holds the metro chat; a metro claude session would take it away. Switch the Harness runner back to the Claude Code session first, or open the conversation with plain claude --resume <session id>';
-export async function launchClaude(extra) {
-    if (harnessRunner() === 'sdk')
-        throw new Error(SDK_HOLDS_CHAT);
-    await reclaimConversation(extra);
-    const decision = await verdict();
-    const port = localPort();
-    const mcp = mcpConfigFor(await servedKey(decision), port);
-    const mode = permissionMode();
-    const prompt = systemPrompt();
-    if (prompt !== null)
-        process.stderr.write('metro claude: the system prompt from the Harness page is appended to this session\n');
-    try {
-        return await runClaude(claudeArgs(nativeRecoveryArgs(extra), mcp?.path, mode, prompt), keepInSession(rmPromptEnv(channelEnv(inferenceEnv(decision, port)))));
-    }
-    finally {
-        mcp?.cleanup();
-    }
-}

package/dist/mcp-config.js

@@ -1,27 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-const METRO_SERVER = 'metro';
-const CHAT_PATH = '/mcp';
-export const VOICE_MCP_PATH = '/mcp/voice';
-export function metroMcpConfig(agentKey, port, path = CHAT_PATH) {
-    const servers = {
-        [METRO_SERVER]: {
-            type: 'http',
-            url: `http://127.0.0.1:${String(port)}${path}`,
-            headers: { Authorization: `Bearer ${agentKey}` },
-        },
-    };
-    return `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`;
-}
-export function writeMcpConfig(agentKey, port, base = tmpdir(), mcpPath = CHAT_PATH) {
-    const dir = mkdtempSync(join(base, 'metro-claude-'));
-    const path = join(dir, 'mcp.json');
-    writeFileSync(path, metroMcpConfig(agentKey, port, mcpPath), { mode: 0o600 });
-    return {
-        path,
-        cleanup: () => {
-            rmSync(dir, { recursive: true, force: true });
-        },
-    };
-}

package/dist/native-recovery-scan.js

@@ -1,246 +0,0 @@
-import { closeSync, constants, fstatSync, openSync, readSync } from 'node:fs';
-import { join } from 'node:path';
-import { isRecord } from './background.js';
-import { nativeId, nativeToken, NATIVE_CURSOR_MAX, NATIVE_FILE_MAX } from './native-recovery-state.js';
-export const NATIVE_SCAN_BYTES = 256 * 1024;
-export const NATIVE_LINE_BYTES = 64 * 1024;
-const RECORD_MAX = 2048;
-function decodeRows(buffer, start, end, read) {
-    const lines = buffer.subarray(start, end).toString('utf8').split('\n');
-    for (const line of lines.slice(0, RECORD_MAX)) {
-        if (line === '')
-            continue;
-        if (Buffer.byteLength(line) > NATIVE_LINE_BYTES) {
-            read.incomplete = true;
-            continue;
-        }
-        try {
-            read.rows.push(JSON.parse(line));
-        }
-        catch {
-            read.incomplete = true;
-        }
-    }
-    read.incomplete ||= lines.length > RECORD_MAX;
-    return read;
-}
-function readRows(path, offset) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    try {
-        const stat = fstatSync(fd);
-        if (!stat.isFile())
-            throw new Error('Native transcript is not a regular file');
-        if (offset > stat.size)
-            return { rows: [], offset, incomplete: true };
-        const from = Math.max(offset, stat.size - NATIVE_SCAN_BYTES);
-        const buffer = Buffer.alloc(Math.min(stat.size - from, NATIVE_SCAN_BYTES));
-        const count = readSync(fd, buffer, 0, buffer.length, from);
-        const end = buffer.lastIndexOf(10, count - 1);
-        const incomplete = from > offset || count < buffer.length || end !== count - 1;
-        if (count === 0)
-            return { rows: [], offset: from, incomplete };
-        if (end < 0)
-            return { rows: [], offset: from, incomplete: true };
-        const start = from > offset ? buffer.indexOf(10) + 1 : 0;
-        return decodeRows(buffer, start, end, { rows: [], offset: from + end + 1, incomplete });
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function contentOf(row) {
-    return isRecord(row.message) ? row.message.content : undefined;
-}
-function textOf(content) {
-    if (typeof content === 'string')
-        return content;
-    if (!Array.isArray(content) || content.length !== 1)
-        return null;
-    const block = content[0];
-    return isRecord(block) && block.type === 'text' && typeof block.text === 'string' ? block.text : null;
-}
-function resultOf(value) {
-    if (isRecord(value))
-        return value;
-    if (typeof value !== 'string' || value.length > NATIVE_LINE_BYTES)
-        return null;
-    try {
-        const raw = JSON.parse(value);
-        return isRecord(raw) ? raw : null;
-    }
-    catch {
-        return null;
-    }
-}
-function tag(text, name) {
-    const matches = [...text.matchAll(new RegExp(`<${name}>([^<]*)</${name}>`, 'g'))];
-    return matches.length > 1 ? undefined : matches[0]?.[1] ?? null;
-}
-function terminal(value, reason) {
-    if (value === 'stopped' && reason === 'worker_restart')
-        return 'restarted';
-    return value === 'completed' || value === 'failed' || value === 'stopped' ? value : null;
-}
-const queued = (row) => isRecord(row.attachment) && row.attachment.type === 'queued_command' ? row.attachment : null;
-function textNotification(row) {
-    const attachment = queued(row);
-    const origin = attachment?.origin ?? row.origin;
-    if (!isRecord(origin) || origin.kind !== 'task-notification')
-        return null;
-    if (row.type !== 'user' && row.type !== 'attachment')
-        return null;
-    const text = textOf(attachment?.value ?? contentOf(row));
-    return text === null ? null : notificationTags(text.trim());
-}
-function notificationOf(agent, tool, status, reason) {
-    const state = terminal(status, reason);
-    if (!nativeToken(agent) || state === null)
-        return null;
-    if (tool != null && !nativeToken(tool))
-        return null;
-    return { agent, state, tool: nativeToken(tool) ? tool : null };
-}
-function notificationTags(text) {
-    const open = '<task-notification>';
-    const close = '</task-notification>';
-    if (!text.startsWith(open) || !text.endsWith(close))
-        return null;
-    if (text.includes(open, 1) || text.indexOf(close) !== text.length - close.length)
-        return null;
-    const fields = ['task-id', 'tool-use-id', 'status', 'reason'].map((name) => tag(text, name));
-    if (fields.some((field) => field === undefined))
-        return null;
-    return notificationOf(fields[0], fields[1], fields[2], fields[3]);
-}
-function notification(row) {
-    if (row.type !== 'system' || row.subtype !== 'task_notification')
-        return textNotification(row);
-    return notificationOf(row.task_id, row.tool_use_id, row.status, row.reason);
-}
-function ackOf(block, base) {
-    if (block.type !== 'text' || typeof block.text !== 'string')
-        return null;
-    const match = /^METRO_RECOVERY_ACK ([a-f0-9]{64})$/.exec(block.text.trim());
-    return nativeId(match?.[1]) ? { ...base, type: 'ack', id: match[1] } : null;
-}
-function callOf(block, base) {
-    if (block.type !== 'tool_use' || !nativeToken(block.id))
-        return null;
-    return block.name === 'Agent' || block.name === 'SendMessage' ? { ...base, type: 'call', tool: block.id, kind: block.name } : null;
-}
-const rootAssistant = (row, base) => base.source === null && row.aborted !== true && row.parent_tool_use_id == null && row.parent_agent_id == null;
-function blockEvent(block, row, base, single) {
-    if (!isRecord(block))
-        return null;
-    if (row.type === 'assistant') {
-        const ack = rootAssistant(row, base) ? ackOf(block, base) : null;
-        return ack ?? callOf(block, base);
-    }
-    if (row.type !== 'user' || block.type !== 'tool_result' || !nativeToken(block.tool_use_id))
-        return null;
-    return { ...base, type: 'result', tool: block.tool_use_id, failed: block.is_error === true, outcome: resultOf(single ? row.toolUseResult : null) ?? resultOf(block.content) };
-}
-const sidechain = (row, source) => source === null && (row.isSidechain === true || typeof row.agentId === 'string');
-function eventsOf(row, source) {
-    if (sidechain(row, source))
-        return [];
-    const at = typeof row.timestamp === 'string' ? Date.parse(row.timestamp) : NaN;
-    if (!Number.isSafeInteger(at) || at < 0 || !nativeToken(row.uuid))
-        return [];
-    const base = { source, at, receipt: row.uuid };
-    const end = notification(row);
-    if (end !== null)
-        return [{ ...base, type: 'notification', ...end }];
-    const content = contentOf(row);
-    const blocks = typeof content === 'string' ? [{ type: 'text', text: content }] : Array.isArray(content) ? content : [];
-    return blocks.flatMap((block) => { const event = blockEvent(block, row, base, blocks.length === 1); return event === null ? [] : [event]; });
-}
-function resultChild(kind, outcome) {
-    if (kind === 'Agent' && (outcome.status === 'async_launched' || outcome.status === 'completed'))
-        return nativeToken(outcome.agentId) ? outcome.agentId : null;
-    return kind === 'SendMessage' && outcome.success === true && nativeToken(outcome.resumedAgentId) ? outcome.resumedAgentId : null;
-}
-function childOf(event, calls) {
-    if (event.type === 'ack')
-        return null;
-    const key = `${event.source ?? ''}/${event.tool ?? ''}`;
-    if (event.type === 'call')
-        calls.set(key, event.kind);
-    if (event.type === 'notification')
-        return calls.has(key) ? event.agent : null;
-    if (event.type !== 'result' || event.failed || event.outcome === null)
-        return null;
-    return resultChild(calls.get(key), event.outcome);
-}
-function missingEnvelope(row) {
-    const message = row.type === 'assistant' || row.type === 'user' || row.type === 'attachment' || row.subtype === 'task_notification';
-    if (!message)
-        return false;
-    return !nativeToken(row.uuid) || typeof row.timestamp !== 'string' || !Number.isSafeInteger(Date.parse(row.timestamp));
-}
-function rowsOf(read, agent, owner) {
-    const events = [];
-    for (const row of read.rows) {
-        if (!isRecord(row)) {
-            read.incomplete = true;
-            continue;
-        }
-        if (agent === null && typeof row.sessionId === 'string' && row.sessionId !== owner) {
-            read.incomplete = true;
-            continue;
-        }
-        read.incomplete ||= missingEnvelope(row);
-        events.push(...eventsOf(row, agent));
-    }
-    return events;
-}
-function discover(context, event, index) {
-    const child = childOf(event, context.calls);
-    if (child === null || context.pending.includes(child))
-        return;
-    if (context.files.size >= NATIVE_CURSOR_MAX) {
-        context.scan.gaps.push('file-capacity');
-        return;
-    }
-    context.files.set(child, { agent: child, offset: 0 });
-    context.pending.splice(index + 1, 0, child);
-}
-function scanFile(context, agent, index) {
-    const { root, owner, files, scan } = context;
-    const before = files.get(agent)?.offset ?? 0;
-    const path = agent === null ? join(root, `${owner}.jsonl`) : join(root, owner, 'subagents', `agent-${agent}.jsonl`);
-    files.delete(agent);
-    try {
-        const read = readRows(path, before);
-        const events = rowsOf(read, agent, owner);
-        files.set(agent, { agent, offset: read.offset });
-        if (read.incomplete)
-            scan.gaps.push(`${agent ?? 'root'}:${String(before)}`);
-        for (const event of events) {
-            discover(context, event, index);
-            if (scan.events.length < RECORD_MAX)
-                scan.events.push(event);
-            else
-                scan.gaps.push('event-capacity');
-        }
-    }
-    catch {
-        scan.gaps.push(`${agent ?? 'root'}:${String(before)}`);
-        files.set(agent, { agent, offset: before });
-    }
-}
-export function scanNative(root, owner, previous, knownCalls) {
-    const pending = [null, ...previous.flatMap((file) => file.agent === null ? [] : [file.agent])];
-    const files = new Map(previous.map((file) => [file.agent, file]));
-    const calls = new Map(knownCalls.map((call) => [`${call.source ?? ''}/${call.tool}`, call.kind]));
-    const scan = { events: [], files: [], gaps: [] };
-    const context = { root, owner, calls, pending, files, scan };
-    for (let i = 0; i < pending.length && i < NATIVE_FILE_MAX; i += 1)
-        scanFile(context, pending[i] ?? null, i);
-    if (pending.length > NATIVE_FILE_MAX)
-        scan.gaps.push('file-budget');
-    scan.files = [...files.values()];
-    scan.gaps = [...new Set(scan.gaps)];
-    scan.events.sort((a, b) => a.at - b.at);
-    return scan;
-}

package/dist/native-recovery-state.js

@@ -1,154 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, opendirSync, openSync, readSync, renameSync, rmdirSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { isRecord, processAlive } from './background.js';
-export const NATIVE_TASK_MAX = 256;
-export const NATIVE_FILE_MAX = 16;
-export const NATIVE_CURSOR_MAX = 256;
-export const NATIVE_NOTICE_MAX = 512;
-export const NATIVE_STATE_BYTES = 512 * 1024;
-export const nativeToken = (value) => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value);
-export const nativeId = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
-const integer = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
-const nullable = (value, valid) => value === null || valid(value);
-const keys = (value, fields) => Object.keys(value).length === fields.length && fields.every((key) => Object.hasOwn(value, key));
-const statuses = new Set(['started', 'completed', 'failed', 'stopped', 'restarted']);
-const reasons = new Set(['interrupted', 'failed', 'restarted', 'incomplete']);
-function taskFields(value) {
-    return nullable(value.source, nativeToken) && nativeToken(value.tool) && (value.kind === 'Agent' || value.kind === 'SendMessage')
-        && nullable(value.agent, nativeToken) && statuses.has(value.state) && nativeToken(value.receipt);
-}
-function task(value) {
-    return isRecord(value) && keys(value, ['id', 'source', 'tool', 'kind', 'agent', 'at', 'updatedAt', 'state', 'receipt']) && nativeId(value.id)
-        && integer(value.at) && integer(value.updatedAt) && value.updatedAt >= value.at && taskFields(value);
-}
-function noticeTimes(value) {
-    if (!nullable(value.deliveredAt, integer) || !nullable(value.acknowledgedAt, integer))
-        return false;
-    if (value.attempts === 0)
-        return value.deliveredAt === null && value.acknowledgedAt === null;
-    if (typeof value.deliveredAt !== 'number')
-        return false;
-    return value.acknowledgedAt === null || (typeof value.acknowledgedAt === 'number' && value.acknowledgedAt >= value.deliveredAt);
-}
-function notice(value) {
-    return isRecord(value) && keys(value, ['id', 'task', 'reason', 'attempts', 'deliveredAt', 'acknowledgedAt']) && nativeId(value.id)
-        && nullable(value.task, nativeId) && reasons.has(value.reason) && integer(value.attempts) && value.attempts <= 3 && noticeTimes(value);
-}
-function cursor(value) {
-    return isRecord(value) && keys(value, ['agent', 'offset']) && nullable(value.agent, nativeToken) && integer(value.offset);
-}
-function rows(value, max, valid, key) {
-    return Array.isArray(value) && value.length <= max && value.every(valid) && new Set(value.map(key)).size === value.length;
-}
-function validState(value, owner) {
-    if (!isRecord(value) || !keys(value, ['version', 'owner', 'tasks', 'notices', 'files']) || value.version !== 1 || value.owner !== owner)
-        return false;
-    const { tasks, notices, files } = value;
-    return rows(tasks, NATIVE_TASK_MAX, task, (v) => v.id) && rows(notices, NATIVE_NOTICE_MAX, notice, (v) => v.id)
-        && rows(files, NATIVE_CURSOR_MAX, cursor, (v) => v.agent)
-        && notices.every((row) => row.task === null || tasks.some((entry) => entry.id === row.task));
-}
-function readStateBytes(path) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    try {
-        const stat = fstatSync(fd);
-        if (!stat.isFile() || stat.size > NATIVE_STATE_BYTES)
-            throw new Error('state exceeds its size bound');
-        const buffer = Buffer.alloc(NATIVE_STATE_BYTES + 1);
-        const count = readSync(fd, buffer, 0, buffer.length, 0);
-        if (count !== stat.size || fstatSync(fd).size !== stat.size)
-            throw new Error('state changed while reading');
-        return buffer.subarray(0, count).toString('utf8');
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function readNativeState(path, owner) {
-    try {
-        const raw = JSON.parse(readStateBytes(path));
-        if (!validState(raw, owner))
-            throw new Error('state does not match its schema');
-        return raw;
-    }
-    catch (err) {
-        if (isRecord(err) && err.code === 'ENOENT')
-            return { version: 1, owner, tasks: [], notices: [], files: [] };
-        throw new Error('Native recovery state cannot be read safely. Restore it before resuming; it has not been overwritten.', { cause: err });
-    }
-}
-function retireLock(path) {
-    if (!lstatSync(path).isDirectory())
-        throw new Error('Native recovery lock is not a directory');
-    const dir = opendirSync(path);
-    let name;
-    try {
-        name = dir.readSync()?.name;
-        if (dir.readSync() !== null)
-            throw new Error('Native recovery lock has unexpected entries');
-    }
-    finally {
-        dir.closeSync();
-    }
-    const pid = /^(\d{1,10})-[a-f0-9-]{36}$/.exec(name ?? '')?.[1];
-    if (pid === undefined || Number(pid) < 1 || processAlive(Number(pid)))
-        throw new Error('Native recovery preparation is locked. Restore an unreadable lock before resuming.');
-    unlinkSync(join(path, name ?? ''));
-    rmdirSync(path);
-}
-export function withNativeStateLock(path, work) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const lock = `${path}.lock`;
-    try {
-        mkdirSync(lock, { mode: 0o700 });
-    }
-    catch (err) {
-        if (!isRecord(err) || err.code !== 'EEXIST')
-            throw err;
-        retireLock(lock);
-        mkdirSync(lock, { mode: 0o700 });
-    }
-    const owner = join(lock, `${String(process.pid)}-${randomUUID()}`);
-    writeFileSync(owner, '', { flag: 'wx', mode: 0o600 });
-    try {
-        return work();
-    }
-    finally {
-        unlinkSync(owner);
-        rmdirSync(lock);
-    }
-}
-function syncDirectory(path) {
-    if (process.platform === 'win32')
-        return;
-    const fd = openSync(path, 'r');
-    try {
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function saveNativeState(path, state) {
-    const text = JSON.stringify(state);
-    if (!validState(state, state.owner) || Buffer.byteLength(text) > NATIVE_STATE_BYTES)
-        throw new Error('Native recovery state exceeds its bounds; it has not been overwritten.');
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const tmp = `${path}.${randomUUID()}.tmp`;
-    try {
-        const fd = openSync(tmp, 'wx', 0o600);
-        try {
-            writeFileSync(fd, text);
-            fsyncSync(fd);
-        }
-        finally {
-            closeSync(fd);
-        }
-        renameSync(tmp, path);
-        syncDirectory(dirname(path));
-    }
-    finally {
-        rmSync(tmp, { force: true });
-    }
-}