@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-R7PYR4HW.js

@@ -1,389 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-};