@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-R7PYR4HW.js

@@ -0,0 +1,389 @@
+import {
+  lane_plan_wait_event
+} from "./chunk-DDOS32JU.js";
+import {
+  lane_net_time,
+  lane_stage_events,
+  lane_stop_stats
+} from "./chunk-SNSZ25XZ.js";
+import {
+  backlog_drive_restore
+} from "./chunk-SQZZHK6X.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-breakdown-pause.ts
+var { EVENT_KIND } = run_event_stream;
+var IMPLEMENT_SUFFIX = " implement";
+var REPLAN_NOTE = "re-plan";
+var RE_RUN_LEAD = "ship \xD7";
+var RE_RUN_TAIL = " re-run";
+var WAITING_LEAD = "waiting on ";
+var PARKED_LEAD = "parked";
+var PARK_TEXT = /^#(?<issue>[1-9]\d*) (?<rest>.*)$/u;
+function name_of(rest) {
+  if (rest.startsWith(WAITING_LEAD)) return `pause for ${rest.slice(WAITING_LEAD.length)}`;
+  if (rest.startsWith(PARKED_LEAD)) return `park${rest.slice(PARKED_LEAD.length)}`;
+  return void 0;
+}
+function rest_of(event, issue) {
+  const groups = PARK_TEXT.exec(event.text)?.groups;
+  return Number(groups?.["issue"]) === issue ? groups?.["rest"] : void 0;
+}
+function mark_of(event, issue) {
+  const name = name_of(rest_of(event, issue) ?? "");
+  return name === void 0 ? [] : [{ at_ms: Date.parse(event.at), name }];
+}
+function is_planning(event) {
+  return event.kind === EVENT_KIND.PLAN || event.kind === EVENT_KIND.LANE_PHASE && event.text.endsWith(IMPLEMENT_SUFFIX);
+}
+function run_step(runs, stage) {
+  if (runs.count > 0 && !runs.started.has(stage)) {
+    return { count: runs.count, started: /* @__PURE__ */ new Set([...runs.started, stage]) };
+  }
+  return { count: runs.count + 1, started: /* @__PURE__ */ new Set([stage]) };
+}
+function runs_of(events) {
+  const starts = events.filter((event) => event.kind === EVENT_KIND.SHIP_STAGE).map((event) => run_ship_stage.words_of(event.text)).filter((words) => words.phase === run_ship_stage.PHASE.START);
+  let runs = { count: 0, started: /* @__PURE__ */ new Set() };
+  for (const words of starts) runs = run_step(runs, words.stage);
+  return runs.count;
+}
+function note_of(events) {
+  const runs = runs_of(events);
+  const parts2 = [
+    ...events.some((event) => is_planning(event)) ? [REPLAN_NOTE] : [],
+    ...runs > 0 ? [`${RE_RUN_LEAD}${String(runs)}${RE_RUN_TAIL}`] : []
+  ];
+  return parts2.length === 0 ? "" : ` (${parts2.join(", ")})`;
+}
+function between_of(events, span) {
+  return events.filter((event) => {
+    const at_ms = Date.parse(event.at);
+    return at_ms > span.from_ms && at_ms <= span.to_ms;
+  });
+}
+function of(events, issue, span) {
+  const lane = events.filter((event) => lane_stop_stats.issue_of(event) === issue);
+  const marks = events.filter((event) => event.kind === EVENT_KIND.PARK).flatMap((event) => mark_of(event, issue)).filter((mark) => mark.at_ms >= span.from_ms && mark.at_ms <= span.to_ms);
+  return marks.map((mark, index) => {
+    const after = { from_ms: mark.at_ms, to_ms: marks[index + 1]?.at_ms ?? span.to_ms };
+    return { ...mark, name: `${mark.name}${note_of(between_of(lane, after))}` };
+  });
+}
+function in_segment(marks, segment) {
+  return marks.find((mark) => mark.at_ms > segment.from_ms && mark.at_ms <= segment.to_ms);
+}
+var lane_breakdown_pause = { in_segment, is_planning, of };
+
+// scripts/lane/lane-yield-split.ts
+var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
+function points_of(entries, events) {
+  const merges = entries.filter((entry) => lane_stage_stats.is_merge(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+  const openings = events.filter(
+    (event) => run_event_setup.is_stage(event, run_event_setup.LANE_STAGE.OPENING)
+  );
+  const done = events.filter((event) => backlog_drive_restore.DONE_KINDS.has(event.kind)).map((event) => ({ issue: lane_stop_stats.issue_of(event), at_ms: Date.parse(event.at) }));
+  return {
+    ends: [...merges, ...done],
+    openings: lane_stop_stats.events_of(openings, EVENT_KIND2.SETUP)
+  };
+}
+function first_at(points, issue, from_ms, until_ms) {
+  const inside = points.filter(
+    (point) => point.issue === issue && point.at_ms >= from_ms && point.at_ms <= until_ms
+  );
+  return inside.length === 0 ? void 0 : Math.min(...inside.map((point) => point.at_ms));
+}
+function after_holder(wait, yielder, ended_ms, points) {
+  const opened_ms = first_at(points.openings, yielder, ended_ms, wait.end_ms ?? Infinity);
+  return {
+    wait,
+    holder: { from_ms: wait.from_ms, end_ms: ended_ms },
+    offer: { from_ms: ended_ms, end_ms: opened_ms },
+    ...opened_ms !== void 0 && { launch: { from_ms: opened_ms, end_ms: wait.end_ms } }
+  };
+}
+function split_of(wait, issues, points) {
+  const [yielder, holder] = issues;
+  const ended_ms = first_at(points.ends, holder, wait.from_ms, wait.end_ms ?? Infinity);
+  return ended_ms === void 0 ? { wait, holder: { from_ms: wait.from_ms, end_ms: wait.end_ms } } : after_holder(wait, yielder, ended_ms, points);
+}
+function parts_of(note, wait, points) {
+  if (wait === void 0) return [];
+  const holder = lane_yield.holder_of(note);
+  return holder === void 0 ? [{ wait }] : [split_of(wait, [lane_stop_stats.issue_of(note), holder], points)];
+}
+function notes_with_waits(entries, events) {
+  const waits = lane_net_time.yield_spans(entries, events);
+  return events.filter((event) => lane_yield.is_yield_note(event)).map((note, index) => ({ note, wait: waits[index] }));
+}
+function parts(entries, events) {
+  const points = points_of(entries, events);
+  return notes_with_waits(entries, events).flatMap(({ note, wait }) => parts_of(note, wait, points));
+}
+function gap_ms({ wait, offer }) {
+  return offer === void 0 || wait.end_ms === void 0 ? void 0 : wait.end_ms - offer.from_ms;
+}
+function is_early({ wait, holder, offer }) {
+  return holder !== void 0 && offer === void 0 && wait.end_ms !== void 0;
+}
+function issue_yield(note, split) {
+  return {
+    holder: lane_yield.holder_of(note),
+    gap_ms: split === void 0 ? void 0 : gap_ms(split),
+    is_early: split !== void 0 && is_early(split)
+  };
+}
+function notes_of(entries, events, issue) {
+  return notes_with_waits(entries, events).filter(
+    ({ note }) => lane_stop_stats.issue_of(note) === issue
+  );
+}
+function of_issue(entries, events, issue) {
+  const points = points_of(entries, events);
+  return notes_of(entries, events, issue).map(
+    ({ note, wait }) => issue_yield(note, parts_of(note, wait, points).at(0))
+  );
+}
+function issue_parts(entries, events, issue) {
+  const points = points_of(entries, events);
+  return notes_of(entries, events, issue).flatMap(({ note, wait }) => parts_of(note, wait, points));
+}
+function part_ms(span) {
+  return span?.end_ms === void 0 ? 0 : span.end_ms - span.from_ms;
+}
+function share_of(splits) {
+  return {
+    holder_ms: splits.reduce((sum, split) => sum + part_ms(split.holder), 0),
+    gap_ms: splits.reduce((sum, split) => sum + (gap_ms(split) ?? 0), 0),
+    unsplit_ms: splits.filter((split) => split.holder === void 0).reduce((sum, split) => sum + part_ms(split.wait), 0)
+  };
+}
+var lane_yield_split = { issue_parts, of_issue, parts, share_of };
+
+// scripts/lane/lane-breakdown.ts
+var { EVENT_KIND: EVENT_KIND3 } = run_event_stream;
+var { PHASE } = run_ship_stage;
+var PLAN_STAGE = "start to plan";
+var IMPLEMENT_STAGE = "implement";
+var BETWEEN_STAGE = "between ship stages";
+var STOP_MARK = "stop";
+var SHIP_LEAD = "ship ";
+var PRE_DETACH_STAGE = `${SHIP_LEAD}${lane_ledger.PRE_DETACH_STAGE}`;
+var FOLLOWUP_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.FOLLOWUP}`;
+var ROUND_TWO_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.ROUND_TWO}`;
+var DRIVER_FOLLOWUP_STAGE = `driver ${run_ship_stage.STAGE.FOLLOWUP}`;
+function is_ship_stage(name) {
+  return name.startsWith(SHIP_LEAD) || name === BETWEEN_STAGE;
+}
+function is_ship(segment) {
+  return is_ship_stage(segment.stage);
+}
+function ship_stage_of(text) {
+  const { stage, phase } = run_ship_stage.words_of(text);
+  return phase === PHASE.START ? `${SHIP_LEAD}${stage}` : BETWEEN_STAGE;
+}
+function stage_of(event) {
+  if (event.kind === EVENT_KIND3.SHIP_STAGE) return ship_stage_of(event.text);
+  return lane_breakdown_pause.is_planning(event) ? IMPLEMENT_STAGE : void 0;
+}
+function is_inside(at_ms, span) {
+  return at_ms >= span.from_ms && at_ms < span.to_ms;
+}
+function is_lane_event(event, issue, span) {
+  return lane_stop_stats.issue_of(event) === issue && is_inside(Date.parse(event.at), span);
+}
+function marker_of(event, issue, span) {
+  const stage = stage_of(event);
+  const at_ms = Date.parse(event.at);
+  return stage !== void 0 && is_lane_event(event, issue, span) ? [{ at_ms, stage }] : [];
+}
+function reason_of(event, issue, span) {
+  if (event.kind !== EVENT_KIND3.SHIP_STAGE || !is_lane_event(event, issue, span)) return [];
+  const reason = run_ship_stage.reason_of(event.text);
+  const stage = `${SHIP_LEAD}${run_ship_stage.words_of(event.text).stage}`;
+  return reason === void 0 ? [] : [[stage, reason]];
+}
+function reasons_of(events, issue, span) {
+  const ordered = events.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  return new Map(ordered.flatMap((event) => reason_of(event, issue, span)));
+}
+function opens_implement(opened, edit_ms) {
+  const [first] = opened;
+  if (opened.some((marker) => marker.stage === IMPLEMENT_STAGE)) return false;
+  return first === void 0 || edit_ms < first.at_ms;
+}
+function edit_markers(opened, span, edit_ms) {
+  if (edit_ms === void 0 || !is_inside(edit_ms, span)) return [];
+  return opens_implement(opened, edit_ms) ? [{ at_ms: edit_ms, stage: IMPLEMENT_STAGE }] : [];
+}
+function stop_of(entry, issue, span) {
+  if (entry.kind !== lane_ledger.KIND.STOP || entry.issue !== issue) return [];
+  const at_ms = Date.parse(entry.at);
+  return is_inside(at_ms, span) ? [{ at_ms, stage: STOP_MARK }] : [];
+}
+function closing(marker, before) {
+  if (marker.stage !== STOP_MARK) return [marker];
+  if (before?.stage.startsWith(SHIP_LEAD) !== true) return [];
+  return [{ ...marker, stage: BETWEEN_STAGE }];
+}
+function closed(markers) {
+  return markers.flatMap((marker, index) => closing(marker, markers[index - 1]));
+}
+function opened_of(records, issue, span) {
+  const events = records.events.flatMap((event) => marker_of(event, issue, span));
+  const stops = records.entries.flatMap((entry) => stop_of(entry, issue, span));
+  return closed([...events, ...stops].toSorted((left, right) => left.at_ms - right.at_ms));
+}
+function segments_of(opened, span, edit_ms) {
+  const markers = [
+    { at_ms: span.from_ms, stage: PLAN_STAGE },
+    ...edit_markers(opened, span, edit_ms),
+    ...opened
+  ].filter((marker, index, all) => marker.stage !== all[index - 1]?.stage);
+  return markers.map((marker, index) => ({
+    stage: marker.stage,
+    from_ms: marker.at_ms,
+    to_ms: markers[index + 1]?.at_ms ?? span.to_ms
+  }));
+}
+function lane_segments(records, issue, span, edit_ms) {
+  const segments = segments_of(opened_of(records, issue, span), span, edit_ms);
+  return lane_plan_wait_event.carved(segments, lane_plan_wait_event.spans(records.events, issue));
+}
+function clipped(segment, parts2) {
+  return parts2.map((part) => ({
+    from_ms: Math.max(segment.from_ms, part.from_ms),
+    to_ms: Math.min(segment.to_ms, part.to_ms)
+  })).filter((part) => part.to_ms > part.from_ms).toSorted((left, right) => left.from_ms - right.from_ms);
+}
+function covered_ms(segment, parts2) {
+  let reached_ms = segment.from_ms;
+  let total_ms = 0;
+  for (const part of clipped(segment, parts2)) {
+    total_ms += Math.max(0, part.to_ms - Math.max(part.from_ms, reached_ms));
+    reached_ms = Math.max(reached_ms, part.to_ms);
+  }
+  return total_ms;
+}
+function ranked(parts2) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const part of parts2) totals.set(part.name, (totals.get(part.name) ?? 0) + part.ms);
+  return [...totals].map(([name, ms]) => ({ name, ms })).toSorted((left, right) => right.ms - left.ms);
+}
+function spans_ms(spans) {
+  return spans.reduce((sum, span) => sum + span.to_ms - span.from_ms, 0);
+}
+function windows_of(segments) {
+  return {
+    plan: segments.filter((segment) => segment.stage === PLAN_STAGE),
+    implement: segments.filter((segment) => segment.stage === IMPLEMENT_STAGE),
+    pre_detach: segments.filter((segment) => segment.stage === PRE_DETACH_STAGE),
+    ship: segments.filter((segment) => is_ship(segment))
+  };
+}
+function yields_of(entries, events, issue, span) {
+  const splits = lane_yield_split.issue_parts(entries, events, issue).filter((split) => is_inside(split.wait.from_ms, span));
+  return {
+    yield_ms: spans_ms(lane_net_time.yielded(entries, events, issue, span)),
+    yield_split: lane_yield_split.share_of(splits)
+  };
+}
+function net_segments_of(segments, outside) {
+  return segments.map((segment) => ({
+    ...segment,
+    net_ms: segment.to_ms - segment.from_ms - covered_ms(segment, outside)
+  }));
+}
+function stages_of(segments) {
+  const parts2 = segments.map((segment) => ({ name: segment.stage, ms: segment.net_ms }));
+  return ranked(parts2.filter((part) => part.name !== FOLLOWUP_STAGE));
+}
+function driver_of(ms) {
+  return ms > 0 ? [{ name: DRIVER_FOLLOWUP_STAGE, ms }] : [];
+}
+function breakdown_of(entries, events, issue, edit_ms) {
+  const span = lane_net_time.span_of(entries, issue);
+  if (span === void 0) return void 0;
+  const waits = lane_net_time.waits(entries, events, issue, span);
+  const outside = lane_net_time.outside(entries, events, issue, span);
+  const segments = lane_segments({ entries, events }, issue, span, edit_ms);
+  const net_segments = net_segments_of(segments, outside);
+  return {
+    stages: stages_of(net_segments),
+    driver: driver_of(spans_ms(outside) - spans_ms(waits)),
+    excluded_ms: spans_ms(waits),
+    slept_ms: spans_ms(lane_net_time.slept(events, span)),
+    ...yields_of(entries, events, issue, span),
+    waits,
+    segments: net_segments,
+    ...windows_of(segments),
+    reasons: reasons_of(events, issue, span),
+    pauses: lane_breakdown_pause.of(events, issue, span)
+  };
+}
+function of2(entries, events, issue, edit_ms) {
+  const span = lane_net_time.span_of(entries, issue);
+  const breakdown = breakdown_of(
+    entries,
+    lane_stage_events.of(entries, events, issue),
+    issue,
+    edit_ms
+  );
+  return breakdown === void 0 || span === void 0 ? void 0 : { ...breakdown, reasons: reasons_of(events, issue, span) };
+}
+function stage_at(breakdown, at_ms) {
+  const plan = (breakdown.plan ?? []).map((span) => ({ ...span, stage: PLAN_STAGE }));
+  const implement = breakdown.implement.map((span) => ({ ...span, stage: IMPLEMENT_STAGE }));
+  const segments = [...plan, ...implement, ...breakdown.ship];
+  return segments.find((segment) => is_inside(at_ms, segment))?.stage;
+}
+function minutes_text(ms) {
+  return `${(ms / MS_PER_MINUTE).toFixed(1)} min`;
+}
+function longest_of(breakdown) {
+  const [longest] = breakdown.stages;
+  return longest === void 0 ? void 0 : { name: longest.name, minutes: Math.round(longest.ms / MS_PER_MINUTE) };
+}
+var lane_breakdown = {
+  BETWEEN_STAGE,
+  DRIVER_FOLLOWUP_STAGE,
+  FOLLOWUP_STAGE,
+  IMPLEMENT_STAGE,
+  PLAN_STAGE,
+  PRE_DETACH_STAGE,
+  ROUND_TWO_STAGE,
+  covered_ms,
+  is_ship_stage,
+  longest_of,
+  minutes_text,
+  of: of2,
+  ranked,
+  stage_at
+};
+
+export {
+  lane_breakdown_pause,
+  lane_yield_split,
+  lane_breakdown
+};

