looply-cli 0.0.0-stage → 0.3.0

package/dist/autonomy-store.js

@@ -0,0 +1,581 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutonomyStore = exports.nodeAutonomyFs = exports.AUTONOMY_STORE_SCHEMA = void 0;
+exports.receiptTrouble = receiptTrouble;
+exports.autonomyStartId = autonomyStartId;
+const core_1 = require("@looply/core");
+const fs_trouble_1 = require("./fs-trouble");
+const ledger_store_1 = require("./ledger-store");
+const run_lease_1 = require("./run-lease");
+/**
+ * WHAT THIS MACHINE HAS SPENT OF A GRANT.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * THE COUNT IS NOT A NUMBER IN A FILE. IT IS A PILE OF RECEIPTS.
+ *
+ * 6D1R-C. Spending used to be read-then-write on `startsConsumed`: read 3,
+ * add one, write 4. Two daemons for one project are possible -- nothing takes
+ * a lock at daemon startup, which was verified rather than assumed -- and two
+ * of them reading 3 both write 4. One Start's worth of budget, two Starts
+ * issued, and the file afterwards is perfectly well-formed and says 4. There
+ * is no later moment at which anything could notice.
+ *
+ * So an ordinal is now RESERVED rather than counted: one file per Start,
+ * created with O_EXCL, which the operating system will hand to exactly one
+ * caller. The loser of that race gets EEXIST, moves to the next ordinal and
+ * takes that one instead. Both callers end up with a distinct Start and the
+ * total spent is still the number of files, which nobody can lose an update
+ * to because nobody ever updates anything.
+ *
+ * `startsConsumed` is DERIVED from the receipts. Storing it as well would
+ * recreate the same defect one indirection down: two sources for one fact,
+ * disagreeing the first time a write was lost.
+ *
+ * At most one Start at a time is a separate invariant, and the RUN LEASE is
+ * what holds it -- also O_EXCL, also structural. The check here is a cheap
+ * early refusal, not the guard. Two daemons that both reserve an ordinal
+ * produce one run and one refusal, and the refused one has spent a Start,
+ * which is the direction this file always errs in.
+ *
+ * The server owns AUTHORIZATION — who may pursue which goal at which version,
+ * with what ceiling, until when. This owns EXECUTION PROGRESS: how many bounded
+ * Starts have actually been spent here, and which one is in flight.
+ *
+ * One fact, one writer. A `startsConsumed` column on the server would be a
+ * counter written from both sides, and the two would disagree the first time a
+ * machine spent a Start while offline.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY NOT ANY EXISTING FILE
+ *
+ * `queue.json` — two processes write it without holding the run lease
+ * (`scan-cmd`, `verify-cmd`), each rewriting the whole list from a map filled at
+ * open. A stale writer would revert a budget, and reverting a budget REFILLS it.
+ *
+ * `goals.json` — the format is `{ schema, goals }` and nothing else survives a
+ * write. Not a race: a field that is not a goal is erased by the file's shape,
+ * on every write, from two processes.
+ *
+ * `control.json` — consumed unconditionally at the start of every run, on the
+ * reasoning that "starting a run is itself the human saying go". Right for a
+ * pause; fatal for a grant, which must outlive the runs it authorizes.
+ *
+ * The command row — deliberately time-boxed to the one-hour redelivery window,
+ * precisely so that an old command cannot be reinterpreted as a standing
+ * permission.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * FAILS CLOSED, WHICH IS THE WHOLE POINT
+ *
+ * A missing or unreadable file does NOT mean "nothing has been spent". It means
+ * this machine cannot say what it has spent, and a budget it cannot account for
+ * is a budget it may not draw on. Every other store here discards a corrupt
+ * file and carries on, because every other store holds a cache of something
+ * recoverable. This one holds the only record of what was already permitted and
+ * used, so the same policy would silently refill the budget on any corruption —
+ * turning a damaged file into unlimited Starts.
+ */
+/**
+ * Bumped only when the on-disk shape changes incompatibly. Read, not decorative.
+ *
+ * 2 dropped `startsConsumed` and `inFlight` from the file, because both are now
+ * derived from receipts. A schema-1 file is REFUSED rather than migrated: its
+ * count is a number this build has no receipts for, and inventing receipts to
+ * match it would be inventing the very evidence the receipts exist to be.
+ */
+exports.AUTONOMY_STORE_SCHEMA = 2;
+/** The real one: ledger reads and writes, plus the lease file's exclusive create. */
+exports.nodeAutonomyFs = {
+    ...ledger_store_1.nodeLedgerFs,
+    createExclusive: run_lease_1.nodeLeaseFs.createExclusive,
+};
+function isEexist(e) {
+    return typeof e === 'object' && e !== null && e.code === 'EEXIST';
+}
+/**
+ * The deterministic identity of one bounded Start within one grant.
+ *
+ * Two daemons can run for one project — nothing takes a lock at daemon startup,
+ * verified rather than assumed — so "the next Start" must be a name both would
+ * compute identically, not a fresh id each invents. Ordinal N of controller C is
+ * one Start no matter how many processes decide it is due.
+ */
+/**
+ * IS THIS RECEIPT A CAPABILITY, OR JUST A FILE THAT PARSES?
+ *
+ * The receipts ARE the Start budget. Nothing else counts them, and `spendOf`
+ * derives everything a person's evening is bounded by from the ones it finds on
+ * disk. So a receipt cannot be believed merely because JSON.parse succeeded and
+ * a number looked numeric — a certification pass fed it an empty file, the text
+ * `not json at all`, and a body naming ordinal 77 of another controller, and
+ * all three were counted as valid reservations.
+ *
+ * Every receipt carries exactly three facts, and each of them must agree with
+ * where the file is sitting:
+ *
+ *   ordinal       the file's own name says which Start this is
+ *   controllerId  the directory says whose grant it belongs to
+ *   startId       derived, never minted — `autonomyStartId(controllerId, ordinal)`
+ *
+ * A CONTRADICTION IS CORRUPTION, and neither side wins. If the path says
+ * controller C ordinal 3 and the body says controller D ordinal 2, believing
+ * the path would let a receipt be moved between grants by renaming it, and
+ * believing the body would let one be forged by writing it. There is no third
+ * option that is safe, so both are refused.
+ *
+ * NOTHING IS DUPLICATED HERE. The receipt is not given a goal id, a goal
+ * version or a generation, because it needs none of them: `controllerId` IS the
+ * generation — the server mints a new row with a new id for every act of
+ * permission, precisely so a fresh grant never inherits a spent one's identity
+ * — and the grant's own terms are held immutable by `adopt`, which refuses a
+ * known controller whose goal, version, ceiling or expiry has moved. Copying a
+ * receipt from C1 into C2's directory changes the controllerId it must match,
+ * and is caught here.
+ */
+function receiptTrouble(text, controllerId, ordinal, maxStarts) {
+    if (!Number.isInteger(ordinal) || ordinal < 1 || ordinal > maxStarts) {
+        return `Start ${ordinal} is outside the ${maxStarts} this grant was given`;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return `the receipt for Start ${ordinal} is not something this build can read`;
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return `the receipt for Start ${ordinal} is not a record`;
+    }
+    const r = parsed;
+    if (r['ordinal'] !== ordinal) {
+        return `the receipt at Start ${ordinal} says it is Start ${String(r['ordinal'])}`;
+    }
+    if (r['controllerId'] !== controllerId) {
+        return `the receipt for Start ${ordinal} belongs to ${String(r['controllerId'])}, not ${controllerId}`;
+    }
+    const expected = autonomyStartId(controllerId, ordinal);
+    if (r['startId'] !== expected) {
+        return `the receipt for Start ${ordinal} names ${String(r['startId'])}, not ${expected}`;
+    }
+    return null;
+}
+function autonomyStartId(controllerId, ordinal) {
+    return `controller-start:${controllerId}:${ordinal}`;
+}
+class AutonomyStore {
+    stateDir;
+    fs;
+    loaded = null;
+    /** Distinguishes two writes from ONE process; the pid distinguishes processes. */
+    static writes = 0;
+    constructor(stateDir, fs) {
+        this.stateDir = stateDir;
+        this.fs = fs;
+    }
+    get path() {
+        return `${this.stateDir}/autonomy.json`;
+    }
+    /** One directory per grant. The controllerId is opaque and never reused. */
+    receiptDir(controllerId) {
+        return `${this.stateDir}/autonomy/${controllerId}`;
+    }
+    /**
+     * The reservation for one ordinal. Zero-padded so the names sort as numbers
+     * for anybody who ever lists the directory by eye.
+     */
+    receiptPath(controllerId, ordinal, suffix = 'start') {
+        return `${this.receiptDir(controllerId)}/${String(ordinal).padStart(4, '0')}.${suffix}.json`;
+    }
+    /**
+     * Read the file, refusing to guess.
+     *
+     * ABSENT is `ok` with nothing in it — a machine that has never been granted
+     * autonomy has spent nothing, and that is a true statement rather than an
+     * assumption. UNREADABLE, malformed, wrong-schema and wrong-shape are all
+     * `ok: false`, because in every one of those cases a grant may exist whose
+     * spending this file was the only record of.
+     */
+    async read() {
+        let text;
+        try {
+            text = await this.fs.readFile(this.path);
+        }
+        catch (e) {
+            // A THROW FROM readFile NEVER PROVES DAMAGE. Nothing has been seen yet,
+            // so there is nothing to call corrupt; that judgement belongs to the
+            // parse below, which has actually looked at the bytes.
+            const trouble = (0, fs_trouble_1.classifyFsError)(e, 'the autonomy record');
+            return { ok: false, because: trouble.because, transient: (0, fs_trouble_1.shouldWaitFor)(trouble) };
+        }
+        if (text === null) {
+            this.loaded = [];
+            return { ok: true, progress: [] };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return { ok: false, because: 'the autonomy record is not readable JSON' };
+        }
+        const file = parsed;
+        if (typeof file !== 'object' || file === null || file.schema !== exports.AUTONOMY_STORE_SCHEMA) {
+            return {
+                ok: false,
+                because: `the autonomy record is schema ${String(file?.schema)}, this build reads ${exports.AUTONOMY_STORE_SCHEMA}`,
+            };
+        }
+        if (!Array.isArray(file.progress)) {
+            return { ok: false, because: 'the autonomy record has no progress array' };
+        }
+        // Row-level rejection is NOT enough here, and this is where the policy
+        // differs from every other store: a malformed row is a grant whose spending
+        // cannot be accounted for, and dropping it would refill its budget.
+        if (!file.progress.every(isProgress)) {
+            return { ok: false, because: 'the autonomy record has an unreadable entry' };
+        }
+        this.loaded = file.progress;
+        return { ok: true, progress: file.progress };
+    }
+    /**
+     * Spend one Start, BEFORE it is issued, and say which one it is.
+     *
+     * The direction is the safety argument. Consuming first means a crash between
+     * the write and the spawn COSTS a Start — one of eight, and the goal is no
+     * worse off. Consuming after would mean a crash between the spawn and the
+     * write GRANTS one, and a machine that crashes reliably at that point has an
+     * unbounded budget.
+     *
+     * Refuses rather than throws when the record cannot be read, when the grant is
+     * unknown, when it has ended, when it has expired, or when the ceiling is
+     * reached. Every one of those is "no Start today", not an error to be caught
+     * and ignored.
+     */
+    async consumeStart(controllerId, now) {
+        const terms = await this.termsOf(controllerId);
+        if (!terms.ok)
+            return terms;
+        const cur = terms.grant;
+        if (cur.state !== 'authorized')
+            return { ok: false, because: `the grant is ${cur.state}` };
+        if (Date.parse(cur.expiresAt) <= now) {
+            return { ok: false, because: 'the grant has expired' };
+        }
+        const spend = await this.spendOf(controllerId, cur.maxStarts);
+        if (!spend.ok)
+            return spend;
+        const unresolved = spend.spend.unfinished[0];
+        if (unresolved !== undefined) {
+            // ONE UNRESOLVED START AT A TIME, and the lowest is the one to resolve.
+            //
+            // "Unresolved" is not "running". It may be a Start whose run is going, or
+            // one whose process died before it launched anything — the difference is
+            // an attempt claim away and is not this file's business. Either way the
+            // answer is the same: finish the ordinal that has already been paid for
+            // before spending another.
+            //
+            // Advisory, deliberately. Two daemons can both pass this check; what
+            // stops two runs is the lease, and what stops two executions of one
+            // attempt is the attempt claim — both structural, where this is a read.
+            return {
+                ok: false,
+                because: `Start ${unresolved} of this grant has not been finished`,
+            };
+        }
+        if (spend.spend.startsConsumed >= cur.maxStarts) {
+            return { ok: false, because: `the grant has spent all ${cur.maxStarts} of its Starts` };
+        }
+        await this.fs.mkdir(this.receiptDir(controllerId));
+        // EXACTLY ONE ORDINAL, ALL OR NOTHING.
+        //
+        // The next one, and no other. An earlier version walked upward on EEXIST so
+        // that two racing callers each came away with a Start — which is right for
+        // a budget counter and WRONG for a grant that may only have one Start
+        // unresolved at a time. Two daemons ticking in the same second would each
+        // buy an ordinal, and the second would sit reserved-but-unexecuted behind
+        // the first: budget spent on a Start nobody asked for twice, and the
+        // one-at-a-time rule broken by the very mechanism meant to bound it.
+        //
+        // Losing is a refusal for THIS tick, not a fallback to another slot. The
+        // loser re-reads next cadence and finds the ordinal its neighbour bought,
+        // which is the same ordinal it would have wanted.
+        const ordinal = spend.spend.startsConsumed + 1;
+        const startId = autonomyStartId(controllerId, ordinal);
+        try {
+            await this.fs.createExclusive(this.receiptPath(controllerId, ordinal), JSON.stringify({ ordinal, startId, controllerId }, null, 2) + '\n');
+        }
+        catch (e) {
+            if (isEexist(e)) {
+                return { ok: false, because: `Start ${ordinal} of this grant was just reserved by another process` };
+            }
+            return { ok: false, because: `the Start could not be reserved (${e.message})` };
+        }
+        return { ok: true, ordinal, startId };
+    }
+    /**
+     * Record which run a Start produced, so its ending can be watched for.
+     *
+     * Immutable like the reservation. A second call naming the SAME run is the
+     * redelivery this whole system is built to tolerate; a second call naming a
+     * different one is two runs claiming one Start, and it is refused rather
+     * than allowed to overwrite the first answer.
+     */
+    async noteRun(controllerId, ordinal, runId) {
+        const path = this.receiptPath(controllerId, ordinal, 'run');
+        try {
+            await this.fs.createExclusive(path, JSON.stringify({ ordinal, runId }, null, 2) + '\n');
+        }
+        catch (e) {
+            if (!isEexist(e))
+                throw e;
+            const held = readRun(await this.fs.readFile(path));
+            if (held !== runId) {
+                throw new Error(`Start ${ordinal} of ${controllerId} already produced run ${String(held)}`);
+            }
+        }
+    }
+    /** The Start is over, however it ended. The count is NOT given back. */
+    async clearInFlight(controllerId) {
+        const terms = await this.termsOf(controllerId);
+        if (!terms.ok)
+            return;
+        const spend = await this.spendOf(controllerId, terms.grant.maxStarts);
+        if (!spend.ok)
+            return;
+        // The LOWEST unresolved one. Taking the highest is what left an earlier
+        // ordinal unfinished for ever, and it only ever mattered because two of
+        // them can be reserved at once.
+        const lowest = spend.spend.unfinished[0];
+        if (lowest === undefined)
+            return;
+        await this.finishStart(controllerId, lowest);
+    }
+    /** Mark one Start over by ordinal. Idempotent: it is already over. */
+    async finishStart(controllerId, ordinal) {
+        try {
+            await this.fs.createExclusive(this.receiptPath(controllerId, ordinal, 'done'), JSON.stringify({ ordinal }, null, 2) + '\n');
+        }
+        catch (e) {
+            if (!isEexist(e))
+                throw e;
+        }
+    }
+    /** The terms of one grant, or why they cannot be answered for. */
+    async termsOf(controllerId) {
+        const read = await this.read();
+        if (!read.ok)
+            return { ok: false, because: read.because };
+        const grant = read.progress.find((p) => p.controllerId === controllerId);
+        if (grant === undefined) {
+            return { ok: false, because: 'this machine has no record of that grant' };
+        }
+        return { ok: true, grant };
+    }
+    /**
+     * Count the receipts.
+     *
+     * Probed ordinal by ordinal rather than listed, because a ceiling of eight
+     * makes eight reads cheaper than adding a directory-listing capability to
+     * every filesystem double in the tree -- and a probe cannot be fooled by a
+     * stray file the way a listing can.
+     */
+    async spendOf(controllerId, maxStarts) {
+        const reserved = [];
+        const missing = [];
+        const unfinished = [];
+        const runs = {};
+        for (let ordinal = 1; ordinal <= maxStarts; ordinal++) {
+            let receipt;
+            try {
+                receipt = await this.fs.readFile(this.receiptPath(controllerId, ordinal));
+            }
+            catch (e) {
+                // A receipt that cannot be READ is not a Start that did not happen —
+                // and it is not a damaged one either. Something else holding the file
+                // for a moment says nothing about the bytes.
+                const t = (0, fs_trouble_1.classifyFsError)(e, `the receipt for Start ${ordinal}`);
+                return { ok: false, transient: (0, fs_trouble_1.shouldWaitFor)(t), because: t.because };
+            }
+            if (receipt === null) {
+                missing.push(ordinal);
+                continue;
+            }
+            if (missing.length > 0) {
+                // A GAP. Receipts are contiguous by construction -- every reservation
+                // takes the lowest free ordinal -- so a hole means one was removed.
+                //
+                // Neither counting around it nor stopping at it is safe. Counting
+                // around gives ordinal 1 back to the next caller, which would issue a
+                // SECOND Start under a startId already used; stopping at it reports a
+                // smaller spend than the receipts show, which refills the budget above
+                // the hole. This is the store that refuses to guess, so it refuses.
+                return {
+                    ok: false,
+                    transient: false,
+                    because: `Start ${missing[0]} of this grant has no receipt, but Start ${ordinal} does`,
+                };
+            }
+            // THE RECEIPT IS THE BUDGET, so it is read rather than counted.
+            const wrong = receiptTrouble(receipt, controllerId, ordinal, maxStarts);
+            if (wrong !== null)
+                return { ok: false, transient: false, because: wrong };
+            reserved.push(ordinal);
+            const done = await this.fs.readFile(this.receiptPath(controllerId, ordinal, 'done'));
+            if (done !== null)
+                continue;
+            // Ascending, and every one of them — not the last one to be looked at.
+            unfinished.push(ordinal);
+            const runId = readRun(await this.fs.readFile(this.receiptPath(controllerId, ordinal, 'run')));
+            if (runId !== null)
+                runs[ordinal] = runId;
+        }
+        // EVIDENCE ABOVE THE HIGHEST RESERVATION.
+        //
+        // Contiguity catches a receipt removed from the MIDDLE, because a survivor
+        // above the hole gives it away. It cannot catch one trimmed from the TOP:
+        // delete the highest and what remains is a shorter, perfectly contiguous
+        // history, and the budget quietly grows by one.
+        //
+        // But a Start that happened leaves more than its reservation. The `.done`
+        // that closed it and the `.run` that named its run are still sitting in the
+        // same directory, and they are proof that an ordinal nobody has a
+        // reservation for was nevertheless spent. Two records that cannot both be
+        // true, so neither is believed.
+        for (let ordinal = reserved.length + 1; ordinal <= maxStarts; ordinal++) {
+            for (const suffix of ['done', 'run']) {
+                let orphan;
+                try {
+                    orphan = await this.fs.readFile(this.receiptPath(controllerId, ordinal, suffix));
+                }
+                catch (e) {
+                    const t = (0, fs_trouble_1.classifyFsError)(e, `the ${suffix} record of Start ${ordinal}`);
+                    return { ok: false, transient: (0, fs_trouble_1.shouldWaitFor)(t), because: t.because };
+                }
+                if (orphan !== null) {
+                    return {
+                        ok: false,
+                        transient: false,
+                        because: `Start ${ordinal} left a ${suffix} record but has no reservation`,
+                    };
+                }
+            }
+        }
+        return {
+            ok: true,
+            spend: { reserved, startsConsumed: reserved.length, unfinished, runs },
+        };
+    }
+    /** Adopt a grant the server issued. Re-adopting the same one keeps what was spent. */
+    async adopt(grant) {
+        const read = await this.read();
+        // A record that cannot be read must not be replaced by a fresh one: that is
+        // exactly how a lost counter would refill a budget.
+        //
+        // The transience travels with the error because the caller's two answers
+        // are not both retryable: a grant the daemon refuses is refused for good.
+        if (!read.ok) {
+            throw Object.assign(new Error(read.because), { transient: read.transient === true });
+        }
+        const at = read.progress.findIndex((p) => p.controllerId === grant.controllerId);
+        const next = [...read.progress];
+        if (at === -1) {
+            next.push({ ...grant, state: 'authorized' });
+        }
+        else {
+            // Same controllerId, seen before. From 6D1R-B this can only be a
+            // RE-DELIVERY of one command: the server never revives an ended grant, it
+            // mints a new row with a new id, so a second authorization arrives as a
+            // controllerId this machine has never seen. Which means the terms cannot
+            // have changed, and a re-delivery must not be allowed to move them --
+            // that would be the one shape that could raise a ceiling against a count
+            // already spent.
+            const held = next[at];
+            const same = held.goalId === grant.goalId &&
+                held.goalVersion === grant.goalVersion &&
+                held.maxStarts === grant.maxStarts &&
+                held.expiresAt === grant.expiresAt;
+            if (!same) {
+                throw new Error(`grant ${grant.controllerId} came back with different terms; this machine will not adopt it`);
+            }
+            // Nothing to write. Returning early also means a redelivery cannot cost a
+            // file write, which is the only way `startsConsumed` could be disturbed.
+            return;
+        }
+        await this.write(next);
+    }
+    /**
+     * Note that the server has been told how this pursuit ended.
+     *
+     * Separate from `settle` on purpose: one is what this machine concluded, the
+     * other is that somebody else now knows. A crash between them must leave the
+     * conclusion standing and the telling still owed.
+     */
+    async markProjected(controllerId, at) {
+        const read = await this.read();
+        if (!read.ok)
+            return;
+        const idx = read.progress.findIndex((p) => p.controllerId === controllerId);
+        if (idx === -1)
+            return;
+        const next = [...read.progress];
+        next[idx] = { ...read.progress[idx], projectedAt: at };
+        await this.write(next);
+    }
+    /** Record where this grant came to rest. Terminal states spend nothing further. */
+    async settle(controllerId, state) {
+        const read = await this.read();
+        if (!read.ok)
+            return;
+        const at = read.progress.findIndex((p) => p.controllerId === controllerId);
+        if (at === -1)
+            return;
+        const next = [...read.progress];
+        next[at] = { ...read.progress[at], state };
+        await this.write(next);
+    }
+    /** What this machine last read. Empty before a successful `read`. */
+    all() {
+        return this.loaded ?? [];
+    }
+    async write(progress) {
+        const body = { schema: exports.AUTONOMY_STORE_SCHEMA, progress };
+        await this.fs.mkdir(this.stateDir);
+        // Temp-then-rename, the same contract as every other store here: a
+        // half-written record read by the next process is worse than none, because
+        // it looks like data.
+        //
+        // The temp name is PRIVATE TO THIS WRITER. A shared `autonomy.json.tmp` is
+        // two processes writing one path: the second truncates and rewrites what
+        // the first is midway through, and then both rename it into place. The
+        // rename is atomic and the file it renames is a splice of two writes.
+        const tmp = `${this.path}.${process.pid}.${(AutonomyStore.writes += 1)}.tmp`;
+        await this.fs.writeFile(tmp, JSON.stringify(body, null, 2) + '\n');
+        await this.fs.rename(tmp, this.path);
+        this.loaded = progress;
+    }
+}
+exports.AutonomyStore = AutonomyStore;
+function isProgress(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const p = v;
+    return (typeof p['controllerId'] === 'string' &&
+        typeof p['goalId'] === 'string' &&
+        typeof p['goalVersion'] === 'number' &&
+        typeof p['maxStarts'] === 'number' &&
+        typeof p['expiresAt'] === 'string' &&
+        (0, core_1.isGoalAutonomyState)(p['state']));
+}
+/** The runId out of a `.run.json` receipt, or null if there isn't one to read. */
+function readRun(text) {
+    if (text === null)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed.runId === 'string' ? parsed.runId : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=autonomy-store.js.map

package/dist/autonomy-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-store.js","sourceRoot":"","sources":["../src/autonomy-store.ts"],"names":[],"mappings":"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"}