@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/wake.js

@@ -1,296 +1 @@
-// Time grammar + recurrence evaluation for crons.
-//
-// This is the ONE place that owns cron time logic. Both the CLI surface and the
-// daemon's firing pass import from here, so there is no duplicated cron usage
-// and no surface<->daemon inverted dependency:
-//   - parseWhen / parseCadence  — arm-time grammar (surface)
-//   - nextSlotAfter             — per-tick advance / coalescing (daemon)
-//
-// Design refs: surface-design §4 (grammar), §5 (timezone/DST ruling),
-// design §5.3 + D7 (engine evaluates UTC; the surface bakes the IANA zone
-// into a calendar `recur`). Tick-scale only — no sub-second precision.
-import { CronExpressionParser } from 'cron-parser';
-// Constants
-/** Cadence floor: reject any interval / cron min-spacing below this (AC-N4). */
-export const CADENCE_FLOOR_MS = 60_000;
-const DURATION_UNIT_MS = {
-    s: 1_000,
-    m: 60_000,
-    h: 3_600_000,
-    d: 86_400_000,
-};
-// `<int><unit>` repeated; units s/m/h/d (surface-design §4.1).
-const DURATION_RE = /^\+?(?:\d+[smhd])+$/;
-const DURATION_PART_RE = /(\d+)([smhd])/g;
-// ISO-8601 date-time core (no zone). Captures Y M D h m [s] [ms].
-const ISO_CORE_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,3}))?/;
-// Trailing zone designator: Z | ±HH[:MM] | ±HHMM.
-const ZONE_SUFFIX_RE = /^(Z|[+-]\d{2}(?::?\d{2})?)$/;
-// Cron `@alias` -> 5-field expansion (the engine never stores a bare alias).
-const CRON_ALIASES = {
-    '@yearly': '0 0 1 1 *',
-    '@annually': '0 0 1 1 *',
-    '@monthly': '0 0 1 * *',
-    '@weekly': '0 0 * * 0',
-    '@daily': '0 0 * * *',
-    '@midnight': '0 0 * * *',
-    '@hourly': '0 * * * *',
-};
-// Internal helpers
-function whenError(code, message, received) {
-    return { error: { code, message, received } };
-}
-function cadenceError(code, message, received) {
-    return { error: { code, message, received } };
-}
-/** Total ms for a relative-duration string (`90s`, `10m`, `1h30m`), or null if
- * it is not one. */
-export function parseDurationMs(s) {
-    if (!DURATION_RE.test(s))
-        return null;
-    let total = 0;
-    DURATION_PART_RE.lastIndex = 0;
-    let m;
-    while ((m = DURATION_PART_RE.exec(s)) !== null) {
-        total += Number(m[1]) * DURATION_UNIT_MS[m[2]];
-    }
-    return total;
-}
-/** Host-configured IANA zone (crtr is a single-machine runtime). */
-function hostZone() {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-}
-/** True iff `tz` is a resolvable IANA zone name. */
-function isValidZone(tz) {
-    try {
-        new Intl.DateTimeFormat('en-US', { timeZone: tz });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Offset (ms) of `tz` at the given UTC instant: wall-clock-as-UTC minus instant. */
-function zoneOffsetMs(tz, utcMs) {
-    const dtf = new Intl.DateTimeFormat('en-US', {
-        timeZone: tz,
-        hourCycle: 'h23',
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-    });
-    const parts = {};
-    for (const p of dtf.formatToParts(new Date(utcMs))) {
-        if (p.type !== 'literal')
-            parts[p.type] = p.value;
-    }
-    const asUTC = Date.UTC(Number(parts['year']), Number(parts['month']) - 1, Number(parts['day']), Number(parts['hour']), Number(parts['minute']), Number(parts['second']));
-    return asUTC - utcMs;
-}
-/** Interpret a wall-clock instant in `tz` and return the UTC ms instant. */
-function wallClockToUtc(y, mo, d, h, mi, s, ms, tz) {
-    const guess = Date.UTC(y, mo - 1, d, h, mi, s, ms);
-    const off1 = zoneOffsetMs(tz, guess);
-    let utc = guess - off1;
-    // Second pass settles DST-boundary cases where the offset at the candidate
-    // instant differs from the offset at the naive guess.
-    const off2 = zoneOffsetMs(tz, utc);
-    if (off2 !== off1)
-        utc = guess - off2;
-    return utc;
-}
-/** Classify a string as a zoned/bare ISO date-time, or null if it is neither. */
-function classifyIso(s) {
-    const m = ISO_CORE_RE.exec(s);
-    if (!m || m.index !== 0)
-        return null;
-    const rest = s.slice(m[0].length);
-    if (rest === '') {
-        return {
-            zoned: false,
-            y: Number(m[1]),
-            mo: Number(m[2]),
-            d: Number(m[3]),
-            h: Number(m[4]),
-            mi: Number(m[5]),
-            s: m[6] ? Number(m[6]) : 0,
-            ms: m[7] ? Number(m[7].padEnd(3, '0')) : 0,
-        };
-    }
-    if (ZONE_SUFFIX_RE.test(rest))
-        return { zoned: true };
-    return null; // trailing garbage -> not a valid ISO instant
-}
-// parseWhen — resolve a one-shot <when> to an absolute UTC instant
-/**
- * Resolve a `<when>` to a single UTC `fireAt`:
- *   - relative duration (`90s`, `1h30m`)        -> now + Σ
- *   - absolute zoned ISO (`…Z` / `±HH:MM`)       -> that exact instant
- *   - absolute bare ISO (`2026-06-07T09:00`)     -> wall clock in `tz`
- *                                                   (default host-local) -> UTC
- *
- * A bare wall-clock time is interpreted in `opts.tz` when given, else the host
- * zone, and frozen to a UTC instant (DST never re-enters a one-shot). A
- * resolved instant not strictly in the future is rejected (`wake_in_past`).
- */
-export function parseWhen(when, opts) {
-    const received = when;
-    const raw = when.trim();
-    const nowMs = opts.now.getTime();
-    // 1. relative duration
-    const durMs = parseDurationMs(raw);
-    if (durMs !== null) {
-        const fireMs = nowMs + durMs;
-        if (fireMs <= nowMs) {
-            return whenError('wake_in_past', `That resolves to now or the past. Use a positive future duration (e.g. "5m", "2h").`, received);
-        }
-        return { fireAt: new Date(fireMs).toISOString() };
-    }
-    // 2/3. absolute ISO (zoned or bare)
-    const iso = classifyIso(raw);
-    if (iso) {
-        let fireMs;
-        if (iso.zoned) {
-            const d = new Date(raw);
-            if (Number.isNaN(d.getTime())) {
-                return whenError('bad_when', `Not a valid ISO-8601 instant: "${received}".`, received);
-            }
-            fireMs = d.getTime();
-        }
-        else {
-            const tz = opts.tz ?? hostZone();
-            if (!isValidZone(tz)) {
-                return whenError('unknown_zone', `Unknown time zone: "${tz}". Use an IANA name (e.g. "America/New_York").`, opts.tz ?? tz);
-            }
-            fireMs = wallClockToUtc(iso.y, iso.mo, iso.d, iso.h, iso.mi, iso.s, iso.ms, tz);
-            if (Number.isNaN(fireMs)) {
-                return whenError('bad_when', `Not a valid date-time: "${received}".`, received);
-            }
-        }
-        if (fireMs <= nowMs) {
-            return whenError('wake_in_past', `That time is now or in the past. Pick a future instant.`, received);
-        }
-        return { fireAt: new Date(fireMs).toISOString() };
-    }
-    return whenError('bad_when', `Could not parse "${received}". Use a duration ("5m", "1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00").`, received);
-}
-// parseCadence — resolve --every to a stored recur + first fire
-/**
- * Resolve a `<cadence>` (the `--every` value) to a stored `recur` JSON string
- * plus the first `fireAt`:
- *   - fixed interval (a duration)  -> {"every":"<dur>"},   first = now + interval
- *   - calendar cron / @alias       -> {"cron":"<5-field>","tz":"<iana>"},
- *                                     first = next match strictly after now
- *
- * Aliases (`@daily`) are expanded to a 5-field cron before baking, and the
- * IANA zone (from `opts.tz`, else host-local) is baked in so the engine stays a
- * pure UTC evaluator (design D7). Rejects sub-floor spacing (`cadence_too_fast`,
- * < 60s — for both intervals and seconds-granular crons), ungrammatical input
- * (`bad_cadence`), and unknown zones (`unknown_zone`).
- */
-export function parseCadence(every, opts) {
-    const received = every;
-    const raw = every.trim();
-    const nowMs = opts.now.getTime();
-    // 1. fixed interval
-    const durMs = parseDurationMs(raw);
-    if (durMs !== null) {
-        if (durMs < CADENCE_FLOOR_MS) {
-            return cadenceError('cadence_too_fast', `Interval too fast: minimum cadence is 60s. Use a longer --every (e.g. "1m", "5m", "1h").`, received);
-        }
-        return {
-            recur: JSON.stringify({ every: raw }),
-            firstFireAt: new Date(nowMs + durMs).toISOString(),
-        };
-    }
-    // 2. calendar cron / alias
-    const expanded = CRON_ALIASES[raw] ?? raw;
-    const tz = opts.tz ?? hostZone();
-    if (opts.tz !== undefined && !isValidZone(opts.tz)) {
-        return cadenceError('unknown_zone', `Unknown time zone: "${opts.tz}". Use an IANA name (e.g. "America/New_York").`, opts.tz);
-    }
-    let interval;
-    let firstFireAt;
-    try {
-        interval = CronExpressionParser.parse(expanded, { currentDate: opts.now, tz });
-        firstFireAt = interval.next().toDate().toISOString();
-    }
-    catch {
-        return cadenceError('bad_cadence', `Could not parse cadence "${received}". Use a duration ("6h"), a 5-field cron ("0 9 * * *"), or an @alias ("@daily").`, received);
-    }
-    // Cadence floor: a 5-field cron is always >=60s; only a seconds-granular cron
-    // (multiple values in the seconds field) can resolve below the floor.
-    const secField = interval.fields?.second;
-    const secValues = secField && Array.isArray(secField.values) ? secField.values : [0];
-    if (secValues.length > 1) {
-        return cadenceError('cadence_too_fast', `Cron resolves below the 60s floor (sub-minute spacing). Use a cadence of at least one minute.`, received);
-    }
-    return {
-        recur: JSON.stringify({ cron: expanded, tz }),
-        firstFireAt,
-    };
-}
-// cadenceDisplay — a recur JSON rendered for humans + agents
-/**
- * Render a stored `recur` JSON as a compact, human-readable cadence:
- *   - {"every":"6h"}                         -> `every 6h`
- *   - {"cron":"0 9 * * *","tz":"America/…"}  -> ``cron `0 9 * * *` (America/…)``
- *   - null / undefined / unparseable         -> `none`
- *
- * The ONE cadence-display helper, shared by the cron CLI surface and the
- * <crtr-wake> wake-provenance block (bearings.ts), so the cadence an agent
- * reads in its wake block matches `crtr cron` exactly. Cadence only — never an
- * instance count.
- */
-export function cadenceDisplay(recur) {
-    if (recur === null || recur === undefined)
-        return 'none';
-    try {
-        const r = JSON.parse(recur);
-        if (typeof r.every === 'string')
-            return `every ${r.every}`;
-        if (typeof r.cron === 'string') {
-            return `cron \`${r.cron}\`${typeof r.tz === 'string' ? ` (${r.tz})` : ''}`;
-        }
-    }
-    catch {
-        /* fall through */
-    }
-    return 'none';
-}
-// nextSlotAfter — the coalescing primitive (daemon advance)
-/**
- * Earliest occurrence of `recur` strictly greater than `now`, as a UTC ISO
- * string. Anchors on `now` (not the stored `fire_at`), so it structurally
- * coalesces every slot missed while the daemon was down (design §5.3, AC-E2).
- * DST-correct because the IANA zone is baked into a calendar `recur`.
- *
- * parseCadence validates the cadence at arm time, so a throw here is a rare
- * backstop (a corrupted/foreign row) — T4 must quarantine such a row, never
- * re-query it each tick.
- */
-export function nextSlotAfter(recur, now) {
-    let parsed;
-    try {
-        parsed = JSON.parse(recur);
-    }
-    catch {
-        throw new Error(`nextSlotAfter: malformed recur JSON: ${recur}`);
-    }
-    if (typeof parsed.every === 'string') {
-        const ms = parseDurationMs(parsed.every);
-        if (ms === null || ms <= 0) {
-            throw new Error(`nextSlotAfter: invalid interval recur: ${recur}`);
-        }
-        return new Date(now.getTime() + ms).toISOString();
-    }
-    if (typeof parsed.cron === 'string') {
-        const tz = typeof parsed.tz === 'string' ? parsed.tz : 'UTC';
-        const interval = CronExpressionParser.parse(parsed.cron, { currentDate: now, tz });
-        return interval.next().toDate().toISOString(); // strictly after `now`
-    }
-    throw new Error(`nextSlotAfter: recur has neither 'every' nor 'cron': ${recur}`);
-}
+var p=Object.defineProperty;var s=(n,e)=>p(n,"name",{value:e,configurable:!0});import{CronExpressionParser as N}from"cron-parser";const T=6e4,O={s:1e3,m:6e4,h:36e5,d:864e5},v=/^\+?(?:\d+[smhd])+$/,w=/(\d+)([smhd])/g,I=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,3}))?/,b=/^(Z|[+-]\d{2}(?::?\d{2})?)$/,A={"@yearly":"0 0 1 1 *","@annually":"0 0 1 1 *","@monthly":"0 0 1 * *","@weekly":"0 0 * * 0","@daily":"0 0 * * *","@midnight":"0 0 * * *","@hourly":"0 * * * *"};function f(n,e,t){return{error:{code:n,message:e,received:t}}}s(f,"whenError");function m(n,e,t){return{error:{code:n,message:e,received:t}}}s(m,"cadenceError");function y(n){if(!v.test(n))return null;let e=0;w.lastIndex=0;let t;for(;(t=w.exec(n))!==null;)e+=Number(t[1])*O[t[2]];return e}s(y,"parseDurationMs");function g(){return Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC"}s(g,"hostZone");function _(n){try{return new Intl.DateTimeFormat("en-US",{timeZone:n}),!0}catch{return!1}}s(_,"isValidZone");function S(n,e){const t=new Intl.DateTimeFormat("en-US",{timeZone:n,hourCycle:"h23",year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit"}),r={};for(const u of t.formatToParts(new Date(e)))u.type!=="literal"&&(r[u.type]=u.value);return Date.UTC(Number(r.year),Number(r.month)-1,Number(r.day),Number(r.hour),Number(r.minute),Number(r.second))-e}s(S,"zoneOffsetMs");function U(n,e,t,r,c,u,i,a){const o=Date.UTC(n,e-1,t,r,c,u,i),d=S(a,o);let l=o-d;const h=S(a,l);return h!==d&&(l=o-h),l}s(U,"wallClockToUtc");function z(n){const e=I.exec(n);if(!e||e.index!==0)return null;const t=n.slice(e[0].length);return t===""?{zoned:!1,y:Number(e[1]),mo:Number(e[2]),d:Number(e[3]),h:Number(e[4]),mi:Number(e[5]),s:e[6]?Number(e[6]):0,ms:e[7]?Number(e[7].padEnd(3,"0")):0}:b.test(t)?{zoned:!0}:null}s(z,"classifyIso");function C(n,e){const t=n,r=n.trim(),c=e.now.getTime(),u=y(r);if(u!==null){const a=c+u;return a<=c?f("wake_in_past",'That resolves to now or the past. Use a positive future duration (e.g. "5m", "2h").',t):{fireAt:new Date(a).toISOString()}}const i=z(r);if(i){let a;if(i.zoned){const o=new Date(r);if(Number.isNaN(o.getTime()))return f("bad_when",`Not a valid ISO-8601 instant: "${t}".`,t);a=o.getTime()}else{const o=e.tz??g();if(!_(o))return f("unknown_zone",`Unknown time zone: "${o}". Use an IANA name (e.g. "America/New_York").`,e.tz??o);if(a=U(i.y,i.mo,i.d,i.h,i.mi,i.s,i.ms,o),Number.isNaN(a))return f("bad_when",`Not a valid date-time: "${t}".`,t)}return a<=c?f("wake_in_past","That time is now or in the past. Pick a future instant.",t):{fireAt:new Date(a).toISOString()}}return f("bad_when",`Could not parse "${t}". Use a duration ("5m", "1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00").`,t)}s(C,"parseWhen");function E(n,e){const t=n,r=n.trim(),c=e.now.getTime(),u=y(r);if(u!==null)return u<T?m("cadence_too_fast",'Interval too fast: minimum cadence is 60s. Use a longer --every (e.g. "1m", "5m", "1h").',t):{recur:JSON.stringify({every:r}),firstFireAt:new Date(c+u).toISOString()};const i=A[r]??r,a=e.tz??g();if(e.tz!==void 0&&!_(e.tz))return m("unknown_zone",`Unknown time zone: "${e.tz}". Use an IANA name (e.g. "America/New_York").`,e.tz);let o,d;try{o=N.parse(i,{currentDate:e.now,tz:a}),d=o.next().toDate().toISOString()}catch{return m("bad_cadence",`Could not parse cadence "${t}". Use a duration ("6h"), a 5-field cron ("0 9 * * *"), or an @alias ("@daily").`,t)}const l=o.fields?.second;return(l&&Array.isArray(l.values)?l.values:[0]).length>1?m("cadence_too_fast","Cron resolves below the 60s floor (sub-minute spacing). Use a cadence of at least one minute.",t):{recur:JSON.stringify({cron:i,tz:a}),firstFireAt:d}}s(E,"parseCadence");function $(n){if(n==null)return"none";try{const e=JSON.parse(n);if(typeof e.every=="string")return`every ${e.every}`;if(typeof e.cron=="string")return`cron \`${e.cron}\`${typeof e.tz=="string"?` (${e.tz})`:""}`}catch{}return"none"}s($,"cadenceDisplay");function k(n,e){let t;try{t=JSON.parse(n)}catch{throw new Error(`nextSlotAfter: malformed recur JSON: ${n}`)}if(typeof t.every=="string"){const r=y(t.every);if(r===null||r<=0)throw new Error(`nextSlotAfter: invalid interval recur: ${n}`);return new Date(e.getTime()+r).toISOString()}if(typeof t.cron=="string"){const r=typeof t.tz=="string"?t.tz:"UTC";return N.parse(t.cron,{currentDate:e,tz:r}).next().toDate().toISOString()}throw new Error(`nextSlotAfter: recur has neither 'every' nor 'cron': ${n}`)}s(k,"nextSlotAfter");export{T as CADENCE_FLOOR_MS,$ as cadenceDisplay,k as nextSlotAfter,E as parseCadence,y as parseDurationMs,C as parseWhen};

