larkin 0.2.70

package/dist/platform/process-inspect.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+function validPid(pid) {
+    const value = Number(pid);
+    return Number.isInteger(value) && value > 0 ? value : null;
+}
+function pidAlive(pid, kill = process.kill) {
+    const value = validPid(pid);
+    if (!value)
+        return false;
+    try {
+        kill(value, 0);
+        return true;
+    }
+    catch (error) {
+        // POSIX reserves ESRCH for a missing process. EPERM means the process may
+        // be alive but is not inspectable by this user and therefore must fail closed.
+        return error.code !== "ESRCH";
+    }
+}
+function inspectUnix(pid) {
+    const env = { ...process.env, LC_ALL: "C", LANG: "C" };
+    const state = (0, node_child_process_1.spawnSync)("ps", ["-ww", "-p", String(pid), "-o", "stat="], { encoding: "utf8", env });
+    const started = (0, node_child_process_1.spawnSync)("ps", ["-ww", "-p", String(pid), "-o", "lstart="], { encoding: "utf8", env });
+    const command = (0, node_child_process_1.spawnSync)("ps", ["-ww", "-p", String(pid), "-o", "command="], { encoding: "utf8", env });
+    if (state.status === 0 && /^Z/.test(String(state.stdout || "").trim()))
+        return { ok: false, dead: true, reason: "process exited" };
+    // The process can disappear between the initial kill(0) probe and ps. Re-checking here
+    // distinguishes a normal exit race from an inspection failure that must remain fail-closed.
+    if ((state.status !== 0 || started.status !== 0 || command.status !== 0) && !pidAlive(pid)) {
+        return { ok: false, dead: true, reason: "process exited" };
+    }
+    if (started.status !== 0 || command.status !== 0)
+        return { ok: false, reason: "ps failed" };
+    const startedText = String(started.stdout || "").trim();
+    const commandText = String(command.stdout || "").trim();
+    if (!startedText || !commandText)
+        return { ok: false, reason: "ps metadata incomplete" };
+    // `ps lstart` omits a timezone. Parsing it into an ISO timestamp makes the
+    // same process look different when two Bun processes have different TZ
+    // state (notably a Bun test parent and a normal Bun child). The value is an
+    // opaque identity token, so preserve the stable kernel-provided text.
+    return { ok: true, command: commandText, startToken: startedText };
+}
+function inspectWindows(pid) {
+    const script = `$p=Get-CimInstance Win32_Process -Filter \"ProcessId=${pid}\"; if($null -eq $p){exit 3}; [pscustomobject]@{CommandLine=$p.CommandLine;CreationDate=$p.CreationDate.ToUniversalTime().ToString('o')} | ConvertTo-Json -Compress`;
+    const result = (0, node_child_process_1.spawnSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { encoding: "utf8" });
+    if (result.status !== 0)
+        return { ok: false, reason: "CIM failed" };
+    try {
+        const parsed = JSON.parse(String(result.stdout || ""));
+        if (!parsed.CommandLine || !parsed.CreationDate)
+            return { ok: false, reason: "CIM metadata incomplete" };
+        return { ok: true, command: parsed.CommandLine, startToken: new Date(parsed.CreationDate).toISOString() };
+    }
+    catch {
+        return { ok: false, reason: "CIM output invalid" };
+    }
+}
+function inspectProcess(pid) {
+    const value = validPid(pid);
+    if (!value)
+        return { ok: false, reason: "invalid pid" };
+    if (!pidAlive(value))
+        return { ok: false, dead: true, reason: "process not alive" };
+    return process.platform === "win32" ? inspectWindows(value) : inspectUnix(value);
+}
+function currentProcessMetadata(commandToken) {
+    const inspected = inspectProcess(process.pid);
+    if (!inspected.ok || !inspected.command || !inspected.startToken) {
+        throw new Error(`无法读取当前进程身份：${inspected.reason || "metadata incomplete"}`);
+    }
+    let effectiveToken = commandToken;
+    if (!inspected.command.includes(commandToken)) {
+        const bunToken = node_path_1.default.basename(process.execPath);
+        if (process.env.LARKIN_BUN_TEST_RUNNER === "1" && inspected.command.includes(bunToken))
+            effectiveToken = bunToken;
+        else if (process.env.LARKIN_BUN_TEST_RUNNER === "1" && /(^|[\s/])bun(?:\s|$)/.test(inspected.command))
+            effectiveToken = "bun";
+        else
+            throw new Error(`当前进程命令不含身份标记 ${commandToken}`);
+    }
+    return { pid: process.pid, processStartToken: inspected.startToken, commandToken: effectiveToken };
+}
+module.exports = { validPid, pidAlive, inspectProcess, currentProcessMetadata };

