@lenne.tech/cli 1.27.0 → 1.28.0

package/build/commands/ticket/stop.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const dev_identity_1 = require("../../lib/dev-identity");
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket stop [<id>]` — tear a ticket env down + remove its worktree.
+ *
+ *   1. `lt dev down` inside the worktree (stops the ticket stack + any test
+ *      stacks, removes the Caddy block — residue-free),
+ *   2. `git worktree remove` (the BRANCH is kept, so nothing is lost),
+ *   3. `--drop-db` also drops the ticket's empty dev + test databases.
+ *
+ * Run with NO id from INSIDE a ticket worktree to clean up THIS environment
+ * (the current folder is removed; the process steps out to the main repo first).
+ */
+const StopCommand = {
+    alias: ['rm'],
+    description: 'Stop a ticket env + remove its worktree (branch kept); no id = the current worktree',
+    name: 'stop',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_f) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: not a git repo';
+        }
+        // Id from the argument — or, when invoked with NO id from INSIDE a ticket
+        // worktree, the current worktree's own ticket (so a bare `lt ticket stop`
+        // cleans up "this" environment and removes this very folder).
+        const fromMarker = parameters.first == null ? (0, dev_ticket_1.readTicketMarker)(layout.root) : null;
+        const id = String((_b = (_a = parameters.first) !== null && _a !== void 0 ? _a : fromMarker) !== null && _b !== void 0 ? _b : '').trim();
+        if (!id) {
+            error('Usage: lt ticket stop <id> [--drop-db] [--force]  — or run with no id from INSIDE a ticket worktree.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: missing id';
+        }
+        const wt = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).find((w) => w.ticket === id);
+        if (!wt) {
+            error(`No ticket worktree "${id}" found. See \`lt ticket list\`.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: not found';
+        }
+        // SAFETY: never silently delete unsaved work. Warn + REFUSE (unless --force)
+        // when the worktree has uncommitted changes OR unpushed commits, so the user
+        // commits + pushes first. (`--force` removes anyway; the branch is kept, so
+        // committed history survives regardless.)
+        const safety = (0, dev_ticket_1.worktreeSafetyReport)(wt.path);
+        if ((safety.dirtySource.length > 0 || safety.unpushed > 0) && parameters.options.force !== true) {
+            warning('');
+            warning(`Refusing to remove ticket "${id}" — work is not fully committed + pushed:`);
+            if (safety.dirtySource.length > 0) {
+                warning(`  • ${safety.dirtySource.length} uncommitted change(s) — would be LOST on removal:`);
+                safety.dirtySource.slice(0, 12).forEach((l) => info(colors.dim(`      ${l}`)));
+                if (safety.dirtySource.length > 12)
+                    info(colors.dim(`      … and ${safety.dirtySource.length - 12} more`));
+            }
+            if (safety.unpushed > 0) {
+                warning(`  • ${safety.unpushed} commit(s) on "${(_c = wt.branch) !== null && _c !== void 0 ? _c : '-'}" not pushed to any remote`);
+            }
+            info('');
+            info(colors.dim('  Commit + push first (the branch is kept), or re-run with --force to remove anyway.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: unsaved work (use --force)';
+        }
+        // If we are removing the worktree we are standing in, step the process out
+        // to the main repo first so git can remove the folder cleanly.
+        const removingCwd = fromMarker !== null || samePath(wt.path, layout.root);
+        if (removingCwd) {
+            try {
+                process.chdir(mainRepoRoot);
+            }
+            catch (_g) {
+                /* best-effort */
+            }
+        }
+        info('');
+        info(colors.bold(`Stopping ticket "${id}"`));
+        // 1. Tear the isolated stack down from inside the worktree (marker-aware).
+        info(colors.dim('  lt dev down …'));
+        yield (0, dev_process_1.runChildInherit)(process.execPath, [process.argv[1], 'dev', 'down'], { cwd: wt.path, env: process.env });
+        // 2. Optionally drop the ticket databases (they are otherwise just left empty).
+        if (parameters.options.dropDb === true || parameters.options['drop-db'] === true) {
+            const base = (0, dev_identity_1.buildIdentity)(mainRepoRoot);
+            const entry = (0, dev_state_1.loadRegistry)().projects[`${base.slug}-${id}`];
+            const mainLayout = (0, dev_project_1.resolveLayout)(mainRepoRoot, filesystem);
+            const devDb = (_d = entry === null || entry === void 0 ? void 0 : entry.dbName) !== null && _d !== void 0 ? _d : (0, dev_project_1.deriveTicketDbName)((0, dev_project_1.deriveDbName)(mainLayout.apiDir, base.slug), id);
+            const testDb = (0, dev_project_1.deriveTestDbName)(devDb);
+            for (const db of [devDb, testDb]) {
+                if ((0, dev_ticket_1.dropDatabase)(db))
+                    info(colors.dim(`  dropped db ${db}`));
+                else
+                    warning(`  could not drop db ${db} (mongosh missing or DB not reachable) — drop it manually if needed.`);
+            }
+        }
+        // 3. Remove the worktree (branch is kept). Auto-force when the ONLY dirty
+        //    files are framework-generated (e.g. `nuxt dev` rewrites the tracked
+        //    `.nuxtrc` on boot), which would otherwise block the remove — but NEVER
+        //    discard real source edits (those keep the non-forced remove, which
+        //    errors with a hint so unsaved work is never lost).
+        const force = parameters.options.force === true || (0, dev_ticket_1.worktreeDirtyOnlyGenerated)(wt.path);
+        if (force && parameters.options.force !== true) {
+            info(colors.dim('  (worktree had only generated files dirty, e.g. .nuxtrc — removing)'));
+        }
+        try {
+            (0, dev_ticket_1.worktreeRemove)(mainRepoRoot, wt.path, force);
+        }
+        catch (e) {
+            error(`git worktree remove failed: ${e.message}`);
+            info(colors.dim('  The worktree has uncommitted SOURCE changes — commit/stash them, or pass --force to discard.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: worktree remove failed';
+        }
+        // The whole env is gone now — drop the ticket's registry entry so its slug +
+        // reserved ports are reclaimed (`lt dev down` only ends the session, keeping
+        // the entry for a restart; `lt ticket stop` removes the env entirely).
+        {
+            const reg = (0, dev_state_1.loadRegistry)();
+            const ticketSlug = `${(0, dev_identity_1.buildIdentity)(mainRepoRoot).slug}-${id}`;
+            if (reg.projects[ticketSlug]) {
+                delete reg.projects[ticketSlug];
+                (0, dev_state_1.saveRegistry)(reg);
+            }
+        }
+        info('');
+        success(`Ticket "${id}" stopped — worktree removed, branch "${(_e = wt.branch) !== null && _e !== void 0 ? _e : '-'}" kept.`);
+        if (removingCwd)
+            info(colors.dim(`  This folder is gone — your shell is still in it. Run: cd ${mainRepoRoot}`));
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket stop: ${id}`;
+    }),
+};
+/** True if two paths point at the same location (resolving symlinks, e.g. /tmp → /private/tmp). */
+function samePath(a, b) {
+    try {
+        return (0, fs_1.realpathSync)(a) === (0, fs_1.realpathSync)(b);
+    }
+    catch (_a) {
+        return a === b;
+    }
+}
+module.exports = StopCommand;