package/dist/core/worktree-close.js

@@ -1,228 +1,6 @@
-import { existsSync, realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { getNode, recordDisposalGrant, recordLandIntent } from './canvas/index.js';
-import { withExclusiveDirectoryLockAsync } from './exclusive-lock.js';
-import { gitAsync } from './git.js';
-import { proveBranchContained } from './worktree-containment.js';
-import { concludeAbsentManagedWorktreeAsync } from './worktree-mutation-async.js';
-import { parseStatusPorcelain, planLandIntoCheckout } from './worktree-landing.js';
-import { WORKTREE_LOCK_WAIT_MS, checkoutPathForBranchInList, missingWorktreeRecoveryHint, persistClosedWorktreeState, samePath, worktreeLockPathForCommonDir, WorktreeError } from './worktree.js';
-import { shellQuote } from '../shared/shell-quote.js';
-function detailOf(result) {
-    return (result.stderr.trim() || result.stdout.trim()).trim();
-}
-async function runGit(cwd, args, code, next) {
-    const result = await gitAsync(args, cwd);
-    if (result.status !== 0)
-        throw new WorktreeError(code, `git ${args.join(' ')} failed`, next, detailOf(result));
-    return result.stdout.trim();
-}
-async function commonGitDir(cwd) {
-    const output = await runGit(cwd, ['rev-parse', '--git-common-dir'], 'git_common_dir_failed', 'Inspect the repository git metadata, then retry.');
-    return realpathSync(resolve(cwd, output));
-}
-async function resolveLandableBase(cwd, baseRef) {
-    const ref = `refs/heads/${baseRef}`;
-    const exists = await gitAsync(['show-ref', '--verify', '--quiet', ref], cwd);
-    if (exists.status === 1 && exists.executionFailed !== true) {
-        throw new WorktreeError('missing_base_branch', `managed worktree base '${baseRef}' does not name an existing local branch`, 'The base must be a local branch that landing can fast-forward — freshen your local branch from origin first (rebase-not-merge), then base on it.');
-    }
-    if (exists.status !== 0) {
-        const execution = exists.processError === undefined ? '' : `\nprocess error: ${exists.processError}`;
-        throw new WorktreeError('base_branch_inspection_failed', `could not inspect local base branch '${baseRef}' (git show-ref exited with status ${exists.status})`, 'Inspect the repository and its Git metadata, then retry.', `status: ${exists.status}\nstderr: ${exists.stderr.trim() || '<empty>'}${execution}`);
-    }
-    return runGit(cwd, ['rev-parse', '--verify', ref], 'base_branch_resolve_failed', 'Inspect the local base branch, then retry.');
-}
-async function rebaseInProgress(cwd) {
-    for (const path of ['rebase-merge', 'rebase-apply']) {
-        const gitPath = await runGit(cwd, ['rev-parse', '--git-path', path], 'git_path_failed', 'Inspect the worktree manually, then retry.');
-        if (existsSync(gitPath))
-            return true;
-    }
-    return false;
-}
-async function registeredWorktree(cwd, path, branch) {
-    const list = await gitAsync(['worktree', 'list', '--porcelain'], cwd);
-    if (list.status !== 0)
-        return false;
-    let current = null;
-    for (const line of list.stdout.split('\n')) {
-        if (line.startsWith('worktree '))
-            current = line.slice('worktree '.length).trim();
-        else if (current !== null && samePath(current, path) && line === `branch refs/heads/${branch}`)
-            return true;
-    }
-    return false;
-}
-function deferredCleanupResult(wt) {
-    return {
-        worktree_removed: false,
-        worktree_remove_error: `cleanup pending: the caller checkout at ${wt.path} remains intact. After its node exits, run \`git -C ${shellQuote(wt.repo_root)} worktree remove ${shellQuote(wt.path)}\` after confirming it is safe to delete.`,
-        branch_deleted: false,
-        branch_delete_error: `cleanup pending: local branch ${wt.branch} remains checked out at ${wt.path}; delete it only after that checkout is removed and its landed commit is still contained in ${wt.base_ref}.`,
-    };
-}
-function recordBlockedLandIntent(nodeId, blocked) {
-    const current = getNode(nodeId)?.managed_worktree;
-    if (current === undefined || current === null || current.state !== 'open')
-        return;
-    recordLandIntent(nodeId, { at: new Date().toISOString(), blocked });
-}
-async function dropStashIfStillTip(cwd, stashSha) {
-    const tip = await gitAsync(['rev-parse', '--verify', '--quiet', 'refs/stash'], cwd);
-    if (tip.status === 0 && tip.stdout.trim() === stashSha)
-        await gitAsync(['stash', 'drop'], cwd);
-}
-async function landIntoBaseCheckout(baseCheckout, branch, baseSha, landedSha) {
-    const status = await gitAsync(['status', '--porcelain'], baseCheckout);
-    if (status.status !== 0)
-        return { ok: false, detail: detailOf(status) };
-    const diff = await gitAsync(['diff', '--name-only', baseSha, landedSha], baseCheckout);
-    if (diff.status !== 0)
-        return { ok: false, detail: detailOf(diff) };
-    const incoming = diff.stdout.split('\n').map((line) => line.trim()).filter((line) => line !== '');
-    const plan = planLandIntoCheckout(parseStatusPorcelain(status.stdout), incoming);
-    if (plan.kind === 'refuse')
-        return { ok: false, detail: `untracked files in ${baseCheckout} would be overwritten by the incoming commits: ${plan.collisions.join(', ')}` };
-    const merge = async () => {
-        const result = await gitAsync(['merge', '--ff-only', landedSha], baseCheckout);
-        return result.status === 0 ? { ok: true } : { ok: false, detail: detailOf(result) };
-    };
-    if (plan.kind === 'direct')
-        return merge();
-    const before = await gitAsync(['rev-parse', '--verify', '--quiet', 'refs/stash'], baseCheckout);
-    const beforeSha = before.status === 0 ? before.stdout.trim() : null;
-    const pushed = await gitAsync(['stash', 'push', '--message', `crtr landing ${branch}`], baseCheckout);
-    if (pushed.status !== 0)
-        return { ok: false, detail: detailOf(pushed) };
-    const after = await gitAsync(['rev-parse', '--verify', '--quiet', 'refs/stash'], baseCheckout);
-    const stashSha = after.status === 0 ? after.stdout.trim() : null;
-    if (stashSha === null || stashSha === beforeSha)
-        return merge();
-    const recovery = `local changes from ${baseCheckout} are retained in stash ${stashSha}; recover them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve any conflict.`;
-    const landed = await merge();
-    if (!landed.ok) {
-        if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
-            await dropStashIfStillTip(baseCheckout, stashSha);
-            return landed;
-        }
-        return { ok: false, detail: `${landed.detail}\n${recovery}` };
-    }
-    if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
-        await dropStashIfStillTip(baseCheckout, stashSha);
-        return { ok: true };
-    }
-    await gitAsync(['reset', '--hard', landedSha], baseCheckout);
-    return { ok: true, stash: `the shared base checkout was reset to landed commit ${landedSha} because local changes conflicted with it. ${recovery}` };
-}
-async function closeLocked(nodeId) {
-    const node = getNode(nodeId);
-    if (node === null)
-        throw new WorktreeError('unknown_node', `unknown node: ${nodeId}`, 'Run this from a live node, or pass a real node id once that command supports it.');
-    const wt = node?.managed_worktree?.state === 'open' ? node.managed_worktree : null;
-    if (wt === null)
-        throw new WorktreeError('no_managed_worktree', `node ${nodeId} has no open managed worktree`, 'Nothing to close for this node.');
-    if (!existsSync(wt.path))
-        throw new WorktreeError('worktree_missing', `managed worktree path is missing: ${wt.path}`, missingWorktreeRecoveryHint(wt));
-    if (await rebaseInProgress(wt.path))
-        throw new WorktreeError('rebase_in_progress', 'this managed worktree is mid-rebase', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`);
-    const status = await runGit(wt.path, ['status', '--porcelain'], 'status_failed', 'Inspect the worktree manually, then retry.');
-    if (status !== '')
-        throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `Commit the work in ${wt.path}, then rerun \`crtr node worktree close\`.`);
-    const branch = await runGit(wt.path, ['rev-parse', '--abbrev-ref', 'HEAD'], 'branch_check_failed', 'Inspect the worktree manually, then retry.');
-    const head = await runGit(wt.path, ['rev-parse', 'HEAD'], 'landed_sha_failed', 'Inspect the worktree checkout manually, then rerun `crtr node worktree close`.');
-    if (branch !== wt.branch) {
-        const recorded = await gitAsync(['show-ref', '--verify', '--quiet', `refs/heads/${wt.branch}`], wt.path);
-        if (recorded.status === 0 || branch === 'HEAD' || !(await registeredWorktree(wt.repo_root, wt.path, branch))) {
-            throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${wt.branch}, found ${branch === 'HEAD' ? 'detached HEAD' : branch})`, `Inspect ${wt.path}, then rerun \`crtr node worktree close\`.`);
-        }
-        if (await proveBranchContained(wt.path, wt, head) === null) {
-            throw new WorktreeError('branch_moved_unlanded', `managed worktree's recorded branch ${wt.branch} no longer exists; its checkout is now on ${branch} at ${head}, which carries content local base branch '${wt.base_ref}' does not yet contain`, `Land or push ${branch} through its own workflow before closing.`);
-        }
-        const commonDir = await commonGitDir(wt.path);
-        if (!(await registeredWorktree(wt.repo_root, wt.path, branch)) || (await runGit(wt.path, ['rev-parse', '--abbrev-ref', 'HEAD'], 'branch_check_failed', 'Inspect the worktree manually, then retry.')) !== branch || (await runGit(wt.path, ['rev-parse', 'HEAD'], 'branch_check_failed', 'Inspect the worktree manually, then retry.')) !== head) {
-            throw new WorktreeError('wrong_branch', `managed worktree at ${wt.path} changed while closing`, `Inspect ${wt.path}, then rerun \`crtr node worktree close\`.`);
-        }
-        recordDisposalGrant(nodeId, { observed_branch: branch, observed_sha: head, common_dir: commonDir, authorized: new Date().toISOString() });
-        persistClosedWorktreeState(nodeId, wt, 'pending');
-        return { node_id: nodeId, branch, worktree_path: wt.path, landed_sha: head, ...deferredCleanupResult(wt), branch_delete_error: `${branch} is not a crtr-managed branch and will never be deleted automatically; it is preserved once the checkout above is removed.` };
-    }
-    // Decide whether landing remains before resolving a destination. A diverged
-    // local base cannot replay history that the recorded upstream already has.
-    if (await proveBranchContained(wt.path, wt, head) !== null) {
-        persistClosedWorktreeState(nodeId, wt, 'pending');
-        return { node_id: nodeId, branch: wt.branch, worktree_path: wt.path, landed_sha: head, ...deferredCleanupResult(wt) };
-    }
-    let baseSha;
-    try {
-        baseSha = await resolveLandableBase(wt.path, wt.base_ref);
-    }
-    catch (error) {
-        if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch' || head !== wt.base_sha)
-            throw error;
-        persistClosedWorktreeState(nodeId, wt, 'pending');
-        return { node_id: nodeId, branch: wt.branch, worktree_path: wt.path, landed_sha: wt.base_sha, ...deferredCleanupResult(wt) };
-    }
-    const rebase = await gitAsync(['rebase', baseSha], wt.path);
-    if (rebase.status !== 0)
-        throw new WorktreeError('rebase_failed', `rebase onto local base branch '${wt.base_ref}' did not complete`, `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`, detailOf(rebase));
-    const landedSha = await runGit(wt.path, ['rev-parse', 'HEAD'], 'landed_sha_failed', 'Inspect the worktree checkout manually, then rerun `crtr node worktree close`.');
-    const blocked = (message, next, detail) => {
-        recordBlockedLandIntent(nodeId, message);
-        return new WorktreeError('land_base_failed', message, next, detail);
-    };
-    const fastForward = await gitAsync(['merge-base', '--is-ancestor', baseSha, landedSha], wt.path);
-    if (fastForward.status !== 0)
-        throw blocked(`rebased worktree is not a fast-forward of local base branch '${wt.base_ref}'`, 'Ask the user how to land this managed worktree.', detailOf(fastForward));
-    const list = await runGit(wt.path, ['worktree', 'list', '--porcelain'], 'worktree_list_failed', 'Inspect the repository worktrees manually, then retry.');
-    const baseCheckout = checkoutPathForBranchInList(list, wt.base_ref);
-    let stashNote;
-    if (baseCheckout !== null) {
-        const checkoutHead = await gitAsync(['rev-parse', 'HEAD'], baseCheckout);
-        if (checkoutHead.status !== 0 || checkoutHead.stdout.trim() !== baseSha)
-            throw blocked(`local base branch '${wt.base_ref}' changed while this worktree was closing`, `Reconcile the base checkout at ${baseCheckout}, then rerun \`crtr node worktree close\`.`, checkoutHead.status !== 0 ? detailOf(checkoutHead) : `expected ${baseSha}, found ${checkoutHead.stdout.trim()}`);
-        const landed = await landIntoBaseCheckout(baseCheckout, wt.branch, baseSha, landedSha);
-        if (!landed.ok)
-            throw blocked(`could not fast-forward local base branch '${wt.base_ref}' to this worktree`, `Local base branch '${wt.base_ref}' is checked out at ${baseCheckout} in a state that blocks a fast-forward.`, landed.detail);
-        stashNote = landed.stash;
-    }
-    else {
-        const update = await gitAsync(['update-ref', `refs/heads/${wt.base_ref}`, landedSha, baseSha], wt.path);
-        if (update.status !== 0)
-            throw blocked(`could not fast-forward local base branch '${wt.base_ref}' to this worktree`, 'Ask the user how to land this managed worktree.', detailOf(update));
-    }
-    persistClosedWorktreeState(nodeId, wt, 'pending');
-    return { node_id: nodeId, branch: wt.branch, worktree_path: wt.path, landed_sha: landedSha, ...deferredCleanupResult(wt), ...(stashNote === undefined ? {} : { base_checkout_stash: stashNote }) };
-}
-/** Async daemon executor for explicit close. The lock wait and every Git
- * subprocess yield to the daemon event loop. */
-export async function closeManagedWorktreeAsync(nodeId) {
-    const wt = getNode(nodeId)?.managed_worktree;
-    if (wt === undefined || wt === null || wt.state !== 'open')
-        return closeLocked(nodeId);
-    if (!existsSync(wt.path)) {
-        const conclusion = await concludeAbsentManagedWorktreeAsync(nodeId);
-        if (conclusion !== null) {
-            return {
-                node_id: nodeId,
-                branch: conclusion.dropped.branch,
-                worktree_path: conclusion.dropped.worktree_path,
-                landed_sha: conclusion.landedSha,
-                worktree_removed: true,
-                branch_deleted: conclusion.dropped.branch_deleted,
-                ...(conclusion.dropped.branch_delete_error === undefined ? {} : { branch_delete_error: conclusion.dropped.branch_delete_error }),
-            };
-        }
-    }
-    const current = getNode(nodeId)?.managed_worktree;
-    if (current === undefined || current === null || current.state !== 'open')
-        return closeLocked(nodeId);
-    const cwd = existsSync(current.path) ? current.path : current.repo_root;
-    const commonDir = await commonGitDir(cwd);
-    return withExclusiveDirectoryLockAsync(worktreeLockPathForCommonDir(commonDir), () => closeLocked(nodeId), {
-        // Leave room for the API handler to serialize the typed refusal before its
-        // 30s client socket deadline.
-        timeoutMs: Math.min(WORKTREE_LOCK_WAIT_MS, 25_000),
-        timeoutError: () => new WorktreeError('worktree_lock_timeout', `timed out waiting to create a managed worktree in ${commonDir}`, 'Wait for the other managed-worktree operation to finish, then retry.'),
-    });
-}
+var P=Object.defineProperty;var c=(t,r)=>P(t,"name",{value:r,configurable:!0});import{existsSync as $,realpathSync as R}from"node:fs";import{resolve as q}from"node:path";import{getNode as v,recordDisposalGrant as B,recordLandIntent as M}from"./canvas/index.js";import{withExclusiveDirectoryLockAsync as O}from"./exclusive-lock.js";import{gitAsync as i}from"./git.js";import{proveBranchContained as x}from"./worktree-containment.js";import{concludeAbsentManagedWorktreeAsync as F}from"./worktree-mutation-async.js";import{parseStatusPorcelain as G,planLandIntoCheckout as I}from"./worktree-landing.js";import{WORKTREE_LOCK_WAIT_MS as T,checkoutPathForBranchInList as N,missingWorktreeRecoveryHint as j,persistClosedWorktreeState as A,samePath as K,worktreeLockPathForCommonDir as z,WorktreeError as h}from"./worktree.js";import{shellQuote as E}from"../shared/shell-quote.js";function p(t){return(t.stderr.trim()||t.stdout.trim()).trim()}c(p,"detailOf");async function u(t,r,e,o){const a=await i(r,t);if(a.status!==0)throw new h(e,`git ${r.join(" ")} failed`,o,p(a));return a.stdout.trim()}c(u,"runGit");async function H(t){const r=await u(t,["rev-parse","--git-common-dir"],"git_common_dir_failed","Inspect the repository git metadata, then retry.");return R(q(t,r))}c(H,"commonGitDir");async function Q(t,r){const e=`refs/heads/${r}`,o=await i(["show-ref","--verify","--quiet",e],t);if(o.status===1&&o.executionFailed!==!0)throw new h("missing_base_branch",`managed worktree base '${r}' does not name an existing local branch`,"The base must be a local branch that landing can fast-forward \u2014 freshen your local branch from origin first (rebase-not-merge), then base on it.");if(o.status!==0){const a=o.processError===void 0?"":`
+process error: ${o.processError}`;throw new h("base_branch_inspection_failed",`could not inspect local base branch '${r}' (git show-ref exited with status ${o.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${o.status}
+stderr: ${o.stderr.trim()||"<empty>"}${a}`)}return u(t,["rev-parse","--verify",e],"base_branch_resolve_failed","Inspect the local base branch, then retry.")}c(Q,"resolveLandableBase");async function J(t){for(const r of["rebase-merge","rebase-apply"]){const e=await u(t,["rev-parse","--git-path",r],"git_path_failed","Inspect the worktree manually, then retry.");if($(e))return!0}return!1}c(J,"rebaseInProgress");async function L(t,r,e){const o=await i(["worktree","list","--porcelain"],t);if(o.status!==0)return!1;let a=null;for(const n of o.stdout.split(`
+`))if(n.startsWith("worktree "))a=n.slice(9).trim();else if(a!==null&&K(a,r)&&n===`branch refs/heads/${e}`)return!0;return!1}c(L,"registeredWorktree");function D(t){return{worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${t.path} remains intact. After its node exits, run \`git -C ${E(t.repo_root)} worktree remove ${E(t.path)}\` after confirming it is safe to delete.`,branch_deleted:!1,branch_delete_error:`cleanup pending: local branch ${t.branch} remains checked out at ${t.path}; delete it only after that checkout is removed and its landed commit is still contained in ${t.base_ref}.`}}c(D,"deferredCleanupResult");function U(t,r){const e=v(t)?.managed_worktree;e==null||e.state!=="open"||M(t,{at:new Date().toISOString(),blocked:r})}c(U,"recordBlockedLandIntent");async function W(t,r){const e=await i(["rev-parse","--verify","--quiet","refs/stash"],t);e.status===0&&e.stdout.trim()===r&&await i(["stash","drop"],t)}c(W,"dropStashIfStillTip");async function V(t,r,e,o){const a=await i(["status","--porcelain"],t);if(a.status!==0)return{ok:!1,detail:p(a)};const n=await i(["diff","--name-only",e,o],t);if(n.status!==0)return{ok:!1,detail:p(n)};const f=n.stdout.split(`
+`).map(_=>_.trim()).filter(_=>_!==""),k=I(G(a.stdout),f);if(k.kind==="refuse")return{ok:!1,detail:`untracked files in ${t} would be overwritten by the incoming commits: ${k.collisions.join(", ")}`};const w=c(async()=>{const _=await i(["merge","--ff-only",o],t);return _.status===0?{ok:!0}:{ok:!1,detail:p(_)}},"merge");if(k.kind==="direct")return w();const b=await i(["rev-parse","--verify","--quiet","refs/stash"],t),g=b.status===0?b.stdout.trim():null,y=await i(["stash","push","--message",`crtr landing ${r}`],t);if(y.status!==0)return{ok:!1,detail:p(y)};const m=await i(["rev-parse","--verify","--quiet","refs/stash"],t),l=m.status===0?m.stdout.trim():null;if(l===null||l===g)return w();const s=`local changes from ${t} are retained in stash ${l}; recover them with \`git -C ${E(t)} stash apply ${l}\` and resolve any conflict.`,d=await w();return d.ok?(await i(["stash","apply",l],t)).status===0?(await W(t,l),{ok:!0}):(await i(["reset","--hard",o],t),{ok:!0,stash:`the shared base checkout was reset to landed commit ${o} because local changes conflicted with it. ${s}`}):(await i(["stash","apply",l],t)).status===0?(await W(t,l),d):{ok:!1,detail:`${d.detail}
+${s}`}}c(V,"landIntoBaseCheckout");async function S(t){const r=v(t);if(r===null)throw new h("unknown_node",`unknown node: ${t}`,"Run this from a live node, or pass a real node id once that command supports it.");const e=r?.managed_worktree?.state==="open"?r.managed_worktree:null;if(e===null)throw new h("no_managed_worktree",`node ${t} has no open managed worktree`,"Nothing to close for this node.");if(!$(e.path))throw new h("worktree_missing",`managed worktree path is missing: ${e.path}`,j(e));if(await J(e.path))throw new h("rebase_in_progress","this managed worktree is mid-rebase",`Resolve conflicts in ${e.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`);if(await u(e.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.")!=="")throw new h("dirty_worktree","managed worktree has uncommitted changes",`Commit the work in ${e.path}, then rerun \`crtr node worktree close\`.`);const a=await u(e.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry."),n=await u(e.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`.");if(a!==e.branch){if((await i(["show-ref","--verify","--quiet",`refs/heads/${e.branch}`],e.path)).status===0||a==="HEAD"||!await L(e.repo_root,e.path,a))throw new h("wrong_branch",`managed worktree is not on its recorded branch (expected ${e.branch}, found ${a==="HEAD"?"detached HEAD":a})`,`Inspect ${e.path}, then rerun \`crtr node worktree close\`.`);if(await x(e.path,e,n)===null)throw new h("branch_moved_unlanded",`managed worktree's recorded branch ${e.branch} no longer exists; its checkout is now on ${a} at ${n}, which carries content local base branch '${e.base_ref}' does not yet contain`,`Land or push ${a} through its own workflow before closing.`);const d=await H(e.path);if(!await L(e.repo_root,e.path,a)||await u(e.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")!==a||await u(e.path,["rev-parse","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")!==n)throw new h("wrong_branch",`managed worktree at ${e.path} changed while closing`,`Inspect ${e.path}, then rerun \`crtr node worktree close\`.`);return B(t,{observed_branch:a,observed_sha:n,common_dir:d,authorized:new Date().toISOString()}),A(t,e,"pending"),{node_id:t,branch:a,worktree_path:e.path,landed_sha:n,...D(e),branch_delete_error:`${a} is not a crtr-managed branch and will never be deleted automatically; it is preserved once the checkout above is removed.`}}if(await x(e.path,e,n)!==null)return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:n,...D(e)};let f;try{f=await Q(e.path,e.base_ref)}catch(s){if(!(s instanceof h)||s.code!=="missing_base_branch"||n!==e.base_sha)throw s;return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:e.base_sha,...D(e)}}const k=await i(["rebase",f],e.path);if(k.status!==0)throw new h("rebase_failed",`rebase onto local base branch '${e.base_ref}' did not complete`,`Resolve conflicts in ${e.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`,p(k));const w=await u(e.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`."),b=c((s,d,_)=>(U(t,s),new h("land_base_failed",s,d,_)),"blocked"),g=await i(["merge-base","--is-ancestor",f,w],e.path);if(g.status!==0)throw b(`rebased worktree is not a fast-forward of local base branch '${e.base_ref}'`,"Ask the user how to land this managed worktree.",p(g));const y=await u(e.path,["worktree","list","--porcelain"],"worktree_list_failed","Inspect the repository worktrees manually, then retry."),m=N(y,e.base_ref);let l;if(m!==null){const s=await i(["rev-parse","HEAD"],m);if(s.status!==0||s.stdout.trim()!==f)throw b(`local base branch '${e.base_ref}' changed while this worktree was closing`,`Reconcile the base checkout at ${m}, then rerun \`crtr node worktree close\`.`,s.status!==0?p(s):`expected ${f}, found ${s.stdout.trim()}`);const d=await V(m,e.branch,f,w);if(!d.ok)throw b(`could not fast-forward local base branch '${e.base_ref}' to this worktree`,`Local base branch '${e.base_ref}' is checked out at ${m} in a state that blocks a fast-forward.`,d.detail);l=d.stash}else{const s=await i(["update-ref",`refs/heads/${e.base_ref}`,w,f],e.path);if(s.status!==0)throw b(`could not fast-forward local base branch '${e.base_ref}' to this worktree`,"Ask the user how to land this managed worktree.",p(s))}return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:w,...D(e),...l===void 0?{}:{base_checkout_stash:l}}}c(S,"closeLocked");async function ie(t){const r=v(t)?.managed_worktree;if(r==null||r.state!=="open")return S(t);if(!$(r.path)){const n=await F(t);if(n!==null)return{node_id:t,branch:n.dropped.branch,worktree_path:n.dropped.worktree_path,landed_sha:n.landedSha,worktree_removed:!0,branch_deleted:n.dropped.branch_deleted,...n.dropped.branch_delete_error===void 0?{}:{branch_delete_error:n.dropped.branch_delete_error}}}const e=v(t)?.managed_worktree;if(e==null||e.state!=="open")return S(t);const o=$(e.path)?e.path:e.repo_root,a=await H(o);return O(z(a),()=>S(t),{timeoutMs:Math.min(T,25e3),timeoutError:c(()=>new h("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${a}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}c(ie,"closeManagedWorktreeAsync");export{ie as closeManagedWorktreeAsync};

package/dist/core/worktree-containment.js

@@ -1,48 +1,3 @@
-import { gitAsync } from './git.js';
-async function revParseRef(cwd, ref) {
-    const result = await gitAsync(['rev-parse', '--verify', '--quiet', ref], cwd);
-    return result.status === 0 ? result.stdout.trim() : null;
-}
-/** Resolve the base branch's configured upstream, or its origin fallback. */
-export async function upstreamTip(cwd, baseRef) {
-    const upstream = await gitAsync(['rev-parse', '--symbolic-full-name', '--verify', `${baseRef}@{upstream}`], cwd);
-    const ref = upstream.status === 0 && upstream.stdout.trim().startsWith('refs/')
-        ? upstream.stdout.trim()
-        : `refs/remotes/origin/${baseRef}`;
-    const sha = await revParseRef(cwd, ref);
-    return sha === null ? null : { ref, sha };
-}
-/** Prove that a recorded base or its upstream already carries a branch's
- * committed content. This is the one decision point for explicit close and
- * sweep cleanup: destination resolution happens only when this returns null. */
-export async function proveBranchContained(cwd, wt, branchSha) {
-    const candidates = [];
-    const localBaseRef = `refs/heads/${wt.base_ref}`;
-    const localBase = await revParseRef(cwd, localBaseRef);
-    if (localBase !== null)
-        candidates.push({ ref: localBaseRef, sha: localBase });
-    const upstream = await upstreamTip(cwd, wt.base_ref);
-    if (upstream !== null)
-        candidates.push(upstream);
-    for (const candidate of candidates) {
-        if ((await gitAsync(['merge-base', '--is-ancestor', branchSha, candidate.sha], cwd)).status === 0)
-            return { containingRef: candidate.ref, containingSha: candidate.sha };
-    }
-    for (const candidate of candidates) {
-        const cherry = await gitAsync(['cherry', candidate.sha, branchSha], cwd);
-        if (cherry.status !== 0)
-            continue;
-        const lines = cherry.stdout.split('\n').map((line) => line.trim()).filter((line) => line !== '');
-        if (lines.every((line) => line.startsWith('-')))
-            return { containingRef: candidate.ref, containingSha: candidate.sha };
-    }
-    for (const candidate of candidates) {
-        const candidateTree = await revParseRef(cwd, `${candidate.sha}^{tree}`);
-        if (candidateTree === null)
-            continue;
-        const merged = await gitAsync(['merge-tree', '--write-tree', candidate.sha, branchSha], cwd);
-        if (merged.status === 0 && merged.stdout.split('\n')[0]?.trim() === candidateTree)
-            return { containingRef: candidate.ref, containingSha: candidate.sha };
-    }
-    return null;
-}
+var p=Object.defineProperty;var f=(t,n)=>p(t,"name",{value:n,configurable:!0});import{gitAsync as u}from"./git.js";async function l(t,n){const s=await u(["rev-parse","--verify","--quiet",n],t);return s.status===0?s.stdout.trim():null}f(l,"revParseRef");async function d(t,n){const s=await u(["rev-parse","--symbolic-full-name","--verify",`${n}@{upstream}`],t),a=s.status===0&&s.stdout.trim().startsWith("refs/")?s.stdout.trim():`refs/remotes/origin/${n}`,r=await l(t,a);return r===null?null:{ref:a,sha:r}}f(d,"upstreamTip");async function v(t,n,s){const a=[],r=`refs/heads/${n.base_ref}`,m=await l(t,r);m!==null&&a.push({ref:r,sha:m});const h=await d(t,n.base_ref);h!==null&&a.push(h);for(const e of a)if((await u(["merge-base","--is-ancestor",s,e.sha],t)).status===0)return{containingRef:e.ref,containingSha:e.sha};for(const e of a){const i=await u(["cherry",e.sha,s],t);if(i.status!==0)continue;if(i.stdout.split(`
+`).map(o=>o.trim()).filter(o=>o!=="").every(o=>o.startsWith("-")))return{containingRef:e.ref,containingSha:e.sha}}for(const e of a){const i=await l(t,`${e.sha}^{tree}`);if(i===null)continue;const c=await u(["merge-tree","--write-tree",e.sha,s],t);if(c.status===0&&c.stdout.split(`
+`)[0]?.trim()===i)return{containingRef:e.ref,containingSha:e.sha}}return null}f(v,"proveBranchContained");export{v as proveBranchContained,d as upstreamTip};