@petepetrash/circuit 0.1.0

package/dist/runtime/fanout/branch-expansion.js

@@ -0,0 +1,64 @@
+import { FanoutBranch as FanoutBranchSchema } from '../../schemas/step.js';
+import { expandTemplate, resolveDottedPath } from '../../shared/fanout-branch-template.js';
+import { resolveRuntimeNumberSource } from '../../shared/runtime-source.js';
+function resolveBranch(branch) {
+    if ('flow_ref' in branch) {
+        return {
+            kind: 'sub-run',
+            branch_id: branch.branch_id,
+            flowRef: branch.flow_ref.flow_id,
+            entryMode: branch.flow_ref.entry_mode,
+            ...(branch.flow_ref.version === undefined ? {} : { version: branch.flow_ref.version }),
+            goal: branch.goal,
+            depth: branch.depth,
+            ...(branch.selection === undefined ? {} : { selection: branch.selection }),
+        };
+    }
+    return {
+        kind: 'relay',
+        branch_id: branch.branch_id,
+        role: branch.execution.role,
+        goal: branch.execution.goal,
+        report_schema: branch.execution.report_schema,
+        ...(branch.execution.provenance_field === undefined
+            ? {}
+            : { provenance_field: branch.execution.provenance_field }),
+        ...(branch.connector === undefined ? {} : { connector: branch.connector }),
+        ...(branch.selection === undefined ? {} : { selection: branch.selection }),
+    };
+}
+export async function expandFanoutBranches(step, files, context) {
+    const branches = step.branches;
+    if (branches.kind === 'static') {
+        return branches.branches.map((branch) => resolveBranch(FanoutBranchSchema.parse(branch)));
+    }
+    const sourceRaw = await files.readJson(branches.source_report);
+    const items = resolveDottedPath(sourceRaw, branches.items_path);
+    if (!Array.isArray(items)) {
+        throw new Error(`dynamic fanout: items_path '${branches.items_path}' did not resolve to an array (got ${typeof items})`);
+    }
+    const maxBranches = typeof branches.max_branches === 'number'
+        ? branches.max_branches
+        : resolveRuntimeNumberSource(branches.max_branches, context?.axes);
+    if (branches.required_count !== undefined) {
+        const expected = resolveRuntimeNumberSource(branches.required_count, context?.axes);
+        if (items.length !== expected) {
+            throw new Error(`dynamic fanout expected ${expected} items from '${branches.items_path}' but found ${items.length}`);
+        }
+    }
+    if (items.length > maxBranches) {
+        throw new Error(`dynamic fanout expanded to ${items.length} items but max_branches is ${maxBranches}`);
+    }
+    const seen = new Set();
+    const resolved = [];
+    for (const item of items) {
+        const branch = FanoutBranchSchema.parse(expandTemplate(branches.template, item));
+        if (seen.has(branch.branch_id)) {
+            throw new Error(`dynamic fanout produced duplicate branch_id '${branch.branch_id}'`);
+        }
+        seen.add(branch.branch_id);
+        resolved.push(resolveBranch(branch));
+    }
+    return resolved;
+}
+//# sourceMappingURL=branch-expansion.js.map

package/dist/runtime/fanout/branch-expansion.js.map

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

package/dist/runtime/fanout/run-owner-lock.d.ts