package/build/commands/ticket/switch.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket switch <id>` — show a ticket worktree's path and open it in your
+ * editor (best-effort). A CLI cannot change the parent shell's directory, so it
+ * also prints the `cd` line to copy. `--no-open` only prints.
+ */
+const SwitchCommand = {
+    alias: ['sw', 'open'],
+    description: 'Show a ticket worktree path + open it in your editor',
+    name: 'switch',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info, success }, } = toolbox;
+        const id = String((_a = parameters.first) !== null && _a !== void 0 ? _a : '').trim();
+        if (!id) {
+            error('Usage: lt ticket switch <id>');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: missing id';
+        }
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_b) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: not a git repo';
+        }
+        const wt = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).find((w) => w.ticket === id);
+        if (!wt) {
+            error(`No ticket worktree "${id}" found. See \`lt ticket list\`.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: not found';
+        }
+        info('');
+        info(`Ticket "${id}"  →  ${wt.path}`);
+        info(colors.dim(`  cd ${wt.path}`));
+        if (parameters.options.open !== false) {
+            const editor = process.env.LT_EDITOR || 'code';
+            try {
+                (0, child_process_1.execFileSync)(editor, [wt.path], { stdio: 'ignore' });
+                success(`Opened in ${editor}.`);
+            }
+            catch (_c) {
+                info(colors.dim(`  (could not run \`${editor}\` — open the folder manually, or set LT_EDITOR)`));
+            }
+        }
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket switch: ${id}`;
+    }),
+};
+module.exports = SwitchCommand;

package/build/commands/ticket/test.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket test <id> [--shard N] [-- <args>]` — run the E2E suite for a ticket
+ * in ITS isolated stack + DB, by delegating to `lt dev test` inside the ticket
+ * worktree (which is ticket-aware via the marker → test DB `<base>-<id>-test`).
+ */
+const TestCommand = {
+    alias: ['t'],
+    description: 'Run the E2E suite for a ticket in its isolated stack',
+    name: 'test',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info }, } = toolbox;
+        const id = String((_a = parameters.first) !== null && _a !== void 0 ? _a : '').trim();
+        if (!id) {
+            error('Usage: lt ticket test <id> [--shard N] [--keep] [-- <playwright args>]');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: missing id';
+        }
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_b) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: not a git repo';
+        }
+        const wt = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).find((w) => w.ticket === id);
+        if (!wt) {
+            error(`No ticket worktree "${id}" found. See \`lt ticket list\`.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: not found';
+        }
+        // Reconstruct `lt dev test` args: forward the common flags + the `--` array.
+        const devArgs = ['dev', 'test'];
+        if (parameters.options.shard !== undefined) {
+            const s = parameters.options.shard;
+            devArgs.push(s === true ? '--shard' : `--shard=${s}`);
+        }
+        if (parameters.options.keep === true)
+            devArgs.push('--keep');
+        if (parameters.options.debug === true)
+            devArgs.push('--debug');
+        // Playwright args after `--` (e.g. a spec path / `--grep`): read them from
+        // the RAW argv. gluegun's parsed `parameters.array` does not reliably carry
+        // post-`--` tokens through the `ticket <id>` positional, which silently ran
+        // the WHOLE suite instead of the requested spec.
+        const dashIdx = process.argv.indexOf('--');
+        const forwarded = dashIdx >= 0 ? process.argv.slice(dashIdx + 1) : [];
+        if (forwarded.length > 0)
+            devArgs.push('--', ...forwarded);
+        info(colors.dim(`(cd ${wt.path} && lt ${devArgs.join(' ')})`));
+        const code = yield (0, dev_process_1.runChildInherit)(process.execPath, [process.argv[1], ...devArgs], {
+            cwd: wt.path,
+            env: process.env,
+        });
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(code !== null && code !== void 0 ? code : 1);
+        return `ticket test: ${id} exit=${code}`;
+    }),
+};
+module.exports = TestCommand;

package/build/commands/ticket/ticket.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Parallel ticket dev environments (`lt ticket <subcommand>`).
+ *
+ * Each ticket runs in its OWN git worktree (a fresh branch from `origin/dev`)
+ * with its OWN isolated `lt dev` stack — own URLs, ports, Caddy block and empty
+ * database — so several tickets can be developed, browser-tested and E2E-tested
+ * fully in parallel without ever influencing each other.
+ *
+ * Subcommands:
+ * - `start <name>`  — create the worktree + bring the isolated stack up
+ * - `list`          — dashboard of all ticket envs (URLs, branch, status, DB)
+ * - `switch <id>`   — show + open a ticket worktree in your editor
+ * - `test <id>`     — run the E2E suite in the ticket's isolated stack
+ * - `stop <id>`     — tear the env down + remove the worktree (branch kept)
+ */
+module.exports = {
+    alias: ['tk'],
+    description: 'Parallel ticket dev environments (worktree + isolated lt dev stack)',
+    hidden: false,
+    name: 'ticket',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        yield toolbox.helper.showMenu('ticket');
+        return 'ticket';
+    }),
+};

package/build/lib/dev-identity.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentity = buildIdentity;
 exports.buildTestIdentity = buildTestIdentity;
+exports.buildTicketIdentity = buildTicketIdentity;
 exports.projectSlug = projectSlug;
 exports.slugify = slugify;
 /**
@@ -85,6 +86,23 @@ function buildTestIdentity(base, suffix = '-test') {
     }
     return { root: base.root, slug, subdomains };
 }
+/**
+ * Derive a per-TICKET identity from a base identity (used by `lt ticket` /
+ * `lt dev up --ticket`). Suffixes the slug + every subdomain hostname with the
+ * ticket id, so each ticket worktree runs on its OWN URLs / ports / Caddy block
+ * / DB — fully parallel to and isolated from every other ticket and the base
+ * dev session.
+ *
+ *   svl.localhost      → svl-2200.localhost
+ *   api.svl.localhost  → api.svl-2200.localhost
+ *
+ * Mechanically identical to {@link buildTestIdentity} (a named wrapper for
+ * readability + intent at the call sites). `id` is already a clean slug (see
+ * `deriveTicketId` in dev-ticket.ts).
+ */
+function buildTicketIdentity(base, id) {
+    return buildTestIdentity(base, `-${id}`);
+}
 /**
  * Read the bare project name from package.json (scope stripped).
  * Falls back to directory basename if no package.json or no `name`.

package/build/lib/dev-patches.js

@@ -264,7 +264,7 @@ function patchPlaywrightConfig(file) {
     if (!/const SHARDED\b/.test(after) && /export default defineConfig/.test(after)) {
         const shardConst = '// `lt dev test --shard N` saturates the CPU (N built SSR servers + N Chromium),\n' +
             '// slowing every navigation. Relax timeouts ONLY under that load — the CLI sets\n' +
-            "// LT_DEV_TEST_SHARDS — so serial + CI keep their tight, fast-failing defaults.\n" +
+            '// LT_DEV_TEST_SHARDS — so serial + CI keep their tight, fast-failing defaults.\n' +
             "const SHARDED = Number(process.env.LT_DEV_TEST_SHARDS || '0') > 1;\n\n";
         after = after.replace(/(export default defineConfig)/, `${shardConst}$1`);
         count++;

package/build/lib/dev-project.js

@@ -4,6 +4,7 @@ exports.apiNeedsPortPatch = apiNeedsPortPatch;
 exports.appNeedsPortPatch = appNeedsPortPatch;
 exports.deriveDbName = deriveDbName;
 exports.deriveTestDbName = deriveTestDbName;
+exports.deriveTicketDbName = deriveTicketDbName;
 exports.resolveLayout = resolveLayout;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -68,6 +69,19 @@ function deriveTestDbName(devDbName) {
     const base = devDbName.replace(/-(local|dev)$/i, '');
     return `${base}-test`;
 }
+/**
+ * Derive the per-TICKET database name from the project's dev DB name, so each
+ * ticket worktree reads/writes its OWN database and tickets never collide.
+ *
+ *   svl-sports-system-local + "2200" → svl-sports-system-2200
+ *
+ * The ticket's isolated `lt dev test` stack then derives its test DB from this
+ * via {@link deriveTestDbName} → `svl-sports-system-2200-test`.
+ */
+function deriveTicketDbName(devDbName, ticketId) {
+    const base = devDbName.replace(/-(local|dev)$/i, '');
+    return `${base}-${ticketId}`;
+}
 /**
  * Resolve layout starting from `cwd`. Walks up to find a workspace if
  * cwd is inside `projects/api/` or `projects/app/`.

package/build/lib/dev-state.js

@@ -1,8 +1,18 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paths = exports.TEST_SESSION_FILE = void 0;
 exports.allocateInternalPort = allocateInternalPort;
 exports.clearSession = clearSession;
+exports.detectSlugConflict = detectSlugConflict;
 exports.isPidAlive = isPidAlive;
 exports.isValidPid = isValidPid;
 exports.loadRegistry = loadRegistry;
@@ -10,6 +20,7 @@ exports.loadSession = loadSession;
 exports.saveRegistry = saveRegistry;
 exports.saveSession = saveSession;
 exports.takenInternalPorts = takenInternalPorts;
+exports.withRegistryLock = withRegistryLock;
 /**
  * State persistence for `lt dev`.
  *
@@ -57,6 +68,21 @@ function clearSession(root, sessionFile = SESSION_FILE) {
         }
     }
 }
+/**
+ * Detect when `slug` is registered to a DIFFERENT checkout than `root`. Two
+ * clones of the same project share a package.json "name" → the same slug → the
+ * same Caddy block / internal ports / database, so running both via `lt dev`
+ * collides (and one's `lt dev down` can unroute the other). Returns null when
+ * there is no conflict (no registry entry, or the entry belongs to THIS checkout).
+ */
+function detectSlugConflict(slug, root) {
+    const entry = loadRegistry().projects[slug];
+    if (!(entry === null || entry === void 0 ? void 0 : entry.path) || sameRealPath(entry.path, root))
+        return null;
+    const session = loadSession(entry.path);
+    const otherSessionAlive = !!session && [session.pids.api, session.pids.app].some((p) => typeof p === 'number' && isPidAlive(p));
+    return { otherPath: entry.path, otherSessionAlive };
+}
 /** Check whether a process with the given PID is currently alive. */
 function isPidAlive(pid) {
     if (!isValidPid(pid))
@@ -146,6 +172,76 @@ function takenInternalPorts(reg, excludeSlug) {
     }
     return ports;
 }
+/** True if two paths resolve to the same location (normalising symlinks, e.g. /var → /private/var). */
+function sameRealPath(a, b) {
+    try {
+        return (0, fs_1.realpathSync)(a) === (0, fs_1.realpathSync)(b);
+    }
+    catch (_a) {
+        return a === b;
+    }
+}
+const LOCK_PATH = `${REGISTRY_PATH}.lock`;
+/**
+ * Run `fn` while holding an EXCLUSIVE lock on the registry, so concurrent
+ * `lt dev` invocations — e.g. two parallel `lt dev test` in different ticket
+ * worktrees — cannot read-modify-write the registry, or allocate the SAME
+ * internal ports, at the same time. (Without this, two simultaneous test runs
+ * both read the registry before either saves, both pick the same free ports,
+ * and the second server fails to bind — the port-allocation race.)
+ *
+ * The lock is a single atomically-created lock file (`openSync(..,'wx')`); a
+ * stale lock left by a crashed process (older than `staleMs`) is reclaimed.
+ * Keep `fn` SHORT — allocation + reservation only, NEVER across a build/spawn.
+ */
+function withRegistryLock(fn_1) {
+    return __awaiter(this, arguments, void 0, function* (fn, opts = {}) {
+        var _a, _b;
+        const staleMs = (_a = opts.staleMs) !== null && _a !== void 0 ? _a : 30000;
+        const timeoutMs = (_b = opts.timeoutMs) !== null && _b !== void 0 ? _b : 20000;
+        const start = Date.now();
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(LOCK_PATH), { recursive: true });
+        let fd = null;
+        while (fd === null) {
+            try {
+                fd = (0, fs_1.openSync)(LOCK_PATH, 'wx'); // atomic exclusive create — throws if held
+            }
+            catch (_c) {
+                try {
+                    if (Date.now() - (0, fs_1.statSync)(LOCK_PATH).mtimeMs > staleMs)
+                        (0, fs_1.unlinkSync)(LOCK_PATH); // reclaim a crashed holder
+                }
+                catch (_d) {
+                    /* lock vanished between calls — just retry */
+                }
+                if (Date.now() - start > timeoutMs)
+                    throw new Error(`registry lock busy for >${timeoutMs}ms (${LOCK_PATH})`);
+                yield delay(40 + Math.floor(Math.random() * 60)); // jittered backoff
+            }
+        }
+        try {
+            return yield fn();
+        }
+        finally {
+            try {
+                (0, fs_1.closeSync)(fd);
+            }
+            catch (_e) {
+                /* ignore */
+            }
+            try {
+                (0, fs_1.unlinkSync)(LOCK_PATH);
+            }
+            catch (_f) {
+                /* ignore */
+            }
+        }
+    });
+}
+/** Promise-based delay for the lock retry loop. */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /** Path constants exported for tests + status displays. */
 exports.paths = {
     registry: REGISTRY_PATH,