package/dist/commands/chunk-RAQ3E6OT.js

@@ -0,0 +1,258 @@
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+
+// scripts/test/test-pinned-stage.ts
+var WIDE_REACH = 100;
+var WIDE_RATIO = 3;
+var TYPE_RED = { verdict: "red", failed: [], pinned_by: "type-check" };
+function none() {
+  return { direct: 0, typed: 0, escalated: 0 };
+}
+function is_wide(reach, direct) {
+  if (direct === 0 || direct >= reach) return false;
+  return reach >= WIDE_REACH || reach >= WIDE_RATIO * direct;
+}
+function plan_over(file, direct, reach) {
+  return is_wide(reach, direct.length) ? { direct, reach: [file] } : { reach: [file] };
+}
+async function past_direct(plan, run, is_type_red, staged) {
+  if (await is_type_red()) {
+    staged.typed += 1;
+    return TYPE_RED;
+  }
+  staged.escalated += 1;
+  return await run(plan.reach);
+}
+async function staged_verdict(plan, run, is_type_red, staged) {
+  if (plan.direct === void 0) return await run(plan.reach);
+  const first = await run(plan.direct);
+  if (first.verdict !== "red") return await past_direct(plan, run, is_type_red, staged);
+  staged.direct += 1;
+  return first;
+}
+function counts_suffix(staged) {
+  if (staged === void 0 || staged.direct + staged.typed + staged.escalated === 0) return "";
+  const typed = staged.typed === 0 ? "" : ` \xB7 type check ${String(staged.typed)}`;
+  return ` \xB7 direct ${String(staged.direct)}${typed} \xB7 escalated ${String(staged.escalated)}`;
+}
+var test_pinned_stage = { WIDE_RATIO, WIDE_REACH, counts_suffix, none, plan_over, staged_verdict };
+
+// scripts/test/test-pinned-logic.ts
+var DEFAULT_MAX_HUNKS = 20;
+var MAX_TEST_FILES = 150;
+var HEADER = /^@@ -\d+(?:,\d+)? \+(?<start>\d+)(?:,(?<count>\d+))? @@/u;
+var FILE_HEADER = "+++ b/";
+var SECTION_HEADER = "diff --git ";
+var OLD_LINE = "-";
+var OLD_FILE_HEADER = "--- ";
+var NEW_LINE = "+";
+var FILE_HEADER_MARK = "+++ ";
+var OLD_FILE_PATH = "--- a/";
+var LINE_BREAK = "\n";
+var GREEN_REASON = "reverting it left every related test green";
+var NO_TEST_REASON = "no related test ran with it reverted";
+var STUB_GREEN_REASON = "replacing its body with a throw left every related test green";
+var STUB_NO_TEST_REASON = "no related test ran with its body replaced by a throw";
+var UNPARSED_REASON = "an added file, and typescript is not installed to read its functions";
+var NO_RUNNER_REASON = "vitest is not installed to run its related tests";
+var STOPPED_REASON = "vitest stopped before any test ran with it reverted";
+var CUT_REASON = "not probed: the run stopped at the first unpinned hunk";
+var OVER_CAP_REASON = `over the ${String(MAX_TEST_FILES)}-test-file cap`;
+var STOPPED_VERDICT = "stopped";
+var SETTLED_VERDICTS = /* @__PURE__ */ new Set(["red", STOPPED_VERDICT]);
+function is_target(file) {
+  return !test_declared_logic.is_test_file(file) && related_scope.is_relatable(file);
+}
+function count_of(group) {
+  return group === void 0 ? 1 : Number(group);
+}
+function hunk_from(file, line) {
+  const groups = HEADER.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  return {
+    file,
+    new_start: Number(groups["start"]),
+    new_count: count_of(groups["count"]),
+    old_lines: [],
+    new_lines: []
+  };
+}
+function is_old_line(line) {
+  return line.startsWith(OLD_LINE) && !line.startsWith(OLD_FILE_HEADER);
+}
+function is_new_line(line) {
+  return line.startsWith(NEW_LINE) && !line.startsWith(FILE_HEADER_MARK);
+}
+function record_line(hunk, line) {
+  if (hunk === void 0) return;
+  if (is_old_line(line)) hunk.old_lines.push(line.slice(OLD_LINE.length));
+  else if (is_new_line(line)) hunk.new_lines?.push(line.slice(NEW_LINE.length));
+}
+function file_after(file, line) {
+  if (line.startsWith(FILE_HEADER)) return line.slice(FILE_HEADER.length);
+  if (line.startsWith(OLD_FILE_PATH)) return line.slice(OLD_FILE_PATH.length);
+  return line.startsWith(SECTION_HEADER) ? "" : file;
+}
+function step(walk, line) {
+  walk.file = file_after(walk.file, line);
+  const hunk = hunk_from(walk.file, line);
+  if (hunk === void 0) record_line(walk.hunks.at(-1), line);
+  else walk.hunks.push(hunk);
+}
+function all_hunks(diff) {
+  const walk = { file: "", hunks: [] };
+  for (const line of diff.split(LINE_BREAK)) step(walk, line);
+  return walk.hunks;
+}
+function parse_hunks(diff) {
+  return all_hunks(diff).filter((hunk) => is_target(hunk.file));
+}
+function start_index(hunk) {
+  return hunk.new_count === 0 ? hunk.new_start : hunk.new_start - 1;
+}
+function revert(content, hunk) {
+  const lines = content.split(LINE_BREAK);
+  const parts = (hunk.parts ?? [hunk]).toSorted(
+    (left, right) => start_index(right) - start_index(left)
+  );
+  for (const part of parts) lines.splice(start_index(part), part.new_count, ...part.old_lines);
+  return lines.join(LINE_BREAK);
+}
+function split(hunks, max_hunks) {
+  return { checked: hunks.slice(0, max_hunks), unchecked: hunks.slice(max_hunks) };
+}
+function capped(hunks, reach, max_tests = MAX_TEST_FILES) {
+  function is_over(hunk) {
+    return (reach.get(hunk.file) ?? 0) > max_tests;
+  }
+  return {
+    checked: hunks.filter((hunk) => !is_over(hunk)),
+    unchecked: hunks.filter((hunk) => is_over(hunk))
+  };
+}
+function by_reach(probes, reach) {
+  function count(probe) {
+    return reach.get(probe.hunk.file) ?? 0;
+  }
+  return probes.toSorted((first, second) => count(first) - count(second));
+}
+function is_unpinned(probe) {
+  return !SETTLED_VERDICTS.has(probe.verdict);
+}
+function unpinned_of(hunk, probe) {
+  if (probe === void 0 || !is_unpinned(probe)) return [];
+  return [{ ...hunk, is_green: probe.verdict === "green" }];
+}
+function stopped_of(hunk, probe) {
+  return probe?.verdict === STOPPED_VERDICT ? [hunk] : [];
+}
+function outcome(hunks, verdicts) {
+  return {
+    unpinned: hunks.flatMap((hunk, index) => unpinned_of(hunk, verdicts[index])),
+    stopped: hunks.flatMap((hunk, index) => stopped_of(hunk, verdicts[index]))
+  };
+}
+function location(hunk) {
+  const line = `${hunk.file}:${String(Math.max(hunk.new_start, 1))}`;
+  return hunk.function_name === void 0 ? line : `${line} ${hunk.function_name}`;
+}
+function reason(hunk) {
+  if (hunk.function_name === void 0) return hunk.is_green ? GREEN_REASON : NO_TEST_REASON;
+  return hunk.is_green ? STUB_GREEN_REASON : STUB_NO_TEST_REASON;
+}
+function unchecked_reason(report) {
+  return report.has_runner ? `over the ${String(report.max_hunks)}-hunk cap` : NO_RUNNER_REASON;
+}
+function hint(hunk) {
+  const tests = hunk.related_tests;
+  if (tests === void 0) {
+    return "related tests unavailable; add or strengthen a regression test that fails when this change is reverted";
+  }
+  if (tests.length === 0) {
+    return "no related tests; add a related regression test that fails when this change is reverted";
+  }
+  return `related tests: ${tests.join(", ")}; strengthen a regression assertion that fails when this change is reverted`;
+}
+function unpinned_lines(report) {
+  return report.unpinned.map(
+    (hunk) => `unpinned ${location(hunk)} \u2014 ${reason(hunk)}; ${hint(hunk)}`
+  );
+}
+function place_of(hunk, why) {
+  return { place: location(hunk), why };
+}
+function unchecked_places(report) {
+  return [
+    ...report.unchecked.map((hunk) => place_of(hunk, unchecked_reason(report))),
+    ...(report.over_cap ?? []).map((hunk) => place_of(hunk, OVER_CAP_REASON)),
+    ...report.stopped.map((hunk) => place_of(hunk, STOPPED_REASON)),
+    ...(report.cut ?? []).map((hunk) => place_of(hunk, CUT_REASON)),
+    ...report.unparsed.map((file) => ({ place: file, why: UNPARSED_REASON }))
+  ];
+}
+function has_unchecked(report) {
+  return unchecked_places(report).length > 0;
+}
+function format(report) {
+  const unchecked = unchecked_places(report).map((item) => `unchecked ${item.place} \u2014 ${item.why}`);
+  return [...unpinned_lines(report), ...unchecked].join(LINE_BREAK);
+}
+function folded_unchecked(report) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { why } of unchecked_places(report)) counts.set(why, (counts.get(why) ?? 0) + 1);
+  return [...counts].map(([why, count]) => `unchecked ${String(count)} \u2014 ${why}`);
+}
+function counts_line(report) {
+  const unchecked = String(unchecked_places(report).length);
+  const staged = test_pinned_stage.counts_suffix(report.staged);
+  return `unpinned ${String(report.unpinned.length)} \xB7 unchecked ${unchecked}${staged}`;
+}
+function report_parts(report) {
+  const lines = [...unpinned_lines(report), ...folded_unchecked(report)];
+  return {
+    text: lines.map((line) => `${line}${LINE_BREAK}`).join(""),
+    counts: counts_line(report),
+    ...report.tree_hash !== void 0 && {
+      tree_hash: report.tree_hash,
+      is_stale: report.is_stale
+    }
+  };
+}
+function report_text(parts, note = "") {
+  const stale = parts.is_stale === true ? " \xB7 stale" : "";
+  const snapshot = parts.tree_hash === void 0 ? "" : `snapshot ${parts.tree_hash}${stale}
+`;
+  const failures = `${snapshot}${parts.text}${note}`;
+  if (parts.counts === void 0) return failures;
+  return verification_tail.format_tail({ failures, log: parts.log, verdict: parts.counts });
+}
+var test_pinned_logic = {
+  all_hunks,
+  DEFAULT_MAX_HUNKS,
+  by_reach,
+  capped,
+  format,
+  has_unchecked,
+  is_target,
+  is_unpinned,
+  location,
+  MAX_TEST_FILES,
+  outcome,
+  parse_hunks,
+  report_parts,
+  report_text,
+  revert,
+  split
+};
+
+export {
+  test_pinned_stage,
+  test_pinned_logic
+};