@@ -0,0 +1,28 @@
+/** Whether a process id is currently alive. Injected so tests stay hermetic. */
+export type ProcessAliveCheck = (pid: number) => boolean;
+/** Absolute path to a run's owner lock under the worktrees root. */
+export declare function ownerLockPath(worktreesRoot: string, runId: string): string;
+/**
+ * Record the current process as the owner of `runId`'s worktrees. Synchronous
+ * so the lock is durable before any worktree is added (a live process always
+ * has its lock present by the time a worktree exists on disk). Best-effort: a
+ * write failure must not abort the fanout it guards.
+ */
+export declare function writeOwnerLock(worktreesRoot: string, runId: string, startedAt: string): void;
+/** Remove a run's owner lock. Best-effort and idempotent (missing is fine). */
+export declare function removeOwnerLock(worktreesRoot: string, runId: string): void;
+/**
+ * Default liveness check: `process.kill(pid, 0)` signals nothing but probes
+ * existence. ESRCH means the process is gone; EPERM means it exists but we may
+ * not signal it (still alive). Any other outcome is treated as alive — the
+ * fail-safe direction, since the cost of a false "alive" is a kept orphan
+ * (reclaimable later) while a false "dead" destroys live work.
+ */
+export declare const defaultProcessAlive: ProcessAliveCheck;
+/**
+ * True when `runId` has an owner lock whose recorded pid is still alive. A
+ * missing or unparseable lock is NOT proof of life, so it returns false and the
+ * reaper falls back to classifying the run from its trace.
+ */
+export declare function isRunLiveByOwnerLock(worktreesRoot: string, runId: string, processAlive?: ProcessAliveCheck): boolean;
+//# sourceMappingURL=run-owner-lock.d.ts.map

package/dist/runtime/fanout/run-owner-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-owner-lock.d.ts","sourceRoot":"","sources":["../../../src/runtime/fanout/run-owner-lock.ts"],"names":[],"mappings":"AAgCA,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAEzD,oEAAoE;AACpE,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAU5F;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAO1E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,iBAQjC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,YAAY,GAAE,iBAAuC,GACpD,OAAO,CAeT"}

package/dist/runtime/fanout/run-owner-lock.js

@@ -0,0 +1,98 @@
+// Run owner lock — a liveness signal for the worktree reaper.
+//
+// The reaper's hard problem: a run that is *still running* mid-fanout leaves a
+// trace that is byte-for-byte the same shape as a run that crashed between
+// checkpoints (a `run.bootstrapped`, a `fanout.started`, and nothing closing —
+// no `run.closed`, no parked `checkpoint.requested`). The trace alone cannot
+// tell "running now" from "crashed", so reaping on the trace verdict alone
+// would force-remove a live run's worktree and destroy its uncommitted work.
+//
+// The fix is an out-of-band liveness signal. While a fanout step holds
+// worktrees, the owning process writes this lock next to them, recording its
+// own pid. A live process's pid stays alive; a SIGKILL leaves the lock behind
+// with a pid that is no longer running. The reaper keeps any worktree whose
+// owner pid is still alive and only considers the trace verdict once the owner
+// is provably gone. This also gives self-exclusion for free: a process never
+// reaps a run whose owner — possibly itself — is still alive.
+//
+// The lock lives at `<worktreesRoot>/<runId>/.owner.json`, a sibling of the
+// per-step worktree directories. The reaper's directory walk only descends into
+// subdirectories, so the lock file is never mistaken for a step directory.
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const OWNER_LOCK_FILENAME = '.owner.json';
+/** Absolute path to a run's owner lock under the worktrees root. */
+export function ownerLockPath(worktreesRoot, runId) {
+    return join(worktreesRoot, runId, OWNER_LOCK_FILENAME);
+}
+/**
+ * Record the current process as the owner of `runId`'s worktrees. Synchronous
+ * so the lock is durable before any worktree is added (a live process always
+ * has its lock present by the time a worktree exists on disk). Best-effort: a
+ * write failure must not abort the fanout it guards.
+ */
+export function writeOwnerLock(worktreesRoot, runId, startedAt) {
+    const lock = { schema_version: 1, pid: process.pid, started_at: startedAt };
+    try {
+        mkdirSync(join(worktreesRoot, runId), { recursive: true });
+        writeFileSync(ownerLockPath(worktreesRoot, runId), JSON.stringify(lock), 'utf8');
+    }
+    catch {
+        // The lock is an optimization, not a correctness requirement on the write
+        // side: a missing lock simply makes the reaper fall back to the trace
+        // verdict. Never let a lock-write failure break the run it guards.
+    }
+}
+/** Remove a run's owner lock. Best-effort and idempotent (missing is fine). */
+export function removeOwnerLock(worktreesRoot, runId) {
+    try {
+        rmSync(ownerLockPath(worktreesRoot, runId), { force: true });
+    }
+    catch {
+        // A leftover lock is harmless: it points at a dead pid, so the reaper still
+        // treats the run as not-live. Swallow so cleanup never throws.
+    }
+}
+/**
+ * Default liveness check: `process.kill(pid, 0)` signals nothing but probes
+ * existence. ESRCH means the process is gone; EPERM means it exists but we may
+ * not signal it (still alive). Any other outcome is treated as alive — the
+ * fail-safe direction, since the cost of a false "alive" is a kept orphan
+ * (reclaimable later) while a false "dead" destroys live work.
+ */
+export const defaultProcessAlive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+};
+/**
+ * True when `runId` has an owner lock whose recorded pid is still alive. A
+ * missing or unparseable lock is NOT proof of life, so it returns false and the
+ * reaper falls back to classifying the run from its trace.
+ */
+export function isRunLiveByOwnerLock(worktreesRoot, runId, processAlive = defaultProcessAlive) {
+    let raw;
+    try {
+        raw = readFileSync(ownerLockPath(worktreesRoot, runId), 'utf8');
+    }
+    catch {
+        return false;
+    }
+    let pid;
+    try {
+        pid = JSON.parse(raw).pid;
+    }
+    catch {
+        return false;
+    }
+    if (typeof pid !== 'number')
+        return false;
+    return processAlive(pid);
+}
+//# sourceMappingURL=run-owner-lock.js.map

