@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/chunk-XXN2EZBY.js

@@ -0,0 +1,133 @@
+import {
+  hook_decision
+} from "./chunk-RLBFEHHC.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-investigation-switch.ts
+var INVESTIGATION_ENV_KEY = "JOSH_LANE_INVESTIGATION";
+function is_on() {
+  return hook_decision.is_switch_opt_in(INVESTIGATION_ENV_KEY);
+}
+var lane_investigation_switch = { is_on };
+
+// scripts/run/event/run-event-overrun.ts
+var WITHIN_PATTERN = /^#(?<issue>\d+) net: (?<minutes>\d+) min$/u;
+var SKIPPED_PATTERN = /^#(?<issue>\d+) overrun skipped: (?<reason>.+)$/u;
+var OVERRAN_PATTERN = /^#(?<issue>\d+) overran: (?<minutes>\d+) min net(?:, longest (?<stage>.+?) (?<stage_minutes>\d+) min)? — (?<outcome>.*)$/u;
+var INVESTIGATING_PATTERN = /^investigating in pid (?<pid>\d+)(?: started (?<start>.+))?$/u;
+var ENDED_PATTERN = /^#(?<issue>\d+) overrun: (?<result>.*)$/u;
+var FAILED_PATTERN = /^#(?<issue>\d+) overrun investigation failed: /u;
+var DISABLED_REASON = "disabled (JOSH_LANE_INVESTIGATION is not on)";
+var FILED_RESULT = "filed";
+var NONE_LEAD = "none: ";
+var NOT_REDUCIBLE_LEAD = "; not reducible: ";
+var RECURRED_PATTERN = /^recurred #(?<number>\d+)/u;
+var FOLDED_LEAD = "folded ";
+var FOLDED_SEPARATOR = ",";
+var FOLDED_PATTERN = /^folded (?<list>#\d+(?:,#\d+)*)/u;
+var NUMBER_PATTERN = /#(?<number>\d+)/gu;
+function started_text(issue, minutes, outcome, longest) {
+  const stage = longest === void 0 ? "" : `, longest ${longest.name} ${String(longest.minutes)} min`;
+  return `${issue_cite.plain_for("program", issue)} overran: ${String(minutes)} min net${stage} \u2014 ${outcome}`;
+}
+function within_text(issue, minutes) {
+  return `${issue_cite.plain_for("program", issue)} net: ${String(minutes)} min`;
+}
+function skipped_text(issue, reason) {
+  return `${issue_cite.plain_for("program", issue)} overrun skipped: ${reason}`;
+}
+function investigating(pid, start) {
+  const outcome = `investigating in pid ${String(pid)}`;
+  return start === void 0 ? outcome : `${outcome} started ${start}`;
+}
+function ended_text(issue, result) {
+  return `${issue_cite.plain_for("program", issue)} overrun: ${result}`;
+}
+function failed_text(issue, note) {
+  return `${issue_cite.plain_for("program", issue)} overrun investigation failed: ${note}`;
+}
+function none_result(reason) {
+  return `${NONE_LEAD}${reason}`;
+}
+function recurred_result(issue) {
+  return `recurred ${issue_cite.plain_for("program", issue)}`;
+}
+function recurred_of(result) {
+  const number = RECURRED_PATTERN.exec(result)?.groups?.["number"];
+  return number === void 0 ? void 0 : Number(number);
+}
+function folded_result(issues) {
+  return `${FOLDED_LEAD}${issues.map((issue) => issue_cite.plain_for("program", issue)).join(FOLDED_SEPARATOR)}`;
+}
+function folded_of(result) {
+  const list = FOLDED_PATTERN.exec(result)?.groups?.["list"] ?? "";
+  return [...list.matchAll(NUMBER_PATTERN)].map((match) => Number(match.groups?.["number"]));
+}
+function reason_of(result) {
+  const [lead = ""] = result.split(NOT_REDUCIBLE_LEAD);
+  return lead.startsWith(NONE_LEAD) ? lead.slice(NONE_LEAD.length) : lead;
+}
+function longest_of(groups) {
+  const name = groups["stage"];
+  return name === void 0 ? void 0 : { name, minutes: Number(groups["stage_minutes"]) };
+}
+function overran(groups) {
+  const issue = Number(groups["issue"]);
+  const minutes = Number(groups["minutes"]);
+  const launched = INVESTIGATING_PATTERN.exec(groups["outcome"] ?? "")?.groups;
+  if (launched === void 0) return { kind: "failed", issue, minutes };
+  const pid = Number(launched["pid"]);
+  const longest = longest_of(groups);
+  return { kind: "started", issue, minutes, pid, start: launched["start"], longest };
+}
+function within(groups) {
+  return { kind: "within", issue: Number(groups["issue"]), minutes: Number(groups["minutes"]) };
+}
+function skipped(groups) {
+  return { kind: "skipped", issue: Number(groups["issue"]), reason: groups["reason"] ?? "" };
+}
+function failed(groups) {
+  return { kind: "failed", issue: Number(groups["issue"]), minutes: void 0 };
+}
+function ended(groups) {
+  return { kind: "ended", issue: Number(groups["issue"]), result: groups["result"] ?? "" };
+}
+var READERS = [
+  [WITHIN_PATTERN, within],
+  [SKIPPED_PATTERN, skipped],
+  [OVERRAN_PATTERN, overran],
+  [FAILED_PATTERN, failed],
+  [ENDED_PATTERN, ended]
+];
+function parse(text) {
+  for (const [pattern, read] of READERS) {
+    const groups = pattern.exec(text)?.groups;
+    if (groups !== void 0) return read(groups);
+  }
+  return void 0;
+}
+var run_event_overrun = {
+  DISABLED_REASON,
+  ended_text,
+  failed_text,
+  FILED_RESULT,
+  folded_of,
+  folded_result,
+  investigating,
+  none_result,
+  NOT_REDUCIBLE_LEAD,
+  parse,
+  reason_of,
+  recurred_of,
+  recurred_result,
+  skipped_text,
+  started_text,
+  within_text
+};
+
+export {
+  lane_investigation_switch,
+  run_event_overrun
+};

package/dist/commands/chunk-XXNEY4B3.js

@@ -0,0 +1,110 @@
+import {
+  git_gh_etag_read
+} from "./chunk-EWVR5AEX.js";
+import {
+  shared_cache
+} from "./chunk-C6QSVO5K.js";
+import {
+  author_fields_schema
+} from "./chunk-34DND4BA.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  parse_json
+} from "./chunk-XDF25GSU.js";
+
+// scripts/gh/gh-permission-cache.ts
+import { z } from "zod";
+var MS_KEPT = 36e5;
+var WRITERS_CACHE = { prefix: "josh-write-permission-", ttl_ms: MS_KEPT };
+var entries_schema = z.array(z.object({ login: z.string(), read_at: z.number() }));
+function fresh_entries(repo, now_ms) {
+  const entries = shared_cache.read(WRITERS_CACHE, repo, entries_schema, now_ms) ?? [];
+  return entries.filter((entry) => entry.read_at <= now_ms && now_ms - entry.read_at < MS_KEPT);
+}
+function is_writer(repo, login, now_ms = Date.now()) {
+  return fresh_entries(repo, now_ms).some((entry) => entry.login === login);
+}
+function remember_writer(repo, login, now_ms = Date.now()) {
+  const fresh = fresh_entries(repo, now_ms);
+  if (fresh.some((entry) => entry.login === login)) return;
+  shared_cache.write(WRITERS_CACHE, repo, [...fresh, { login, read_at: now_ms }], now_ms);
+}
+var gh_permission_cache = { WRITERS_CACHE, is_writer, remember_writer };
+
+// scripts/gh/gh-author-association.ts
+import { z as z2 } from "zod";
+var OWNER = "OWNER";
+var ASKED_ASSOCIATIONS = /* @__PURE__ */ new Set(["MEMBER", "COLLABORATOR"]);
+var WRITE_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var LOGIN_PATTERN = /^[\da-z](?:[\w-]*[\da-z])?$/iu;
+var TRUSTED_LIST = "OWNER, or MEMBER / COLLABORATOR with write access";
+var AUTHOR_FIELDS = "author_association,user";
+var permission_schema = z2.looseObject({
+  permission: z2.string().nullish(),
+  role_name: z2.string().nullish()
+});
+var answers = /* @__PURE__ */ new Map();
+function permission_path(login, repo) {
+  return `${git_gh_api_path.repo_api_path(repo)}/collaborators/${login}/permission`;
+}
+function has_write_role(raw) {
+  const parsed = parse_json.parse_json_object_or_undefined(raw, permission_schema);
+  const roles = [parsed?.role_name, parsed?.permission];
+  return roles.some((role) => typeof role === "string" && WRITE_ROLES.has(role));
+}
+async function read_permission(asked) {
+  try {
+    const path = permission_path(asked.login, asked.repo);
+    const raw = await git_gh_etag_read.read(path, asked.timeout_ms);
+    return has_write_role(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function ask_permission(asked) {
+  if (asked.is_shared !== true) return await read_permission(asked);
+  const repo = asked.repo ?? "";
+  if (gh_permission_cache.is_writer(repo, asked.login)) return true;
+  const has_write = await read_permission(asked);
+  if (has_write === true) gh_permission_cache.remember_writer(repo, asked.login);
+  return has_write;
+}
+async function can_write(author) {
+  const key = `${author.repo ?? ""} ${author.login}`;
+  const asked = answers.get(key) ?? ask_permission(author);
+  answers.set(key, asked);
+  const has_write = await asked;
+  if (has_write === void 0 && answers.get(key) === asked) answers.delete(key);
+  return has_write;
+}
+function is_user_login(login) {
+  return login !== void 0 && LOGIN_PATTERN.test(login);
+}
+function is_asked(author) {
+  return ASKED_ASSOCIATIONS.has(author.association ?? "") && is_user_login(author.login);
+}
+async function trust_of(author) {
+  if (author.association === OWNER) return true;
+  if (author.login === void 0 || !is_asked(author)) return false;
+  return await can_write({ ...author, login: author.login });
+}
+async function is_trusted(author) {
+  return await trust_of(author) === true;
+}
+function author_of(row, timeout_ms) {
+  return { login: row.user?.login, association: row.author_association, timeout_ms };
+}
+var gh_author_association = {
+  AUTHOR_FIELDS,
+  TRUSTED_LIST,
+  author_fields_schema,
+  author_of,
+  is_trusted,
+  trust_of
+};
+
+export {
+  gh_author_association
+};

package/dist/commands/chunk-XZQWEVR3.js

@@ -0,0 +1,84 @@
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/issue/expected-effect-lint.ts
+var DECLARATION_LINE = issue_body_keys.line("purpose", "time_saving");
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var HEADING = issue_body_keys.heading("expected_effect");
+var RATE_LABEL = "\u52B9\u304F\u7387";
+var GAIN_LABEL = "1 \u56DE\u3042\u305F\u308A\u306E\u5F97";
+var ITEM_LABELS = [RATE_LABEL, GAIN_LABEL, "\u5916\u308C\u305F\u3068\u304D\u306E\u640D", "\u51FA\u5178"];
+var WEEK = "\u9031";
+var COUNT = /(?<![\d.])(?<count>\d+) ?回/gu;
+var SPAN = /(?<![\d.])(?<weeks>\d+) ?週/u;
+var ONE_WEEK = 1;
+var DURATION = /(?<![\d.])(?<amount>\d+(?:\.\d+)?) ?(?<unit>[分秒])/u;
+var SECONDS_UNIT = "\u79D2";
+var SECONDS_PER_MINUTE = 60;
+var NONE = 0;
+var PLACEHOLDER = /^<.*>$/u;
+function is_target(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  return markdown_section.has_unfenced_line(background, DECLARATION_LINE);
+}
+function item_value(line, label) {
+  const prefix = `- ${label}:`;
+  if (!line.startsWith(prefix)) return void 0;
+  return line.slice(prefix.length).trim();
+}
+function is_stated(value) {
+  return value !== void 0 && value.length > 0 && !PLACEHOLDER.test(value);
+}
+function stated_value(lines, label) {
+  return lines.map((line) => item_value(line.trim(), label)).find((value) => is_stated(value));
+}
+function effect_lines(body) {
+  const section = markdown_section.section_lines(body, HEADING).join("\n");
+  return markdown_section.unfenced_lines(section);
+}
+function value_of(body, label) {
+  return stated_value(effect_lines(body), label);
+}
+function weeks_of(rate) {
+  const weeks = SPAN.exec(rate)?.groups?.["weeks"];
+  return Math.max(Number(weeks ?? ONE_WEEK), ONE_WEEK);
+}
+function weekly_hits(rate) {
+  if (!rate?.includes(WEEK)) return NONE;
+  const counts = [...rate.matchAll(COUNT)].map((match) => Number(match.groups?.["count"]));
+  return (counts.at(-1) ?? NONE) / weeks_of(rate);
+}
+function minutes_per_hit(gain = "") {
+  const groups = DURATION.exec(gain)?.groups;
+  if (groups === void 0) return NONE;
+  const amount = Number(groups["amount"]);
+  return groups["unit"] === SECONDS_UNIT ? amount / SECONDS_PER_MINUTE : amount;
+}
+function weekly_minutes(body = "") {
+  return weekly_hits(value_of(body, RATE_LABEL)) * minutes_per_hit(value_of(body, GAIN_LABEL));
+}
+function problems(body) {
+  if (!is_target(body)) return [];
+  if (!markdown_section.has_line(body, HEADING)) return [`missing heading: ${HEADING}`];
+  const lines = effect_lines(body);
+  return ITEM_LABELS.filter((label) => stated_value(lines, label) === void 0).map(
+    (label) => `missing expected-effect item: - ${label}: <value>`
+  );
+}
+var expected_effect_lint = {
+  DECLARATION_LINE,
+  HEADING,
+  ITEM_LABELS,
+  is_target,
+  problems,
+  value_of,
+  weekly_minutes
+};
+
+export {
+  expected_effect_lint
+};

package/dist/commands/chunk-Y27PTXXI.js

@@ -0,0 +1,258 @@
+import {
+  related_scope
+} from "./chunk-CFHRNTE5.js";
+import {
+  verification_tail
+} from "./chunk-FGL6DBZU.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-Y2RNUX4W.js

@@ -0,0 +1,8 @@
+// scripts/lane/lane-ledger-pinned-origin.ts
+import { z } from "zod";
+var pinned_origin_schema = z.enum(["run-review", "pre-detach", "manual"]);
+var lane_ledger_pinned_origin = { pinned_origin_schema };
+
+export {
+  lane_ledger_pinned_origin
+};