package/dist/platform/process-state.cjs

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentProcessMetadata = exports.inspectProcess = exports.pidAlive = void 0;
+exports.readJson = readJson;
+exports.readOwnedProcessRecord = readOwnedProcessRecord;
+exports.readProcessState = readProcessState;
+exports.daemonHasAgent = daemonHasAgent;
+exports.assertProcessCanStart = assertProcessCanStart;
+exports.terminateOwnedProcess = terminateOwnedProcess;
+exports.waitForProcessExit = waitForProcessExit;
+exports.acquireProcessLock = acquireProcessLock;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const process_inspect_cjs_1 = __importDefault(require("./process-inspect.cjs"));
+const processInspect = process_inspect_cjs_1.default;
+exports.pidAlive = processInspect.pidAlive;
+exports.inspectProcess = processInspect.inspectProcess;
+exports.currentProcessMetadata = processInspect.currentProcessMetadata;
+function readJson(file, fallback = null) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+function readOwnedProcessRecord(file, defaultCommandToken, { inspect = exports.inspectProcess } = {}) {
+    const record = readJson(file, null);
+    if (!record)
+        return { file, state: "dead", alive: false, running: false, reason: "status missing" };
+    const alive = (0, exports.pidAlive)(record.pid);
+    if (!alive)
+        return { ...record, file, state: "dead", alive: false, running: false, reason: "pid not alive" };
+    const inspected = inspect(Number(record.pid));
+    if (!inspected?.ok && inspected?.dead) {
+        return { ...record, file, state: "dead", alive: false, running: false, reason: inspected.reason || "process exited", inspected };
+    }
+    if (!inspected?.ok) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: inspected?.reason || "process inspection failed",
+        };
+    }
+    if (typeof inspected.command !== "string" || !inspected.command ||
+        typeof inspected.startToken !== "string" || !inspected.startToken) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: "process inspection metadata incomplete",
+            inspected,
+        };
+    }
+    const commandToken = record.commandToken || defaultCommandToken;
+    if (!commandToken || !inspected.command.includes(commandToken)) {
+        return { ...record, file, state: "mismatch", alive: true, running: false, reason: "command mismatch", inspected };
+    }
+    if (!record.processStartToken) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: "status lacks processStartToken",
+            inspected,
+        };
+    }
+    if (record.processStartToken !== inspected.startToken) {
+        return { ...record, file, state: "mismatch", alive: true, running: false, reason: "process start mismatch", inspected };
+    }
+    return { ...record, file, state: "owned", alive: true, running: true, reason: null, inspected };
+}
+function readProcessState(larkinHome) {
+    return {
+        supervisor: readOwnedProcessRecord(node_path_1.default.join(larkinHome, "supervisor-status.json"), "app/run.mjs"),
+        daemon: readOwnedProcessRecord(node_path_1.default.join(larkinHome, "daemon-status.json"), "app/runtime-process.mjs"),
+        dashboard: readOwnedProcessRecord(node_path_1.default.join(larkinHome, "dashboard-status.json"), "app/dashboard.mjs"),
+    };
+}
+function daemonHasAgent(daemon, agentId) {
+    return !!(daemon?.state === "owned" && Array.isArray(daemon.agents) && daemon.agents.includes(agentId));
+}
+function assertProcessCanStart(record, label) {
+    if (record?.state === "unknown") {
+        throw new Error(`${label} PID ${record.pid} 存活但身份无法确认（${record.reason}）；为避免重复进程或误杀，已停止`);
+    }
+}
+function terminateOwnedProcess(record, signal = "SIGTERM", { inspect = exports.inspectProcess } = {}) {
+    const current = readOwnedProcessRecord(record.file, record.commandToken, { inspect });
+    if (current.state !== "owned") {
+        throw new Error(`拒绝向 PID ${record.pid} 发送 ${signal}：进程所有权=${current.state}（${current.reason}）`);
+    }
+    process.kill(Number(current.pid), signal);
+    return current;
+}
+async function waitForProcessExit(record, timeoutMs = 10_000, { inspect = exports.inspectProcess } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const current = readOwnedProcessRecord(record.file, record.commandToken, { inspect });
+        if (current.state === "dead" || current.state === "mismatch")
+            return true;
+        if (current.state === "unknown")
+            throw new Error(`等待 PID ${record.pid} 退出时无法确认所有权：${current.reason}`);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+}
+function atomicCreateJson(file, value) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true, mode: 0o700 });
+    const fd = node_fs_1.default.openSync(file, "wx", 0o600);
+    try {
+        node_fs_1.default.writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`);
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+function tryAcquireReclaimLock(file, commandToken) {
+    const reclaimFile = `${file}.reclaim`;
+    const metadata = (0, exports.currentProcessMetadata)(commandToken);
+    const record = { ...metadata, nonce: node_crypto_1.default.randomUUID(), startedAt: new Date().toISOString() };
+    try {
+        atomicCreateJson(reclaimFile, record);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const existing = readOwnedProcessRecord(reclaimFile, commandToken);
+        if (existing.state === "owned" || existing.state === "unknown")
+            return null;
+        node_fs_1.default.rmSync(reclaimFile, { force: true });
+        try {
+            atomicCreateJson(reclaimFile, record);
+        }
+        catch (retryError) {
+            if (retryError.code === "EEXIST")
+                return null;
+            throw retryError;
+        }
+    }
+    return () => {
+        const current = readJson(reclaimFile, null);
+        if (current?.nonce === record.nonce && current?.pid === process.pid)
+            node_fs_1.default.rmSync(reclaimFile, { force: true });
+    };
+}
+function acquireProcessLock(file, commandToken, { malformedGraceMs = 5_000 } = {}) {
+    const nonce = node_crypto_1.default.randomUUID();
+    const metadata = (0, exports.currentProcessMetadata)(commandToken);
+    const record = { ...metadata, nonce, startedAt: new Date().toISOString() };
+    let created = false;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        try {
+            atomicCreateJson(file, record);
+            created = true;
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let existing = null;
+            let malformedAge = null;
+            try {
+                existing = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+            }
+            catch {
+                try {
+                    malformedAge = Date.now() - node_fs_1.default.statSync(file).mtimeMs;
+                }
+                catch (statError) {
+                    if (statError.code === "ENOENT")
+                        continue;
+                    throw statError;
+                }
+            }
+            if (malformedAge !== null && malformedAge < malformedGraceMs)
+                throw new Error(`lock 正在创建，暂不能接管：${file}`);
+            if (existing) {
+                const state = readOwnedProcessRecord(file, existing.commandToken || commandToken);
+                if (state.state === "owned" || state.state === "unknown") {
+                    throw new Error(`lock 已被正在运行的进程占用：${file} pid=${existing.pid} state=${state.state}`);
+                }
+            }
+            const releaseReclaim = tryAcquireReclaimLock(file, commandToken);
+            if (!releaseReclaim)
+                continue;
+            try {
+                let latest = null;
+                try {
+                    latest = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+                }
+                catch {
+                    let age;
+                    try {
+                        age = Date.now() - node_fs_1.default.statSync(file).mtimeMs;
+                    }
+                    catch (statError) {
+                        if (statError.code === "ENOENT")
+                            continue;
+                        throw statError;
+                    }
+                    if (age < malformedGraceMs)
+                        throw new Error(`lock 正在创建，暂不能接管：${file}`);
+                }
+                if (latest) {
+                    const latestState = readOwnedProcessRecord(file, latest.commandToken || commandToken);
+                    if (latestState.state === "owned" || latestState.state === "unknown") {
+                        throw new Error(`lock 已被正在运行的进程占用：${file} pid=${latest.pid} state=${latestState.state}`);
+                    }
+                }
+                node_fs_1.default.rmSync(file, { force: true });
+            }
+            finally {
+                releaseReclaim();
+            }
+        }
+    }
+    if (!created)
+        throw new Error(`无法取得 lock（并发重试耗尽）：${file}`);
+    const release = () => {
+        const current = readJson(file, null);
+        if (current?.nonce === nonce && current?.pid === process.pid)
+            node_fs_1.default.rmSync(file, { force: true });
+    };
+    return { file, record, release };
+}

package/dist/platform/process-state.mjs

@@ -0,0 +1,223 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import processInspectImport from "./process-inspect.cjs";
+const processInspect = processInspectImport;
+export const pidAlive = processInspect.pidAlive;
+export const inspectProcess = processInspect.inspectProcess;
+export const currentProcessMetadata = processInspect.currentProcessMetadata;
+export function readJson(file, fallback = null) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+export function readOwnedProcessRecord(file, defaultCommandToken, { inspect = inspectProcess } = {}) {
+    const record = readJson(file, null);
+    if (!record)
+        return { file, state: "dead", alive: false, running: false, reason: "status missing" };
+    const alive = pidAlive(record.pid);
+    if (!alive)
+        return { ...record, file, state: "dead", alive: false, running: false, reason: "pid not alive" };
+    const inspected = inspect(Number(record.pid));
+    if (!inspected?.ok && inspected?.dead) {
+        return { ...record, file, state: "dead", alive: false, running: false, reason: inspected.reason || "process exited", inspected };
+    }
+    if (!inspected?.ok) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: inspected?.reason || "process inspection failed",
+        };
+    }
+    if (typeof inspected.command !== "string" || !inspected.command ||
+        typeof inspected.startToken !== "string" || !inspected.startToken) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: "process inspection metadata incomplete",
+            inspected,
+        };
+    }
+    const commandToken = record.commandToken || defaultCommandToken;
+    if (!commandToken || !inspected.command.includes(commandToken)) {
+        return { ...record, file, state: "mismatch", alive: true, running: false, reason: "command mismatch", inspected };
+    }
+    if (!record.processStartToken) {
+        return {
+            ...record,
+            file,
+            state: "unknown",
+            alive: true,
+            running: false,
+            reason: "status lacks processStartToken",
+            inspected,
+        };
+    }
+    if (record.processStartToken !== inspected.startToken) {
+        return { ...record, file, state: "mismatch", alive: true, running: false, reason: "process start mismatch", inspected };
+    }
+    return { ...record, file, state: "owned", alive: true, running: true, reason: null, inspected };
+}
+export function readProcessState(larkinHome) {
+    return {
+        supervisor: readOwnedProcessRecord(path.join(larkinHome, "supervisor-status.json"), "app/run.mjs"),
+        daemon: readOwnedProcessRecord(path.join(larkinHome, "daemon-status.json"), "app/runtime-process.mjs"),
+        dashboard: readOwnedProcessRecord(path.join(larkinHome, "dashboard-status.json"), "app/dashboard.mjs"),
+    };
+}
+export function daemonHasAgent(daemon, agentId) {
+    return !!(daemon?.state === "owned" && Array.isArray(daemon.agents) && daemon.agents.includes(agentId));
+}
+export function assertProcessCanStart(record, label) {
+    if (record?.state === "unknown") {
+        throw new Error(`${label} PID ${record.pid} 存活但身份无法确认（${record.reason}）；为避免重复进程或误杀，已停止`);
+    }
+}
+export function terminateOwnedProcess(record, signal = "SIGTERM", { inspect = inspectProcess } = {}) {
+    const current = readOwnedProcessRecord(record.file, record.commandToken, { inspect });
+    if (current.state !== "owned") {
+        throw new Error(`拒绝向 PID ${record.pid} 发送 ${signal}：进程所有权=${current.state}（${current.reason}）`);
+    }
+    process.kill(Number(current.pid), signal);
+    return current;
+}
+export async function waitForProcessExit(record, timeoutMs = 10_000, { inspect = inspectProcess } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const current = readOwnedProcessRecord(record.file, record.commandToken, { inspect });
+        if (current.state === "dead" || current.state === "mismatch")
+            return true;
+        if (current.state === "unknown")
+            throw new Error(`等待 PID ${record.pid} 退出时无法确认所有权：${current.reason}`);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+}
+function atomicCreateJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const fd = fs.openSync(file, "wx", 0o600);
+    try {
+        fs.writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function tryAcquireReclaimLock(file, commandToken) {
+    const reclaimFile = `${file}.reclaim`;
+    const metadata = currentProcessMetadata(commandToken);
+    const record = { ...metadata, nonce: crypto.randomUUID(), startedAt: new Date().toISOString() };
+    try {
+        atomicCreateJson(reclaimFile, record);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const existing = readOwnedProcessRecord(reclaimFile, commandToken);
+        if (existing.state === "owned" || existing.state === "unknown")
+            return null;
+        fs.rmSync(reclaimFile, { force: true });
+        try {
+            atomicCreateJson(reclaimFile, record);
+        }
+        catch (retryError) {
+            if (retryError.code === "EEXIST")
+                return null;
+            throw retryError;
+        }
+    }
+    return () => {
+        const current = readJson(reclaimFile, null);
+        if (current?.nonce === record.nonce && current?.pid === process.pid)
+            fs.rmSync(reclaimFile, { force: true });
+    };
+}
+export function acquireProcessLock(file, commandToken, { malformedGraceMs = 5_000 } = {}) {
+    const nonce = crypto.randomUUID();
+    const metadata = currentProcessMetadata(commandToken);
+    const record = { ...metadata, nonce, startedAt: new Date().toISOString() };
+    let created = false;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        try {
+            atomicCreateJson(file, record);
+            created = true;
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let existing = null;
+            let malformedAge = null;
+            try {
+                existing = JSON.parse(fs.readFileSync(file, "utf8"));
+            }
+            catch {
+                try {
+                    malformedAge = Date.now() - fs.statSync(file).mtimeMs;
+                }
+                catch (statError) {
+                    if (statError.code === "ENOENT")
+                        continue;
+                    throw statError;
+                }
+            }
+            if (malformedAge !== null && malformedAge < malformedGraceMs)
+                throw new Error(`lock 正在创建，暂不能接管：${file}`);
+            if (existing) {
+                const state = readOwnedProcessRecord(file, existing.commandToken || commandToken);
+                if (state.state === "owned" || state.state === "unknown") {
+                    throw new Error(`lock 已被正在运行的进程占用：${file} pid=${existing.pid} state=${state.state}`);
+                }
+            }
+            const releaseReclaim = tryAcquireReclaimLock(file, commandToken);
+            if (!releaseReclaim)
+                continue;
+            try {
+                let latest = null;
+                try {
+                    latest = JSON.parse(fs.readFileSync(file, "utf8"));
+                }
+                catch {
+                    let age;
+                    try {
+                        age = Date.now() - fs.statSync(file).mtimeMs;
+                    }
+                    catch (statError) {
+                        if (statError.code === "ENOENT")
+                            continue;
+                        throw statError;
+                    }
+                    if (age < malformedGraceMs)
+                        throw new Error(`lock 正在创建，暂不能接管：${file}`);
+                }
+                if (latest) {
+                    const latestState = readOwnedProcessRecord(file, latest.commandToken || commandToken);
+                    if (latestState.state === "owned" || latestState.state === "unknown") {
+                        throw new Error(`lock 已被正在运行的进程占用：${file} pid=${latest.pid} state=${latestState.state}`);
+                    }
+                }
+                fs.rmSync(file, { force: true });
+            }
+            finally {
+                releaseReclaim();
+            }
+        }
+    }
+    if (!created)
+        throw new Error(`无法取得 lock（并发重试耗尽）：${file}`);
+    const release = () => {
+        const current = readJson(file, null);
+        if (current?.nonce === nonce && current?.pid === process.pid)
+            fs.rmSync(file, { force: true });
+    };
+    return { file, record, release };
+}

package/dist/platform/release-artifacts.mjs

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+export const RELEASE_TARGETS = Object.freeze([
+    { platform: "darwin", arch: "arm64", bunTarget: "bun-darwin-arm64" },
+    { platform: "darwin", arch: "x64", bunTarget: "bun-darwin-x64-baseline" },
+    { platform: "linux", arch: "arm64", bunTarget: "bun-linux-arm64" },
+    { platform: "linux", arch: "x64", bunTarget: "bun-linux-x64-baseline" },
+]);
+export function artifactFilename(version, platform, arch) {
+    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+        throw new Error(`invalid release version: ${version}`);
+    if (!RELEASE_TARGETS.some((target) => target.platform === platform && target.arch === arch)) {
+        throw new Error(`unsupported release target: ${platform}-${arch}`);
+    }
+    return `larkin-v${version}-${platform}-${arch}`;
+}
+export function sha256File(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+export function selectReleaseArtifact(manifest, platform, arch) {
+    const record = manifest.artifacts.find((candidate) => candidate.platform === platform && candidate.arch === arch);
+    if (!record || !RELEASE_TARGETS.some((target) => target.platform === platform && target.arch === arch)) {
+        throw new Error(`unsupported platform: ${platform}-${arch}`);
+    }
+    if (record.file !== artifactFilename(manifest.version, record.platform, record.arch) || !/^[a-f0-9]{64}$/.test(record.sha256)) {
+        throw new Error(`invalid artifact manifest entry: ${record.file}`);
+    }
+    return record;
+}
+export function verifyReleaseArtifact(directory, record) {
+    const root = path.resolve(directory);
+    const file = path.resolve(root, record.file);
+    if (path.dirname(file) !== root)
+        throw new Error("artifact path escaped release directory");
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || !Number.isSafeInteger(record.size) || record.size <= 0 || stat.size !== record.size) {
+        throw new Error(`invalid artifact size for ${record.file}`);
+    }
+    const actual = sha256File(file);
+    if (actual !== record.sha256)
+        throw new Error(`checksum mismatch for ${record.file}`);
+    return file;
+}
+export function verifyReleaseNotices(directory, manifest) {
+    const record = manifest.notices;
+    if (!record || record.file !== "THIRD_PARTY_NOTICES.txt" || record.scope !== "runtime-closure" || !/^[a-f0-9]{64}$/.test(record.sha256)) {
+        throw new Error("invalid runtime notices manifest entry");
+    }
+    const root = path.resolve(directory);
+    const file = path.resolve(root, record.file);
+    if (path.dirname(file) !== root)
+        throw new Error("runtime notices path escaped release directory");
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || !Number.isSafeInteger(record.size) || record.size <= 0 || stat.size !== record.size) {
+        throw new Error("invalid runtime notices size");
+    }
+    if (sha256File(file) !== record.sha256)
+        throw new Error("runtime notices checksum mismatch");
+    return file;
+}