looply-cli 0.0.0-stage → 0.3.0

package/dist/rails-home.d.ts

@@ -0,0 +1,162 @@
+/**
+ * WHERE THE RAILS LEDGERS LIVE, AND WHY IT IS NOT IN THE REPOSITORY.
+ *
+ * Two files decide whether a rail is shut: the exemption spend ledger (has this
+ * single-use grant been used?) and the loop-safety history (is this goal held?).
+ * Phase 1 moved both from the per-checkout state directory to the PROJECT state
+ * directory, which is what stopped N workspaces giving one grant N spends. That
+ * was the urgent half.
+ *
+ * 🔴 THE REMAINING HALF: THE PROJECT STATE DIRECTORY IS INSIDE THE REPOSITORY.
+ *
+ * For an ordinary checkout `projectStateDir` is `<repo>/.looply/state`. So the
+ * record of every single-use grant this machine has already spent sits in a
+ * directory that:
+ *
+ *   - `discard()` deliberately preserves (`-e .looply`) but a person's own
+ *     `git clean -xfd` does not,
+ *   - a re-clone does not carry, because `.looply/state` is not tracked,
+ *   - and `rm -rf` on a finished checkout takes with it.
+ *
+ * Every one of those turns a spent single-use exemption back into an unspent
+ * one. Not by an attack — by ordinary housekeeping. A rail whose "already used"
+ * record a person can delete without knowing they did is not a rail.
+ *
+ * ⚠️ THE PRECEDENT IS ALREADY IN THIS CODEBASE. `projectStateDir` itself falls
+ * back to `~/.looply/projects/<key>/state` for a repository with no main
+ * worktree, with the note that "`~/.looply` is where this codebase already puts
+ * state that must survive the repository". That is the argument, and it applies
+ * to the rails ledgers of EVERY repository, not only the bare ones.
+ *
+ * ⚠️ AND IT IS KEYED THE SAME WAY EVERYTHING ELSE IS. `repoIdentityPath` is what
+ * `workspacesRoot` hashes and what the registry agrees on: the main worktree
+ * root, or the common dir for a bare repository, or the directory itself.
+ * Ordinary checkouts and linked worktrees of one repository therefore share one
+ * key, which is the entire point.
+ */
+export declare function railsDir(cwd: string, home?: string): string;
+/** What a migration reads and writes. Narrow on purpose: no delete of anything old. */
+export interface MigrationFs {
+    /** Resolves to null when the file does not exist; THROWS when it exists and cannot be read. */
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, data: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    /** Recursive; succeeds when the directory already exists. */
+    mkdir(path: string): Promise<void>;
+    /** Fails with EEXIST when the path is already there. The whole arbitration. */
+    createExclusive(path: string, data: string): Promise<void>;
+    /** Entry names, or null when the directory does not exist. */
+    readDir(path: string): Promise<string[] | null>;
+    /** Removes ONE file. Only ever called on a migration token this process wrote. */
+    unlink(path: string): Promise<void>;
+}
+/** One source's content, handed to a merge. `path` is included so a merge can order by origin. */
+export interface MigrationPart {
+    readonly path: string;
+    readonly text: string;
+}
+export interface MigrationFile {
+    /** The file's name inside the machine-level directory. */
+    readonly name: string;
+    /** Old locations, in any order. Missing ones are skipped; unreadable ones REFUSE. */
+    readonly sources: readonly string[];
+    /** Combine the target's current content (first, when present) with every source. */
+    readonly merge: (parts: readonly MigrationPart[]) => string;
+}
+/**
+ * A directory whose entries move across whole, never merged.
+ *
+ * 🔴 THE OVERRIDE MARKERS, AND THEY ARE NOT OPTIONAL.
+ *
+ * `foldInSpentRetries` re-derives "has this incident's one retry been spent"
+ * from `loop-safety-overrides/<id>.json` on EVERY open. Move the incidents to
+ * the machine-level home and leave the markers behind, and a person who already
+ * spent their one retry finds the hold active again — the retry was consumed
+ * and did nothing. Move the markers and leave the incidents, and the reverse:
+ * a marker for an incident nothing can see.
+ *
+ * ⚠️ ENTRIES ARE NEVER OVERWRITTEN. A marker is an exclusive-create claim whose
+ * whole meaning is "this was taken first"; a copy that replaced one would be
+ * handing the same retry out twice.
+ */
+export interface MigrationDir {
+    /** The directory's name inside the machine-level directory. */
+    readonly name: string;
+    /** Old locations, in any order. Missing ones are skipped. */
+    readonly sources: readonly string[];
+}
+export type MigrationResult = {
+    readonly ok: true;
+    readonly migrated: boolean;
+    readonly read: readonly string[];
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+/**
+ * MOVE A LEDGER FORWARD ONCE, MERGED, UNDER AN EXCLUSIVE CREATE.
+ *
+ * 🔴 "READ THE OLD PATH WHEN THE NEW ONE IS ABSENT" IS NOT A MIGRATION. IT IS
+ * THE BYPASS.
+ *
+ * That was the first design and it is worth stating why it fails, because it
+ * reads as the conservative option. The old file records that grant `g` was
+ * spent. The first UNRELATED spend after the move creates the new file. From
+ * that moment the new file is present, the fallback stops firing, the old
+ * file's record of `g` is invisible — and `g`, a single-use grant over a railed
+ * path, is spendable a second time. The relocation would re-open exactly the
+ * rail it was done to protect.
+ *
+ * The loop-safety history has the same shape with a milder consequence: the
+ * first new observation hides every prior one, so an active hold loses its
+ * basis and the detectors restart from zero.
+ *
+ * So: ONE-TIME COPY-FORWARD, MERGED, and never a fallback.
+ *
+ * ⚠️ THE TARGET IS ITS OWN FIRST SOURCE, which is what makes a re-run safe.
+ * The marker is written LAST, so a crash between the rename and the marker
+ * leaves the migration to be redone — and if a spend was appended in between, a
+ * merge that ignored the target would erase it. Reading the target first makes
+ * the whole operation idempotent under any number of crashes.
+ *
+ * ⚠️ AN UNREADABLE SOURCE REFUSES, and the caller fails closed. `ExemptionStore`
+ * already answers "spent" for everything when its own file will not parse,
+ * because treating a corrupt ledger as "nothing spent" re-opens every door the
+ * machine has used. That rule has to survive the move rather than be suspended
+ * for it — a migration that silently skipped a file it could not read would be
+ * the same bypass with a different spelling.
+ *
+ * ⚠️ NOTHING OLD IS EVER DELETED. Route B's premise: a directory nobody can
+ * prove is stale is not a directory looply removes. The old files are left
+ * exactly where they are and never read again.
+ */
+export declare function copyForwardOnce(opts: {
+    dir: string;
+    files: readonly MigrationFile[];
+    dirs?: readonly MigrationDir[];
+    fs: MigrationFs;
+    /** Identifies this process in the token, so a stale token names its owner. */
+    who: string;
+    /** How long to wait for another process's migration. Default 5s. */
+    waitMs?: number;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    /** Judges whether a token's owner is still running. Injected so a test can decide. */
+    probe?: (pid: number) => 'alive' | 'dead' | 'unknown';
+}): Promise<MigrationResult>;
+/**
+ * Every per-checkout state directory this repository has, oldest homes first.
+ *
+ * The project's own, plus one per workspace under the workspaces root. A
+ * migration must find them all: Phase 1 wrote to per-workspace state directories
+ * before it hoisted to the project's, so a machine that ran a Phase-1 build has
+ * spends in places nothing looks at any more.
+ */
+export declare function legacyStateDirs(opts: {
+    projectState: string;
+    workspacesRoot: string;
+    fs: Pick<MigrationFs, 'readDir'>;
+}): Promise<string[]>;
+/** The node-backed filesystem for a migration. */
+export declare const nodeMigrationFs: MigrationFs;
+//# sourceMappingURL=rails-home.d.ts.map

package/dist/rails-home.d.ts.map

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

package/dist/rails-home.js

@@ -0,0 +1,452 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeMigrationFs = void 0;
+exports.railsDir = railsDir;
+exports.copyForwardOnce = copyForwardOnce;
+exports.legacyStateDirs = legacyStateDirs;
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const trusted_git_1 = require("./trusted-git");
+/**
+ * WHERE THE RAILS LEDGERS LIVE, AND WHY IT IS NOT IN THE REPOSITORY.
+ *
+ * Two files decide whether a rail is shut: the exemption spend ledger (has this
+ * single-use grant been used?) and the loop-safety history (is this goal held?).
+ * Phase 1 moved both from the per-checkout state directory to the PROJECT state
+ * directory, which is what stopped N workspaces giving one grant N spends. That
+ * was the urgent half.
+ *
+ * 🔴 THE REMAINING HALF: THE PROJECT STATE DIRECTORY IS INSIDE THE REPOSITORY.
+ *
+ * For an ordinary checkout `projectStateDir` is `<repo>/.looply/state`. So the
+ * record of every single-use grant this machine has already spent sits in a
+ * directory that:
+ *
+ *   - `discard()` deliberately preserves (`-e .looply`) but a person's own
+ *     `git clean -xfd` does not,
+ *   - a re-clone does not carry, because `.looply/state` is not tracked,
+ *   - and `rm -rf` on a finished checkout takes with it.
+ *
+ * Every one of those turns a spent single-use exemption back into an unspent
+ * one. Not by an attack — by ordinary housekeeping. A rail whose "already used"
+ * record a person can delete without knowing they did is not a rail.
+ *
+ * ⚠️ THE PRECEDENT IS ALREADY IN THIS CODEBASE. `projectStateDir` itself falls
+ * back to `~/.looply/projects/<key>/state` for a repository with no main
+ * worktree, with the note that "`~/.looply` is where this codebase already puts
+ * state that must survive the repository". That is the argument, and it applies
+ * to the rails ledgers of EVERY repository, not only the bare ones.
+ *
+ * ⚠️ AND IT IS KEYED THE SAME WAY EVERYTHING ELSE IS. `repoIdentityPath` is what
+ * `workspacesRoot` hashes and what the registry agrees on: the main worktree
+ * root, or the common dir for a bare repository, or the directory itself.
+ * Ordinary checkouts and linked worktrees of one repository therefore share one
+ * key, which is the entire point.
+ */
+function railsDir(cwd, home = (0, node_os_1.homedir)()) {
+    const root = (0, trusted_git_1.repoIdentityPath)(cwd);
+    const key = (0, node_crypto_1.createHash)('sha256').update(root.toLowerCase(), 'utf8').digest('hex').slice(0, 16);
+    return (0, node_path_1.join)(home, '.looply', 'projects', key, 'rails');
+}
+/**
+ * MOVE A LEDGER FORWARD ONCE, MERGED, UNDER AN EXCLUSIVE CREATE.
+ *
+ * 🔴 "READ THE OLD PATH WHEN THE NEW ONE IS ABSENT" IS NOT A MIGRATION. IT IS
+ * THE BYPASS.
+ *
+ * That was the first design and it is worth stating why it fails, because it
+ * reads as the conservative option. The old file records that grant `g` was
+ * spent. The first UNRELATED spend after the move creates the new file. From
+ * that moment the new file is present, the fallback stops firing, the old
+ * file's record of `g` is invisible — and `g`, a single-use grant over a railed
+ * path, is spendable a second time. The relocation would re-open exactly the
+ * rail it was done to protect.
+ *
+ * The loop-safety history has the same shape with a milder consequence: the
+ * first new observation hides every prior one, so an active hold loses its
+ * basis and the detectors restart from zero.
+ *
+ * So: ONE-TIME COPY-FORWARD, MERGED, and never a fallback.
+ *
+ * ⚠️ THE TARGET IS ITS OWN FIRST SOURCE, which is what makes a re-run safe.
+ * The marker is written LAST, so a crash between the rename and the marker
+ * leaves the migration to be redone — and if a spend was appended in between, a
+ * merge that ignored the target would erase it. Reading the target first makes
+ * the whole operation idempotent under any number of crashes.
+ *
+ * ⚠️ AN UNREADABLE SOURCE REFUSES, and the caller fails closed. `ExemptionStore`
+ * already answers "spent" for everything when its own file will not parse,
+ * because treating a corrupt ledger as "nothing spent" re-opens every door the
+ * machine has used. That rule has to survive the move rather than be suspended
+ * for it — a migration that silently skipped a file it could not read would be
+ * the same bypass with a different spelling.
+ *
+ * ⚠️ NOTHING OLD IS EVER DELETED. Route B's premise: a directory nobody can
+ * prove is stale is not a directory looply removes. The old files are left
+ * exactly where they are and never read again.
+ */
+async function copyForwardOnce(opts) {
+    const { dir, files, fs } = opts;
+    const now = opts.now ?? (() => Date.now());
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const waitMs = opts.waitMs ?? 5_000;
+    /**
+     * 🔴 ONE MARKER PER LEDGER, AND A SHARED ONE WAS A TOTAL BYPASS.
+     *
+     * This was `migrated.json`, and `move()` computes the same `dir` for both the
+     * exemption ledger and the safety history. Whichever migrated FIRST wrote the
+     * marker; the second then saw `done()` and returned `{ok: true, migrated:
+     * false}` having copied nothing at all.
+     *
+     * MEASURED, and the order is deterministic rather than a race: `runLoop`
+     * opens the safety store near its top and the exemption store two thousand
+     * lines later, so on every machine it was the EXEMPTION ledger that was
+     * skipped. `ExemptionStore.open()` then read an empty directory, reported
+     * `ok`, and answered `isSpent` FALSE for every grant the machine had ever
+     * spent — a single-use grant over a railed path, spendable again, on every
+     * repository on that machine. The precise bypass this file's header says the
+     * copy-forward exists to prevent, reintroduced by a filename.
+     *
+     * ⚠️ AND IT FAILED THE OTHER WAY TOO. A safety migration that REFUSED wrote
+     * no marker, correctly — and the exemption migration that ran later in the
+     * same command wrote one, marking the refused migration permanently done. A
+     * live hold was then discharged for ever, silently, with its incidents left
+     * in a file nothing would read again.
+     */
+    const marker = (0, node_path_1.join)(dir, `migrated.${opts.who}.json`);
+    const token = (0, node_path_1.join)(dir, `.migrating.${opts.who}`);
+    const done = async () => (await fs.readFile(marker)) !== null;
+    if (await done())
+        return { ok: true, migrated: false, read: [] };
+    await fs.mkdir(dir);
+    const mine = JSON.stringify({ pid: process.pid, at: new Date(now()).toISOString(), who: opts.who });
+    try {
+        await fs.createExclusive(token, `${mine}\n`);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        /**
+         * 🔴 THE LOSER WAITS AND RE-READS. It does NOT migrate in parallel.
+         *
+         * Two processes merging the same sources into the same target is not merely
+         * wasteful: the second rename lands on a file the first may have appended
+         * to since, so a spend written between the two is lost. Waiting costs a
+         * second on one machine, once, ever.
+         */
+        const until = now() + waitMs;
+        while (now() < until) {
+            await sleep(50);
+            if (await done())
+                return { ok: true, migrated: false, read: [] };
+        }
+        /**
+         * 🔴 A TOKEN WHOSE OWNER IS GONE IS BROKEN, NOT OBEYED — AND WITHOUT THIS
+         * EVERY RUN ON THIS MACHINE WAS BRICKED FOR EVER BY ONE Ctrl-C.
+         *
+         * MEASURED: with a token left behind and no marker, three consecutive opens
+         * each stalled the full 5s and each answered `unreadable`. Nothing aged the
+         * token out, nothing probed the pid it names, and no `looply` command could
+         * clear it — so `looply daemon` said "autonomy will hold" for ever, every
+         * hand-typed run paid ten seconds of dead wall clock and then skipped the
+         * hold fence entirely, and no granted exemption could be used again. The
+         * remedy was deleting a dot-file under `~/.looply` that nothing tells a
+         * person about, and the refusal it printed — "try again in a moment" — was
+         * false in a way that guaranteed nobody would look.
+         *
+         * ⚠️ SAME DISCIPLINE PHASE 1 SETTLED ON FOR ITS OWN TOKENS: probe the pid,
+         * and break the token only by CONTENT MATCH. Re-reading before removing is
+         * what stops this deleting a token a live process took in the moment we
+         * were deciding — the failure Phase 1 measured when it removed one by path.
+         */
+        /**
+         * ⚠️ GUARDED, LIKE ITS SIBLING FOUR LINES BELOW. An unreadable token used to
+         * throw straight out of `open()` — which both stores document as something
+         * that cannot happen.
+         */
+        const holder = await fs.readFile(token).catch(() => null);
+        const owner = ownerOf(holder);
+        /**
+         * 🔴 A TOKEN THAT NAMES NOBODY IS BREAKABLE, AND THE FIRST VERSION OF THIS
+         * REPAIR ONLY BROKE ONES THAT PARSED.
+         *
+         * MEASURED: a ZERO-BYTE token — exactly what a Ctrl-C or a power cut leaves
+         * between `open(path,'wx')` and the write, which is the very interrupt this
+         * was written for — made `ownerOf` answer null, `liveness` answer
+         * `'unknown'`, and the token be obeyed for ever. Three consecutive opens,
+         * five seconds of dead wall clock each, `unreadable` each, token intact
+         * each. Every test the repair added planted a well-formed token; none
+         * planted a malformed one.
+         *
+         * ⚠️ AND BREAKING IT IS SAFE PRECISELY BECAUSE IT NAMES NOBODY. A token
+         * whose owner cannot be identified protects nobody: no process can be
+         * pointed at, so no process can be harmed. What is NOT broken is a token
+         * naming a pid this cannot judge — that one may well be alive.
+         */
+        const liveness = owner === null ? (holder === null ? 'dead' : 'ownerless') : (opts.probe ?? nodeMigrationProbe)(owner);
+        if (liveness === 'dead' || liveness === 'ownerless') {
+            const still = await fs.readFile(token).catch(() => null);
+            if (still === holder) {
+                await fs.unlink(token).catch(() => undefined);
+                return {
+                    ok: false,
+                    because: `the last attempt to move this ledger was interrupted (${owner === null ? 'its claim named no process' : `pid ${owner} is gone`}). ` +
+                        'Its claim has been cleared — run the same command again and it will finish.',
+                };
+            }
+        }
+        return {
+            ok: false,
+            because: 'another process is moving this ledger to its machine-level home and has not finished. ' +
+                `Nothing is lost; try again in a moment. If this persists, delete ${token}.`,
+        };
+    }
+    try {
+        const read = [];
+        const outputs = [];
+        for (const file of files) {
+            const target = (0, node_path_1.join)(dir, file.name);
+            const parts = [];
+            // The target FIRST, so a re-run after a crash keeps anything appended since.
+            const current = await fs.readFile(target).catch((e) => {
+                throw e;
+            });
+            if (current !== null)
+                parts.push({ path: target, text: current });
+            for (const source of file.sources) {
+                let text;
+                try {
+                    text = await fs.readFile(source);
+                }
+                catch (e) {
+                    return {
+                        ok: false,
+                        because: `${source} exists and could not be read (${e.message}), so this machine ` +
+                            'cannot prove what it has already spent. Refusing to migrate rather than ' +
+                            'moving forward without it.',
+                    };
+                }
+                if (text === null)
+                    continue;
+                read.push(source);
+                parts.push({ path: source, text });
+            }
+            /**
+             * ⚠️ A MERGE MAY REFUSE, AND A REFUSAL IS NOT AN ERROR TO SWALLOW.
+             *
+             * "Exists and cannot be read" covers an I/O failure. It does not cover a
+             * file that reads perfectly and does not PARSE — and that is the shape
+             * `ExemptionStore` already fails closed on, because a corrupt ledger
+             * treated as "nothing spent" re-opens every door the machine has used. A
+             * merge that quietly skipped an unparseable source would be that bypass
+             * with a different spelling, so a merge throws and this refuses.
+             */
+            try {
+                outputs.push({ name: file.name, text: file.merge(parts) });
+            }
+            catch (e) {
+                return {
+                    ok: false,
+                    because: `${file.name} could not be built from what is already on disk ` +
+                        `(${e.message}). Refusing to migrate rather than moving forward without it.`,
+                };
+            }
+        }
+        for (const out of outputs) {
+            const staging = (0, node_path_1.join)(dir, `${out.name}.migrating`);
+            await fs.writeFile(staging, out.text);
+            await fs.rename(staging, (0, node_path_1.join)(dir, out.name));
+        }
+        /**
+         * ⚠️ DIRECTORIES AFTER FILES, AND EACH ENTRY BY EXCLUSIVE CREATE.
+         *
+         * These carry claims — "this retry was taken" — so an entry already at the
+         * target is the truth and a copy must lose to it, not replace it. EEXIST is
+         * therefore the ordinary outcome on a re-run, not an error.
+         */
+        for (const d of opts.dirs ?? []) {
+            const target = (0, node_path_1.join)(dir, d.name);
+            let made = false;
+            for (const source of d.sources) {
+                const names = await fs.readDir(source);
+                if (names === null)
+                    continue;
+                for (const name of names) {
+                    let text;
+                    try {
+                        text = await fs.readFile((0, node_path_1.join)(source, name));
+                    }
+                    catch (e) {
+                        return {
+                            ok: false,
+                            because: `${(0, node_path_1.join)(source, name)} exists and could not be read (${e.message}), so this ` +
+                                'machine cannot prove which retries have already been spent. Refusing to migrate.',
+                        };
+                    }
+                    if (text === null)
+                        continue;
+                    if (!made) {
+                        await fs.mkdir(target);
+                        made = true;
+                    }
+                    read.push((0, node_path_1.join)(source, name));
+                    try {
+                        await fs.createExclusive((0, node_path_1.join)(target, name), text);
+                    }
+                    catch (e) {
+                        if (e.code !== 'EEXIST')
+                            throw e;
+                    }
+                }
+            }
+        }
+        // LAST. Before this line the migration is repeatable; after it, it is done.
+        await fs.writeFile(marker, `${JSON.stringify({ at: new Date(now()).toISOString(), read, files: files.map((f) => f.name) }, null, 2)}\n`);
+        return { ok: true, migrated: true, read };
+    }
+    finally {
+        /**
+         * ⚠️ ONLY IF IT IS STILL OURS. Phase 1 measured what happens when a token is
+         * removed by path rather than by identity: a process that had already lost
+         * its claim deleted the winner's, and four processes then held one lock.
+         */
+        try {
+            const held = await fs.readFile(token);
+            if (held !== null && held.trim() === mine)
+                await fs.unlink(token);
+        }
+        catch {
+            /* someone else's, or already gone */
+        }
+    }
+}
+/**
+ * Every per-checkout state directory this repository has, oldest homes first.
+ *
+ * The project's own, plus one per workspace under the workspaces root. A
+ * migration must find them all: Phase 1 wrote to per-workspace state directories
+ * before it hoisted to the project's, so a machine that ran a Phase-1 build has
+ * spends in places nothing looks at any more.
+ */
+async function legacyStateDirs(opts) {
+    const out = [opts.projectState];
+    for (const name of (await opts.fs.readDir(opts.workspacesRoot)) ?? []) {
+        const dir = (0, node_path_1.join)(opts.workspacesRoot, name, '.looply', 'state');
+        if (dir !== opts.projectState)
+            out.push(dir);
+    }
+    return out;
+}
+/** The pid a migration token names, or null when it names none this can read. */
+function ownerOf(token) {
+    if (token === null)
+        return null;
+    try {
+        const pid = JSON.parse(token).pid;
+        return typeof pid === 'number' && Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Is that process still running?
+ *
+ * ⚠️ THREE-VALUED, AND `unknown` IS NOT `dead`. `kill(pid, 0)` answers ESRCH for
+ * a pid nobody owns and EPERM for one this user may not signal — and EPERM means
+ * the process EXISTS. Reading it as dead would break a live token.
+ */
+function nodeMigrationProbe(pid) {
+    try {
+        process.kill(pid, 0);
+        return 'alive';
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 'ESRCH')
+            return 'dead';
+        if (code === 'EPERM')
+            return 'alive';
+        return 'unknown';
+    }
+}
+/** The node-backed filesystem for a migration. */
+exports.nodeMigrationFs = {
+    readFile: async (path) => {
+        const { readFile } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        try {
+            return await readFile(path, 'utf8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    },
+    writeFile: async (path, data) => {
+        const { writeFile } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        await writeFile(path, data, 'utf8');
+    },
+    rename: async (from, to) => {
+        const { rename } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        await rename(from, to);
+    },
+    mkdir: async (path) => {
+        const { mkdir } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        await mkdir(path, { recursive: true });
+    },
+    createExclusive: async (path, data) => {
+        const { writeFile } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        await writeFile(path, data, { encoding: 'utf8', flag: 'wx' });
+    },
+    readDir: async (path) => {
+        const { readdir } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        try {
+            return await readdir(path);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    },
+    unlink: async (path) => {
+        const { unlink } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        await unlink(path);
+    },
+};
+//# sourceMappingURL=rails-home.js.map

package/dist/rails-home.js.map

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