package/dist/commands/chunk-RESNXNDG.js

@@ -0,0 +1,54 @@
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  PORCELAIN_FLAG
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/test/test-declared-changed.ts
+var RENAME_ARROW = " -> ";
+var STATUS_PREFIX_LENGTH = 3;
+function path_of(line) {
+  const body = line.slice(STATUS_PREFIX_LENGTH);
+  const arrow = body.indexOf(RENAME_ARROW);
+  return arrow === -1 ? body : body.slice(arrow + RENAME_ARROW.length);
+}
+function read_changed_paths_sync() {
+  const output = git_spawn_sync.run(["status", PORCELAIN_FLAG], { timeout: 0 });
+  if (output.exit_code !== 0) return [];
+  return output.stdout.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH).map((line) => path_of(line));
+}
+var injected = {};
+function source_paths() {
+  return injected.paths ?? read_changed_paths_sync();
+}
+function current_verdict(paths = source_paths()) {
+  return test_declared_logic.verdict_for(paths, project_checks.is_basic(process.cwd()));
+}
+function restore_injection(previous) {
+  if (previous === void 0) {
+    delete injected.paths;
+    return;
+  }
+  injected.paths = previous;
+}
+function with_paths(paths, body) {
+  const previous = injected.paths;
+  injected.paths = paths;
+  try {
+    return body();
+  } finally {
+    restore_injection(previous);
+  }
+}
+var test_declared_changed = { current_verdict, path_of, read_changed_paths_sync, with_paths };
+
+export {
+  test_declared_changed
+};