package/dist/runtime/fanout/run-owner-lock.js.map

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

package/dist/runtime/fanout/types.d.ts

@@ -0,0 +1,38 @@
+import type { FanoutStep } from '../../schemas/step.js';
+import type { RunClosedOutcome } from '../domain/run.js';
+export { NO_VERDICT_SENTINEL } from '../run/relay-support.js';
+export type FanoutJoinPolicy = FanoutStep['check']['join']['policy'];
+export interface ResolvedSubRunBranch {
+    readonly kind: 'sub-run';
+    readonly branch_id: string;
+    readonly flowRef: string;
+    readonly entryMode: string;
+    readonly version?: string;
+    readonly goal: string;
+    readonly depth: string;
+    readonly selection?: unknown;
+}
+export interface ResolvedRelayBranch {
+    readonly kind: 'relay';
+    readonly branch_id: string;
+    readonly role: string;
+    readonly goal: string;
+    readonly report_schema: string;
+    readonly provenance_field?: string;
+    readonly connector?: string;
+    readonly selection?: unknown;
+}
+export type ResolvedBranch = ResolvedSubRunBranch | ResolvedRelayBranch;
+export interface BranchOutcome {
+    readonly branch_id: string;
+    readonly child_run_id: string;
+    readonly worktree_path: string;
+    readonly child_outcome: RunClosedOutcome;
+    readonly verdict: string;
+    readonly result_path: string;
+    readonly result_body?: unknown;
+    readonly duration_ms: number;
+    readonly admitted: boolean;
+    readonly failure_reason?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/fanout/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/fanout/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAK9D,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;AAErE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAExE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,gBAAgB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC"}

package/dist/runtime/fanout/types.js

@@ -0,0 +1,2 @@
+export { NO_VERDICT_SENTINEL } from '../run/relay-support.js';
+//# sourceMappingURL=types.js.map

package/dist/runtime/fanout/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/fanout/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/runtime/fanout/worktree-reaper.d.ts

@@ -0,0 +1,108 @@
+import type { WorktreeRunner } from '../run/child-runner.js';
+/**
+ * Status of the run that owns a worktree, as the reaper needs to decide.
+ *
+ * - `closed`      — the run finished cleanly (its trace has a `run.closed`
+ *                   entry). Its worktrees are safe to reclaim.
+ * - `dead`        — the run has no `run.closed` and is not parked at an
+ *                   unresolved checkpoint. This is the audit's dead-folder
+ *                   shape: a crash landed between checkpoints, or the run
+ *                   folder is gone entirely. Its worktrees are safe to reclaim.
+ * - `live-parked` — the run is paused at an unresolved operator checkpoint and
+ *                   may still resume forward. Its worktrees must be LEFT ALONE.
+ * - `unknown`     — the owning run's status could not be determined (its trace
+ *                   is unreadable or fails to parse). The reaper cannot prove
+ *                   the run is dead, so it must LEAVE THE WORKTREE ALONE rather
+ *                   than risk destroying a live run's work. Fail safe.
+ *
+ * The reaper removes a worktree only when its owning run is `closed` or `dead`.
+ * Both `live-parked` and `unknown` are kept.
+ */
+export type OwningRunStatus = 'closed' | 'dead' | 'live-parked' | 'unknown';
+/** Resolve the owning run's status from its id. Injected so tests can stub it. */
+export type ResolveRunStatus = (runId: string) => OwningRunStatus | Promise<OwningRunStatus>;
+/**
+ * Whether the run that owns a worktree is still being executed by a live
+ * process. This is the out-of-band liveness gate that the trace cannot provide:
+ * a still-running mid-fanout run and a crashed one have the same trace shape, so
+ * the reaper must keep any worktree whose owner is alive *before* it consults
+ * the trace verdict. Injected so tests can stub it; the default reads the run
+ * owner lock under the worktrees root (see `run-owner-lock.ts`).
+ */
+export type IsRunLive = (runId: string) => boolean | Promise<boolean>;
+/**
+ * Lists the worktree leaf directories under a worktrees root, returning, for
+ * each, the absolute path plus the `runId` that owns it. Injected so tests can
+ * stub the filesystem walk; the default reads the real on-disk layout.
+ */
+export type WorktreeLister = (worktreesRoot: string) => Promise<readonly WorktreeEntry[]>;
+export interface WorktreeEntry {
+    /** Absolute path to the `worktrees/<runId>/<stepId>/<branchId>` directory. */
+    readonly path: string;
+    /** The id of the run that provisioned this worktree. */
+    readonly runId: string;
+}
+export interface ReapWorktreesOptions {
+    /** Absolute path to `<projectRoot>/.circuit/worktrees`. */
+    readonly worktreesRoot: string;
+    /**
+     * Absolute path to the project root (the git repository that owns the
+     * worktrees). Passed to the runner's `remove` as the git working directory so
+     * reclamation targets this repo, not the reaper's process cwd — the case that
+     * breaks when `circuit reclaim --project-root <path>` runs from elsewhere.
+     * Optional: absence falls back to process.cwd().
+     */
+    readonly repoRoot?: string;
+    /** Resolves the owning run's status by run id. */
+    readonly resolveRunStatus: ResolveRunStatus;
+    /**
+     * Whether the owning run is still being executed by a live process. Checked
+     * BEFORE the trace verdict — a live owner's worktree is always kept. Defaults
+     * to the run owner lock under `worktreesRoot`.
+     */
+    readonly isRunLive?: IsRunLive;
+    /** Worktree runner whose `remove` reclaims a worktree. Defaults to git. */
+    readonly worktreeRunner?: WorktreeRunner;
+    /** Lists worktree leaf dirs. Defaults to a real filesystem walk. */
+    readonly listWorktrees?: WorktreeLister;
+}
+export interface ReapWorktreesSummary {
+    /** Worktree paths that were removed. */
+    readonly removed: string[];
+    /** Worktree paths left in place because the owning run is live-parked. */
+    readonly kept: string[];
+    /** Per-worktree failures. The reaper records and continues; it never throws. */
+    readonly errors: {
+        readonly path: string;
+        readonly message: string;
+    }[];
+}
+/**
+ * Default lister: walk `worktrees/<runId>/<stepId>/<branchId>` and return one
+ * entry per branch leaf directory. A missing worktrees root is not an error —
+ * there is simply nothing to reap.
+ */
+export declare const listWorktreesFromDisk: WorktreeLister;
+/**
+ * Resolve a run's status by loading its trace and classifying the ending.
+ *
+ * This mirrors the canonical unresolved-checkpoint logic in
+ * `checkpoint-resume.ts`: a run is live-parked when its trace contains a
+ * `checkpoint.requested` whose `(step_id, attempt)` pair has no matching
+ * `checkpoint.resolved`. A run is closed when its trace has a `run.closed`
+ * entry. An empty or absent run folder is dead (a genuine orphan). A trace
+ * that exists but cannot be parsed is `unknown` — we cannot prove the run is
+ * dead, so the reaper keeps its worktrees rather than risk destroying live
+ * work.
+ *
+ * `runsRoot` is the absolute `<projectRoot>/.circuit/runs` directory.
+ */
+export declare function makeTraceRunStatusResolver(runsRoot: string): ResolveRunStatus;
+/**
+ * Reap orphaned worktrees. For each worktree leaf directory, resolve the owning
+ * run's status; remove the worktree if the run is closed or dead; leave it in
+ * place if the run is live-parked. Every removal is wrapped so a single failure
+ * is recorded and the reaper keeps going. This function never throws.
+ */
+export declare function reapWorktrees(options: ReapWorktreesOptions): Promise<ReapWorktreesSummary>;
+//# sourceMappingURL=worktree-reaper.d.ts.map

package/dist/runtime/fanout/worktree-reaper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-reaper.d.ts","sourceRoot":"","sources":["../../../src/runtime/fanout/worktree-reaper.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAK7D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;AAE5E,kFAAkF;AAClF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAE7F;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC,CAAC;AAE1F,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,oEAAoE;IACpE,QAAQ,CAAC,aAAa,CAAC,EAAE,cAAc,CAAC;CACzC;AAED,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACxE;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAanC,CAAC;AAcF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAiB7E;AAiBD;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqFhG"}

package/dist/runtime/fanout/worktree-reaper.js

@@ -0,0 +1,195 @@
+// Worktree reaper — reclaims per-branch fanout worktrees a crash orphaned.
+//
+// A fanout step provisions one git worktree per branch under
+// `<projectRoot>/.circuit/worktrees/<runId>/<stepId>/<branchId>` and removes
+// them in a `finally` block (`fanout.ts`). A `finally` does not run under
+// SIGKILL, so a process killed mid-fanout leaves those worktrees on disk with
+// nothing to reclaim them. This reaper is the reclaimer: it runs *after* the
+// crash, on a later invocation, walks the deterministic worktree layout, and
+// removes the worktrees whose owning run is closed or dead — while leaving the
+// worktrees of a live, parked run (one waiting at an unresolved operator
+// checkpoint) untouched.
+//
+// The module is pure and fully injectable so it can be tested with a fake
+// worktree runner and a stubbed status reader. The defaults wire it to the real
+// filesystem layout and the real trace store.
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TraceStore } from '../trace/trace-store.js';
+import { isRunLiveByOwnerLock, removeOwnerLock } from './run-owner-lock.js';
+import { gitWorktreeRunner } from './worktree.js';
+/**
+ * Default lister: walk `worktrees/<runId>/<stepId>/<branchId>` and return one
+ * entry per branch leaf directory. A missing worktrees root is not an error —
+ * there is simply nothing to reap.
+ */
+export const listWorktreesFromDisk = async (worktreesRoot) => {
+    const entries = [];
+    const runDirs = await listSubdirectories(worktreesRoot);
+    for (const runId of runDirs) {
+        const stepDirs = await listSubdirectories(join(worktreesRoot, runId));
+        for (const stepId of stepDirs) {
+            const branchDirs = await listSubdirectories(join(worktreesRoot, runId, stepId));
+            for (const branchId of branchDirs) {
+                entries.push({ path: join(worktreesRoot, runId, stepId, branchId), runId });
+            }
+        }
+    }
+    return entries;
+};
+async function listSubdirectories(dir) {
+    try {
+        const dirents = await readdir(dir, { withFileTypes: true });
+        return dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    }
+    catch (error) {
+        // A missing directory means there is nothing to reap; treat any read
+        // failure as "no children" so the reaper stays best-effort.
+        if (error.code === 'ENOENT')
+            return [];
+        return [];
+    }
+}
+/**
+ * Resolve a run's status by loading its trace and classifying the ending.
+ *
+ * This mirrors the canonical unresolved-checkpoint logic in
+ * `checkpoint-resume.ts`: a run is live-parked when its trace contains a
+ * `checkpoint.requested` whose `(step_id, attempt)` pair has no matching
+ * `checkpoint.resolved`. A run is closed when its trace has a `run.closed`
+ * entry. An empty or absent run folder is dead (a genuine orphan). A trace
+ * that exists but cannot be parsed is `unknown` — we cannot prove the run is
+ * dead, so the reaper keeps its worktrees rather than risk destroying live
+ * work.
+ *
+ * `runsRoot` is the absolute `<projectRoot>/.circuit/runs` directory.
+ */
+export function makeTraceRunStatusResolver(runsRoot) {
+    return async (runId) => {
+        let entries;
+        try {
+            const trace = new TraceStore(join(runsRoot, runId));
+            entries = await trace.load();
+        }
+        catch {
+            // The trace exists but is unreadable or fails strict parse. We cannot
+            // classify the run, so we must NOT treat it as removable. Fail safe.
+            return 'unknown';
+        }
+        // An absent or empty run folder is a genuine orphan: its worktrees are
+        // reclaimable. (TraceStore.load returns [] for a missing trace file.)
+        if (entries.length === 0)
+            return 'dead';
+        if (entries.some((entry) => entry.kind === 'run.closed'))
+            return 'closed';
+        return hasUnresolvedCheckpoint(entries) ? 'live-parked' : 'dead';
+    };
+}
+function hasUnresolvedCheckpoint(entries) {
+    const resolved = new Set();
+    for (const entry of entries) {
+        if (entry.kind !== 'checkpoint.resolved')
+            continue;
+        if (entry.step_id === undefined || entry.attempt === undefined)
+            continue;
+        resolved.add(`${entry.step_id}:${entry.attempt}`);
+    }
+    for (const entry of entries) {
+        if (entry.kind !== 'checkpoint.requested')
+            continue;
+        if (entry.step_id === undefined || entry.attempt === undefined)
+            continue;
+        if (!resolved.has(`${entry.step_id}:${entry.attempt}`))
+            return true;
+    }
+    return false;
+}
+/**
+ * Reap orphaned worktrees. For each worktree leaf directory, resolve the owning
+ * run's status; remove the worktree if the run is closed or dead; leave it in
+ * place if the run is live-parked. Every removal is wrapped so a single failure
+ * is recorded and the reaper keeps going. This function never throws.
+ */
+export async function reapWorktrees(options) {
+    const worktreeRunner = options.worktreeRunner ?? gitWorktreeRunner;
+    const listWorktrees = options.listWorktrees ?? listWorktreesFromDisk;
+    const isRunLive = options.isRunLive ?? ((runId) => isRunLiveByOwnerLock(options.worktreesRoot, runId));
+    const summary = { removed: [], kept: [], errors: [] };
+    // Run ids whose worktrees we reaped, so we can drop their now-stale owner
+    // locks once at the end (the lock points at a dead pid by definition here).
+    const reapedRunIds = new Set();
+    let entries;
+    try {
+        entries = await listWorktrees(options.worktreesRoot);
+    }
+    catch (error) {
+        // Listing should not throw, but if a custom lister does, surface it as a
+        // single error against the root rather than crashing the caller.
+        summary.errors.push({
+            path: options.worktreesRoot,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        return summary;
+    }
+    for (const entry of entries) {
+        // Liveness gate first. A run whose owning process is still alive keeps its
+        // worktree no matter what its trace says: a live mid-fanout run and a
+        // crashed one share the same trace shape, so the trace cannot be trusted to
+        // distinguish them. Force-removing a live run's worktree destroys
+        // uncommitted work, so this gate is the reaper's primary safety boundary.
+        let live;
+        try {
+            live = await Promise.resolve(isRunLive(entry.runId));
+        }
+        catch (error) {
+            // If liveness cannot be determined, fail safe: keep the worktree rather
+            // than risk reaping a live run.
+            summary.errors.push({
+                path: entry.path,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        if (live) {
+            summary.kept.push(entry.path);
+            continue;
+        }
+        let status;
+        try {
+            status = await Promise.resolve(options.resolveRunStatus(entry.runId));
+        }
+        catch (error) {
+            summary.errors.push({
+                path: entry.path,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        // Only reclaim a worktree whose owning run is provably finished or dead.
+        // A live-parked run may resume; an unknown run cannot be proven dead. Both
+        // are kept — the reaper never removes a worktree it cannot justify.
+        if (status !== 'closed' && status !== 'dead') {
+            summary.kept.push(entry.path);
+            continue;
+        }
+        try {
+            await Promise.resolve(worktreeRunner.remove(entry.path, options.repoRoot));
+            summary.removed.push(entry.path);
+            reapedRunIds.add(entry.runId);
+        }
+        catch (error) {
+            summary.errors.push({
+                path: entry.path,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Drop owner locks for runs we fully reaped. The owner is provably gone (it
+    // failed the liveness gate), so the lock is stale; removing it keeps the
+    // worktrees root from accruing dead-pid markers across crashes.
+    for (const runId of reapedRunIds) {
+        removeOwnerLock(options.worktreesRoot, runId);
+    }
+    return summary;
+}
+//# sourceMappingURL=worktree-reaper.js.map

package/dist/runtime/fanout/worktree-reaper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-reaper.js","sourceRoot":"","sources":["../../../src/runtime/fanout/worktree-reaper.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,EAAE;AACF,6DAA6D;AAC7D,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,yEAAyE;AACzE,yBAAyB;AACzB,EAAE;AACF,0EAA0E;AAC1E,gFAAgF;AAChF,8CAA8C;AAE9C,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAoFlD;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAmB,KAAK,EAAE,aAAa,EAAE,EAAE;IAC3E,MAAM,OAAO,GAAoB,EAAE,CAAC;IACpC,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,CAAC;IACxD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC;QACtE,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC9B,MAAM,UAAU,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;YAChF,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;gBAClC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YAC9E,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,KAAK,UAAU,kBAAkB,CAAC,GAAW;IAC3C,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvF,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,qEAAqE;QACrE,4DAA4D;QAC5D,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,CAAC;QAClE,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAAgB;IACzD,OAAO,KAAK,EAAE,KAAK,EAAE,EAAE;QACrB,IAAI,OAA8B,CAAC;QACnC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;YACpD,OAAO,GAAG,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;QAC/B,CAAC;QAAC,MAAM,CAAC;YACP,sEAAsE;YACtE,qEAAqE;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,uEAAuE;QACvE,sEAAsE;QACtE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QACxC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC;YAAE,OAAO,QAAQ,CAAC;QAC1E,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAAC,OAA8B;IAC7D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,KAAK,CAAC,IAAI,KAAK,qBAAqB;YAAE,SAAS;QACnD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,SAAS;QACzE,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,KAAK,CAAC,IAAI,KAAK,sBAAsB;YAAE,SAAS;QACpD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,SAAS;QACzE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IACtE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,OAA6B;IAC/D,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,iBAAiB,CAAC;IACnE,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,qBAAqB,CAAC;IACrE,MAAM,SAAS,GACb,OAAO,CAAC,SAAS,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC;IACvF,MAAM,OAAO,GAAyB,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAC5E,0EAA0E;IAC1E,4EAA4E;IAC5E,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEvC,IAAI,OAAiC,CAAC;IACtC,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,yEAAyE;QACzE,iEAAiE;QACjE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;YAClB,IAAI,EAAE,OAAO,CAAC,aAAa;YAC3B,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAChE,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,2EAA2E;QAC3E,sEAAsE;QACtE,4EAA4E;QAC5E,kEAAkE;QAClE,0EAA0E;QAC1E,IAAI,IAAa,CAAC;QAClB,IAAI,CAAC;YACH,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACvD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,wEAAwE;YACxE,gCAAgC;YAChC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;gBAClB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAChE,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9B,SAAS;QACX,CAAC;QAED,IAAI,MAAuB,CAAC;QAC5B,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACxE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;gBAClB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAChE,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,yEAAyE;QACzE,2EAA2E;QAC3E,oEAAoE;QACpE,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YAC7C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9B,SAAS;QACX,CAAC;QAED,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC3E,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;gBAClB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAChE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,4EAA4E;IAC5E,yEAAyE;IACzE,gEAAgE;IAChE,KAAK,MAAM,KAAK,IAAI,YAAY,EAAE,CAAC;QACjC,eAAe,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/runtime/fanout/worktree.d.ts

@@ -0,0 +1,3 @@
+import type { WorktreeRunner } from '../run/child-runner.js';
+export declare const gitWorktreeRunner: WorktreeRunner;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/runtime/fanout/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../../src/runtime/fanout/worktree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,eAAO,MAAM,iBAAiB,EAAE,cA0C/B,CAAC"}

package/dist/runtime/fanout/worktree.js

@@ -0,0 +1,35 @@
+import { spawnSync } from 'node:child_process';
+export const gitWorktreeRunner = {
+    add({ worktreePath, baseRef, branchName, repoRoot }) {
+        // Anchor git at the owning repo (repoRoot) so provisioning targets it and
+        // not the caller's process cwd; fall back to process.cwd() when the caller
+        // supplies no root, matching the changedFiles cwd threading below.
+        const result = spawnSync('git', ['worktree', 'add', '-b', branchName, worktreePath, baseRef], {
+            encoding: 'utf8',
+            ...(repoRoot === undefined ? {} : { cwd: repoRoot }),
+        });
+        if (result.status !== 0) {
+            throw new Error(`git worktree add failed (exit ${result.status ?? 'null'}): ${result.stderr ?? ''}`.trim());
+        }
+    },
+    remove(worktreePath, repoRoot) {
+        const result = spawnSync('git', ['worktree', 'remove', '--force', worktreePath], {
+            encoding: 'utf8',
+            ...(repoRoot === undefined ? {} : { cwd: repoRoot }),
+        });
+        if (result.status !== 0) {
+            throw new Error(`git worktree remove failed (exit ${result.status ?? 'null'}): ${result.stderr ?? ''}`.trim());
+        }
+    },
+    changedFiles(worktreePath, baseRef) {
+        const result = spawnSync('git', ['diff', '--name-only', `${baseRef}..HEAD`], {
+            cwd: worktreePath,
+            encoding: 'utf8',
+        });
+        if (result.status !== 0) {
+            throw new Error(`git diff --name-only failed (exit ${result.status ?? 'null'}): ${result.stderr ?? ''}`.trim());
+        }
+        return (result.stdout ?? '').split('\n').filter((line) => line.length > 0);
+    },
+};
+//# sourceMappingURL=worktree.js.map

package/dist/runtime/fanout/worktree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.js","sourceRoot":"","sources":["../../../src/runtime/fanout/worktree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,MAAM,CAAC,MAAM,iBAAiB,GAAmB;IAC/C,GAAG,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE;QACjD,0EAA0E;QAC1E,2EAA2E;QAC3E,mEAAmE;QACnE,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;YAC5F,QAAQ,EAAE,MAAM;YAChB,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;SACrD,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,iCAAiC,MAAM,CAAC,MAAM,IAAI,MAAM,MAAM,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAC3F,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,CAAC,YAAY,EAAE,QAAQ;QAC3B,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,EAAE;YAC/E,QAAQ,EAAE,MAAM;YAChB,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;SACrD,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,oCAAoC,MAAM,CAAC,MAAM,IAAI,MAAM,MACzD,MAAM,CAAC,MAAM,IAAI,EACnB,EAAE,CAAC,IAAI,EAAE,CACV,CAAC;QACJ,CAAC;IACH,CAAC;IACD,YAAY,CAAC,YAAY,EAAE,OAAO;QAChC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,QAAQ,CAAC,EAAE;YAC3E,GAAG,EAAE,YAAY;YACjB,QAAQ,EAAE,MAAM;SACjB,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,qCAAqC,MAAM,CAAC,MAAM,IAAI,MAAM,MAC1D,MAAM,CAAC,MAAM,IAAI,EACnB,EAAE,CAAC,IAAI,EAAE,CACV,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7E,CAAC;CACF,CAAC"}