@lsctech/polaris 0.1.0

package/dist/runs/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLedgerPath = resolveLedgerPath;
+exports.resolveStateFile = resolveStateFile;
+exports.readLedger = readLedger;
+exports.createRunsCommand = createRunsCommand;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const ledger_js_1 = require("../loop/ledger.js");
+const list_js_1 = require("./list.js");
+const show_js_1 = require("./show.js");
+const ledger_tail_js_1 = require("./ledger-tail.js");
+const reconcile_js_1 = require("./reconcile.js");
+function resolveLedgerPath(repoRoot) {
+    return (0, node_path_1.resolve)(repoRoot, ledger_js_1.DEFAULT_LEDGER_PATH);
+}
+function resolveStateFile(repoRoot) {
+    const taskchainPath = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json");
+    const polarisPath = (0, node_path_1.join)(repoRoot, ".polaris", "runs", "current-state.json");
+    if ((0, node_fs_1.existsSync)(taskchainPath))
+        return taskchainPath;
+    if ((0, node_fs_1.existsSync)(polarisPath))
+        return polarisPath;
+    return taskchainPath;
+}
+function readLedger(repoRoot) {
+    const ledgerPath = resolveLedgerPath(repoRoot);
+    if (!(0, node_fs_1.existsSync)(ledgerPath)) {
+        return null;
+    }
+    const raw = (0, node_fs_1.readFileSync)(ledgerPath, "utf-8");
+    const rawLines = raw.split(/\r?\n/).filter((line) => line.length > 0);
+    const events = [];
+    for (let i = 0; i < rawLines.length; i++) {
+        try {
+            events.push(JSON.parse(rawLines[i]));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Warning: skipping malformed ledger line ${i + 1} in ${ledgerPath}: ${msg}\nContent: ${rawLines[i]}`);
+        }
+    }
+    return {
+        ledgerPath,
+        rawLines,
+        events,
+    };
+}
+function noLedgerFound() {
+    process.stdout.write("no ledger found\n");
+}
+function createRunsCommand(options) {
+    const runs = new commander_1.Command("runs")
+        .description("safe/read-only: inspect Polaris global run ledger")
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .action(() => {
+        runs.outputHelp();
+    });
+    runs
+        .command("list")
+        .description("safe/read-only: list runs from the global ledger")
+        .option("--open", "Only show runs whose latest status is not complete or finalized")
+        .action((commandOptions) => {
+        const ledger = readLedger(options.repoRoot);
+        if (!ledger) {
+            noLedgerFound();
+            return;
+        }
+        (0, list_js_1.runRunsList)(ledger.events, { open: Boolean(commandOptions.open) });
+    });
+    runs
+        .command("show")
+        .description("safe/read-only: show all ledger events for a run")
+        .argument("<run-id>", "Run ID to inspect")
+        .action((runId) => {
+        const ledger = readLedger(options.repoRoot);
+        if (!ledger) {
+            noLedgerFound();
+            return;
+        }
+        (0, show_js_1.runRunsShow)(ledger.events, runId);
+    });
+    const ledger = runs
+        .command("ledger")
+        .description("safe/read-only: inspect raw ledger storage")
+        .showHelpAfterError()
+        .action(() => {
+        ledger.outputHelp();
+    });
+    ledger
+        .command("tail")
+        .description("safe/read-only: print the last N raw ledger lines")
+        .option("--n <count>", "Number of lines to print", "20")
+        .action((commandOptions) => {
+        const ledgerData = readLedger(options.repoRoot);
+        if (!ledgerData) {
+            noLedgerFound();
+            return;
+        }
+        (0, ledger_tail_js_1.runRunsLedgerTail)(ledgerData.rawLines, commandOptions.n);
+    });
+    runs
+        .command("reconcile")
+        .description("safe/read-only: report divergence between ledger and current-state.json")
+        .action(() => {
+        const ledgerData = readLedger(options.repoRoot);
+        if (!ledgerData) {
+            noLedgerFound();
+            return;
+        }
+        (0, reconcile_js_1.runRunsReconcile)(ledgerData.events, {
+            repoRoot: options.repoRoot,
+            stateFile: resolveStateFile(options.repoRoot),
+        });
+    });
+    return runs;
+}

package/dist/runs/index.test.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const vitest_1 = require("vitest");
+const index_js_1 = require("../cli/index.js");
+const stdout = vitest_1.vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+const stderr = vitest_1.vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+(0, vitest_1.afterEach)(() => {
+    stdout.mockClear();
+    stderr.mockClear();
+});
+function repoWithLedger(events) {
+    const repoRoot = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-runs-"));
+    if (events) {
+        const ledgerDir = (0, node_path_1.join)(repoRoot, ".polaris", "runs");
+        (0, node_fs_1.mkdirSync)(ledgerDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(ledgerDir, "ledger.jsonl"), events.map((event) => JSON.stringify(event)).join("\n") + "\n");
+    }
+    return repoRoot;
+}
+function event(overrides) {
+    return {
+        schema_version: 1,
+        event_id: overrides.event_id ?? "event-1",
+        event: overrides.event ?? "run-started",
+        run_id: overrides.run_id ?? "run-1",
+        run_type: overrides.run_type ?? "implement",
+        cluster_id: overrides.cluster_id ?? "POL-1",
+        issue_id: overrides.issue_id ?? null,
+        branch: overrides.branch ?? "feature/run-1",
+        status: overrides.status ?? "running",
+        completed_children: overrides.completed_children ?? [],
+        open_children: overrides.open_children ?? [],
+        next_child: overrides.next_child ?? null,
+        last_commit: overrides.last_commit ?? null,
+        pr_url: overrides.pr_url ?? null,
+        timestamp: overrides.timestamp ?? "2026-05-28T00:00:00.000Z",
+        ...overrides,
+    };
+}
+async function run(args, repoRoot) {
+    const program = (0, index_js_1.createPolarisCommand)({ repoRoot });
+    let exitCode = 0;
+    program.exitOverride();
+    try {
+        await program.parseAsync(["node", "polaris", ...args], { from: "node" });
+    }
+    catch (error) {
+        if (error instanceof Error && "exitCode" in error) {
+            exitCode = Number(error.exitCode);
+        }
+        else {
+            throw error;
+        }
+    }
+    return {
+        exitCode,
+        output: stdout.mock.calls.map((call) => String(call[0])).join(""),
+    };
+}
+(0, vitest_1.describe)("polaris runs", () => {
+    (0, vitest_1.it)("lists the latest row for each run with required columns", async () => {
+        const repoRoot = repoWithLedger([
+            event({ run_id: "run-a", event_id: "a-1", status: "running" }),
+            event({
+                run_id: "run-a",
+                event_id: "a-2",
+                status: "cluster-complete",
+                timestamp: "2026-05-28T00:05:00.000Z",
+            }),
+            event({
+                run_id: "run-b",
+                event_id: "b-1",
+                run_type: "analyze",
+                cluster_id: "POL-2",
+                branch: "feature/run-2",
+                status: "finalized",
+                timestamp: "2026-05-28T00:07:00.000Z",
+            }),
+        ]);
+        const result = await run(["runs", "list"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output).toContain("run_id");
+        (0, vitest_1.expect)(result.output).toContain("run_type");
+        (0, vitest_1.expect)(result.output).toContain("cluster_id");
+        (0, vitest_1.expect)(result.output).toContain("branch");
+        (0, vitest_1.expect)(result.output).toContain("status");
+        (0, vitest_1.expect)(result.output).toContain("last event timestamp");
+        (0, vitest_1.expect)(result.output).toContain("run-a");
+        (0, vitest_1.expect)(result.output).toContain("cluster-complete");
+        (0, vitest_1.expect)(result.output).toContain("run-b");
+        (0, vitest_1.expect)(result.output).toContain("finalized");
+    });
+    (0, vitest_1.it)("filters list --open to runs not complete or finalized", async () => {
+        const repoRoot = repoWithLedger([
+            event({ run_id: "open-run", status: "running" }),
+            event({ run_id: "complete-run", status: "complete" }),
+            event({ run_id: "finalized-run", status: "finalized" }),
+        ]);
+        const result = await run(["runs", "list", "--open"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output).toContain("open-run");
+        (0, vitest_1.expect)(result.output).not.toContain("complete-run");
+        (0, vitest_1.expect)(result.output).not.toContain("finalized-run");
+    });
+    (0, vitest_1.it)("shows events for a run in chronological order", async () => {
+        const repoRoot = repoWithLedger([
+            event({
+                run_id: "run-a",
+                event_id: "late",
+                event: "child-completed",
+                timestamp: "2026-05-28T00:05:00.000Z",
+                issue_id: "POL-2",
+                last_commit: "abc123",
+                validation: { status: "passed" },
+            }),
+            event({
+                run_id: "run-a",
+                event_id: "early",
+                event: "run-started",
+                timestamp: "2026-05-28T00:01:00.000Z",
+            }),
+            event({ run_id: "run-b", event_id: "other" }),
+        ]);
+        const result = await run(["runs", "show", "run-a"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output.indexOf('"event_id":"early"')).toBeLessThan(result.output.indexOf('"event_id":"late"'));
+        (0, vitest_1.expect)(result.output).not.toContain('"event_id":"other"');
+    });
+    (0, vitest_1.it)("tails the last N raw ledger lines", async () => {
+        const repoRoot = repoWithLedger([
+            event({ event_id: "one" }),
+            event({ event_id: "two" }),
+            event({ event_id: "three" }),
+        ]);
+        const result = await run(["runs", "ledger", "tail", "--n", "2"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output).not.toContain('"event_id":"one"');
+        (0, vitest_1.expect)(result.output).toContain('"event_id":"two"');
+        (0, vitest_1.expect)(result.output).toContain('"event_id":"three"');
+    });
+    (0, vitest_1.it)("reports reconcile divergence without mutating state", async () => {
+        const repoRoot = repoWithLedger([
+            event({
+                run_id: "run-a",
+                cluster_id: "POL-1",
+                branch: "feature/ledger",
+                status: "running",
+                completed_children: [],
+                open_children: ["POL-2"],
+                next_child: "POL-2",
+                last_commit: "ledger-commit",
+            }),
+        ]);
+        const statePath = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json");
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run"), { recursive: true });
+        const state = {
+            run_id: "run-a",
+            cluster_id: "POL-1",
+            branch: "feature/state",
+            status: "running",
+            completed_children: ["POL-1"],
+            open_children: [],
+            next_open_child: null,
+            last_commit: "state-commit",
+        };
+        (0, node_fs_1.writeFileSync)(statePath, JSON.stringify(state, null, 2));
+        const result = await run(["runs", "reconcile"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output).toContain("divergence");
+        (0, vitest_1.expect)(result.output).toContain("branch");
+        (0, vitest_1.expect)(result.output).toContain("completed_children");
+        (0, vitest_1.expect)(result.output).toContain("read-only");
+        (0, vitest_1.expect)(JSON.parse((0, node_fs_1.readFileSync)(statePath, "utf-8"))).toEqual(state);
+    });
+    (0, vitest_1.it)("exits cleanly when the ledger is absent", async () => {
+        const repoRoot = repoWithLedger();
+        const result = await run(["runs", "list"], repoRoot);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.output.trim()).toBe("no ledger found");
+    });
+});

package/dist/runs/ledger-tail.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunsLedgerTail = runRunsLedgerTail;
+function parseLineCount(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        return 20;
+    }
+    return parsed;
+}
+function runRunsLedgerTail(rawLines, count) {
+    const lineCount = parseLineCount(count);
+    const lines = rawLines.slice(-lineCount);
+    process.stdout.write(lines.length > 0 ? `${lines.join("\n")}\n` : "");
+}

package/dist/runs/list.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunsList = runRunsList;
+const CLOSED_STATUSES = new Set(["complete", "finalized"]);
+function latestEventsByRun(events) {
+    const latest = new Map();
+    for (const event of events) {
+        latest.set(event.run_id, event);
+    }
+    return Array.from(latest.values()).sort((left, right) => left.run_id.localeCompare(right.run_id));
+}
+function formatRow(values) {
+    return values.join("\t");
+}
+function runRunsList(events, options) {
+    const rows = latestEventsByRun(events).filter((event) => !options.open || !CLOSED_STATUSES.has(event.status));
+    const lines = [
+        formatRow(["run_id", "run_type", "cluster_id", "branch", "status", "last event timestamp"]),
+        ...rows.map((event) => formatRow([
+            event.run_id,
+            event.run_type,
+            event.cluster_id ?? "",
+            event.branch,
+            event.status,
+            event.timestamp,
+        ])),
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}

package/dist/runs/reconcile.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunsReconcile = runRunsReconcile;
+const node_fs_1 = require("node:fs");
+function latestEventForRun(events, runId) {
+    return events.filter((event) => event.run_id === runId).at(-1) ?? null;
+}
+function sameStringArray(left, right) {
+    return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+function collectDivergences(ledger, state) {
+    const divergences = [];
+    const scalarChecks = [
+        ["cluster_id", ledger.cluster_id, state.cluster_id],
+        ["branch", ledger.branch, state.branch],
+        ["status", ledger.status, state.status],
+        ["next_child", ledger.next_child, state.next_open_child ?? null],
+        ["last_commit", ledger.last_commit, state.last_commit ?? null],
+    ];
+    for (const [field, ledgerValue, stateValue] of scalarChecks) {
+        if (ledgerValue !== stateValue) {
+            divergences.push({ field, ledger: ledgerValue, current_state: stateValue });
+        }
+    }
+    if (!sameStringArray(ledger.completed_children, state.completed_children)) {
+        divergences.push({
+            field: "completed_children",
+            ledger: ledger.completed_children,
+            current_state: state.completed_children ?? [],
+        });
+    }
+    if (!sameStringArray(ledger.open_children, state.open_children)) {
+        divergences.push({
+            field: "open_children",
+            ledger: ledger.open_children,
+            current_state: state.open_children ?? [],
+        });
+    }
+    return divergences;
+}
+function runRunsReconcile(events, options) {
+    if (!(0, node_fs_1.existsSync)(options.stateFile)) {
+        process.stdout.write(`read-only: no current-state.json found at ${options.stateFile}\n`);
+        return;
+    }
+    let state;
+    try {
+        state = JSON.parse((0, node_fs_1.readFileSync)(options.stateFile, "utf-8"));
+    }
+    catch (err) {
+        process.stdout.write("read-only: current-state.json has no run_id\n");
+        return;
+    }
+    if (!state.run_id) {
+        process.stdout.write("read-only: current-state.json has no run_id\n");
+        return;
+    }
+    const latest = latestEventForRun(events, state.run_id);
+    if (!latest) {
+        process.stdout.write(`read-only: divergence found\nrun_id\tledger\tcurrent_state\n${state.run_id}\tmissing\tpresent\n`);
+        return;
+    }
+    const divergences = collectDivergences(latest, state);
+    if (divergences.length === 0) {
+        process.stdout.write("read-only: no divergence found\n");
+        return;
+    }
+    const lines = [
+        "read-only: divergence found",
+        "field\tledger\tcurrent_state",
+        ...divergences.map((divergence) => `${divergence.field}\t${JSON.stringify(divergence.ledger)}\t${JSON.stringify(divergence.current_state)}`),
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}

package/dist/runs/show.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunsShow = runRunsShow;
+function runRunsShow(events, runId) {
+    const lines = events
+        .filter((event) => event.run_id === runId)
+        .sort((left, right) => left.timestamp.localeCompare(right.timestamp))
+        .map((event) => JSON.stringify(event));
+    process.stdout.write(lines.length > 0 ? `${lines.join("\n")}\n` : "");
+}

package/dist/runtime/audit/logger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendAuditEvent = appendAuditEvent;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const state_js_1 = require("../state.js");
+async function appendAuditEvent(artifactDir, event) {
+    const dir = (0, state_js_1.getArtifactDir)(artifactDir);
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    const entry = { timestamp: new Date().toISOString(), ...event };
+    await (0, promises_1.appendFile)(node_path_1.default.join(dir, "audit.jsonl"), JSON.stringify(entry) + "\n", "utf-8");
+}

package/dist/runtime/audit/reader.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAuditLog = readAuditLog;
+exports.findLastEvent = findLastEvent;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const state_js_1 = require("../state.js");
+async function readAuditLog(artifactDir) {
+    const auditFile = node_path_1.default.join((0, state_js_1.getArtifactDir)(artifactDir), "audit.jsonl");
+    try {
+        const raw = await (0, promises_1.readFile)(auditFile, "utf-8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        const events = [];
+        for (const line of lines) {
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch (parseErr) {
+                throw new Error(`Audit log corruption detected in ${auditFile}: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+            }
+        }
+        return events;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+function findLastEvent(log, eventType, run_id, step_cursor) {
+    for (let i = log.length - 1; i >= 0; i--) {
+        const e = log[i];
+        if (e.event_type === eventType && e.run_id === run_id && e.step_cursor === step_cursor) {
+            return e;
+        }
+    }
+    return undefined;
+}

package/dist/runtime/checkpoint.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCheckpoint = writeCheckpoint;
+exports.recoverFromCheckpoint = recoverFromCheckpoint;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const logger_js_1 = require("./audit/logger.js");
+const state_js_1 = require("./state.js");
+function getCheckpointsDir(artifactDir) {
+    return node_path_1.default.join((0, state_js_1.getArtifactDir)(artifactDir), "checkpoints");
+}
+function buildCheckpointFilename(stepCursor, timestamp) {
+    // Sanitize step_cursor so it can safely appear in a filename
+    const safeCursor = stepCursor.replace(/[^a-zA-Z0-9_-]/g, "_");
+    // Collapse ISO timestamp to a filesystem-safe form: 20260525T202317Z
+    const safeTs = timestamp.replace(/[:.]/g, "").replace("Z", "Z").slice(0, 16) + "Z";
+    return `${safeCursor}-${safeTs}.json`;
+}
+/**
+ * Write a checkpoint for the current state of the given artifact directory.
+ *
+ * Loads the current state snapshot from disk (fresh read), writes it to
+ * `.taskchain_artifacts/{artifactDir}/checkpoints/{step_cursor}-{timestamp}.json`,
+ * and appends a `checkpoint_written` audit event.
+ *
+ * Throws if the state file cannot be read or the checkpoint cannot be written.
+ */
+async function writeCheckpoint(artifactDir, stepCursor) {
+    const state = await (0, state_js_1.loadState)(artifactDir);
+    if (state === null) {
+        throw new Error(`writeCheckpoint: cannot load state for artifact_dir="${artifactDir}" — current-state.json not found`);
+    }
+    const writtenAt = new Date().toISOString();
+    const filename = buildCheckpointFilename(stepCursor, writtenAt);
+    const checkpointsDir = getCheckpointsDir(artifactDir);
+    const checkpointPath = node_path_1.default.join(checkpointsDir, filename);
+    const record = {
+        artifact_dir: artifactDir,
+        step_cursor: stepCursor,
+        written_at: writtenAt,
+        state_snapshot: state,
+    };
+    await (0, promises_1.mkdir)(checkpointsDir, { recursive: true });
+    await (0, promises_1.writeFile)(checkpointPath, JSON.stringify(record, null, 2) + "\n", "utf-8");
+    await (0, logger_js_1.appendAuditEvent)(artifactDir, {
+        event_type: "checkpoint_written",
+        run_id: state.run_id,
+        step_cursor: stepCursor,
+        operator: "polaris-runtime",
+        operation: "write_checkpoint",
+        result: "ok",
+        metadata: { checkpoint_file: filename },
+    });
+    return record;
+}
+/**
+ * Find and return the latest checkpoint for the given artifact directory.
+ *
+ * Checkpoints are sorted lexicographically by filename; the last entry is the
+ * most recent. Returns null if the checkpoints directory does not exist or
+ * contains no `.json` files.
+ */
+async function recoverFromCheckpoint(artifactDir) {
+    const checkpointsDir = getCheckpointsDir(artifactDir);
+    let entries;
+    try {
+        const dirEntries = await (0, promises_1.readdir)(checkpointsDir);
+        entries = dirEntries.filter((name) => name.endsWith(".json")).sort();
+    }
+    catch {
+        // Directory does not exist or is not readable — no checkpoints
+        return null;
+    }
+    if (entries.length === 0) {
+        return null;
+    }
+    const latestFile = entries[entries.length - 1];
+    const filePath = node_path_1.default.join(checkpointsDir, latestFile);
+    try {
+        const raw = await (0, promises_1.readFile)(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}