@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-CDK7QZWG.js

@@ -1,44 +0,0 @@
-import {
-  acceptance_map
-} from "./chunk-5PCK53WP.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/review/acceptance-map-check.ts
-var ISSUE_SEPARATOR = "#";
-async function is_found(deferral) {
-  const [repo, number = ""] = deferral.issue.split(ISSUE_SEPARATOR);
-  const read = await git_gh_command.issue_get_body_classified(
-    number,
-    repo === "" ? void 0 : repo
-  );
-  return read.kind === "read";
-}
-async function absent_deferrals(deferrals) {
-  const found = await Promise.all(deferrals.map(async (deferral) => await is_found(deferral)));
-  return deferrals.filter((_deferral, index) => found[index] !== true).map((deferral) => `- \`${deferral.id}\` names ${deferral.issue}`);
-}
-function unreadable_message(issue) {
-  return `Issue ${session_cite.issue(issue)} could not be re-read to check its acceptance criteria, so the merge is refused; re-run once it can be.`;
-}
-async function body_refusal(issue, pr_body) {
-  const issue_read = await git_gh_command.issue_get_body_classified(issue);
-  if (issue_read.kind !== "read") return unreadable_message(issue);
-  const criteria = acceptance_map.criteria_of(issue_read.text);
-  const comparison = acceptance_map.compare(criteria, acceptance_map.rows_of(pr_body));
-  const absent = await absent_deferrals(comparison.deferrals);
-  if (comparison.missing.length === 0 && absent.length === 0) return void 0;
-  return acceptance_map.refusal_message(issue, comparison, absent);
-}
-async function refusal(issue, branch_name) {
-  return await body_refusal(issue, await git_gh_command.pr_get_body(branch_name));
-}
-var acceptance_map_check = { body_refusal, refusal };
-
-export {
-  acceptance_map_check
-};

package/dist/commands/chunk-CDYFUCDC.js

@@ -1,72 +0,0 @@
-import {
-  npm_registry,
-  release_age
-} from "./chunk-5GI5GLC4.js";
-import {
-  git_gh_exec
-} from "./chunk-43DU7DYZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/version/version-remote.ts
-var TIMES_PAGE_SIZE = 100;
-var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
-function require_endpoint(versions_endpoint, package_name) {
-  if (versions_endpoint !== void 0 && versions_endpoint.trim() !== "") return versions_endpoint;
-  throw new Error(
-    `Could not derive a versions endpoint for ${package_name}; check its version-command config.`
-  );
-}
-function read_github_name(endpoint, package_name) {
-  try {
-    return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
-  } catch (error) {
-    const detail = error_text.message_of(error);
-    throw new Error(
-      `Failed to fetch latest version for ${package_name} via ${endpoint}: ${detail}`,
-      {
-        cause: error
-      }
-    );
-  }
-}
-function read_github_latest(endpoint, package_name) {
-  const name = read_github_name(endpoint, package_name);
-  const version = npm_registry.valid_version(name);
-  if (version !== void 0) return version;
-  throw new Error(
-    `Refused latest version for ${package_name} via ${endpoint}: ${JSON.stringify(name)} is not a semver version`
-  );
-}
-function fetch_latest_version(versions_endpoint, package_name) {
-  const endpoint = require_endpoint(versions_endpoint, package_name);
-  return npm_registry.read_latest(package_name) ?? read_github_latest(endpoint, package_name);
-}
-function with_page_size(endpoint, page_size) {
-  const separator = endpoint.indexOf("?");
-  const path_part = separator === -1 ? endpoint : endpoint.slice(0, separator);
-  const query = new URLSearchParams(separator === -1 ? "" : endpoint.slice(separator + 1));
-  query.set("per_page", String(page_size));
-  return `${path_part}?${query.toString()}`;
-}
-function read_github_release_times(versions_endpoint) {
-  const endpoint = with_page_size(versions_endpoint, TIMES_PAGE_SIZE);
-  const stdout = git_gh_exec.read_gh_api_sync({ path: endpoint, jq_filter: TIMES_JQ });
-  if (stdout === void 0) return void 0;
-  const parsed = release_age.release_times_schema.safeParse(json_value.parse_or_undefined(stdout));
-  return parsed.success ? parsed.data : void 0;
-}
-function fetch_release_times(versions_endpoint, package_name) {
-  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
-  return npm_registry.read_release_times(package_name) ?? read_github_release_times(versions_endpoint);
-}
-
-export {
-  fetch_latest_version,
-  with_page_size,
-  fetch_release_times
-};

package/dist/commands/chunk-CEADAQIL.js

@@ -1,170 +0,0 @@
-import {
-  backlog_drive_unit
-} from "./chunk-2E6PSONB.js";
-import {
-  run_event_setup
-} from "./chunk-OKN63ZH5.js";
-import {
-  run_carry
-} from "./chunk-DS53UUDH.js";
-import {
-  agent_session_environment
-} from "./chunk-HHBC6QZE.js";
-import {
-  issue_number_shape
-} from "./chunk-G75GWNNY.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/backlog/backlog-drive-retrospective-unit.ts
-function brief_of(owner) {
-  return [
-    "Run the backlogrun retrospective as the run parent would: `pnpm josh doc:read retrospective.md`;",
-    "its digest is `pnpm josh retrospective`.",
-    `Close with \`pnpm josh run:carry --retrospective --summary "<result>" --owner ${owner}\`:`,
-    "the run record is held by that process, not this session.",
-    "Nobody answers this session: a question for a person ends it, written as the final message."
-  ].join(" ");
-}
-var LOG_LABEL = "retrospective";
-function request_of(ports, git_directory, owner) {
-  const log = backlog_drive_unit.log_path(git_directory, LOG_LABEL, ports.now());
-  return backlog_drive_unit.request_of(brief_of(owner), ports, log);
-}
-function production_ports() {
-  return {
-    repository_directory: run_carry.repository_directory,
-    emit: run_event_setup.emit,
-    launch_attached: backlog_drive_unit.launch_attached,
-    is_marked: (git_directory) => run_carry.retrospective_done_of(run_carry.read_carry(run_carry.carry_path(git_directory))),
-    environment: process.env,
-    cwd: process.cwd(),
-    now: () => Date.now()
-  };
-}
-async function run(owner, ports = production_ports()) {
-  const git_directory = await ports.repository_directory();
-  if (git_directory === void 0) return false;
-  const request = request_of(ports, git_directory, owner);
-  if (request === void 0) return false;
-  await ports.emit(run_event_setup.STAGE.RETROSPECTIVE);
-  await ports.launch_attached(request);
-  return ports.is_marked(git_directory);
-}
-var backlog_drive_retrospective_unit = { brief_of, run };
-
-// scripts/backlog/backlog-drive-args.ts
-var LIST_SEPARATOR = ",";
-var USAGE = "Usage: josh backlog:drive [--owner <pid>] [--active <ISO-8601>] [--max <n>] [--idle <minutes>] [--only] [--exclude <n>[,<n>...]] [--await <n>[,<n>...]] [--window <minutes>] [--stopped <n>]";
-var OPTIONS = {
-  active: { type: "string" },
-  await: { type: "string" },
-  exclude: { type: "string" },
-  idle: { type: "string" },
-  max: { type: "string" },
-  only: { type: "boolean" },
-  owner: { type: "string" },
-  stopped: { type: "string" },
-  "triage-owed": { type: "boolean" },
-  "triage-pid": { type: "string" },
-  "triage-start": { type: "string" },
-  window: { type: "string" }
-};
-var START_SPACE = " ";
-var START_SPACE_TOKEN = "_";
-function beside_session(values) {
-  const pid = cli_flags.to_count(values["triage-pid"]);
-  if (pid === void 0) return {};
-  const start = values["triage-start"]?.split(START_SPACE_TOKEN).join(START_SPACE);
-  return start === void 0 ? { triage_pid: pid } : { triage_pid: pid, triage_start: start };
-}
-function triage_flags(values) {
-  const owed = values["triage-owed"] === true ? { is_triage_owed: true } : {};
-  return { ...owed, ...beside_session(values) };
-}
-function read_values(argv) {
-  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
-}
-function to_issues(raw) {
-  if (raw === void 0) return [];
-  const issues = raw.split(LIST_SEPARATOR);
-  return issues.some((issue) => !issue_number_shape.is_issue_number(issue)) ? void 0 : issues;
-}
-function forwarded_of(values) {
-  const pairs = ["max", "idle"].filter((name) => values[name] !== void 0);
-  if (pairs.some((name) => cli_flags.to_count(values[name]) === void 0)) return void 0;
-  return pairs.flatMap((name) => [`--${name}`, values[name] ?? ""]);
-}
-function window_of(raw) {
-  return raw === void 0 ? void 0 : Number(raw) * MS_PER_MINUTE;
-}
-function is_count_or_absent(raw) {
-  return raw === void 0 || cli_flags.to_count(raw) !== void 0;
-}
-function is_valid_single(values) {
-  const is_valid_stopped = values.stopped === void 0 || issue_number_shape.ISSUE_NUMBER_PATTERN.test(values.stopped);
-  const is_valid_counts = is_count_or_absent(values.window) && is_count_or_absent(values["triage-pid"]);
-  return is_valid_stopped && is_valid_counts;
-}
-function owner_of(values) {
-  const owner = values?.owner ?? agent_session_environment.own_session_pid()?.toString();
-  return cli_flags.to_count(owner) === void 0 ? void 0 : owner;
-}
-function to_context(values, owner) {
-  if (!is_valid_single(values)) return void 0;
-  const forwarded = forwarded_of(values);
-  const exclude = to_issues(values.exclude);
-  const awaited = to_issues(values.await);
-  if (forwarded === void 0 || exclude === void 0 || awaited === void 0) return void 0;
-  const window_ms = window_of(values.window);
-  return {
-    owner,
-    active: values.active,
-    forwarded,
-    exclude,
-    awaited,
-    window_ms,
-    window: values.window,
-    is_only: values.only === true,
-    stopped: values.stopped,
-    ...triage_flags(values)
-  };
-}
-function parse(argv) {
-  const values = read_values(argv);
-  const owner = owner_of(values);
-  return values === void 0 || owner === void 0 ? void 0 : to_context(values, owner);
-}
-function beside_flags(pid, start) {
-  if (pid === void 0) return [];
-  const named = ["--triage-pid", String(pid)];
-  if (start === void 0) return named;
-  return [...named, "--triage-start", start.split(START_SPACE).join(START_SPACE_TOKEN)];
-}
-function triage_line_flags(state) {
-  const owed = state.is_triage_owed === true ? ["--triage-owed"] : [];
-  return [...owed, ...beside_flags(state.triage_pid, state.triage_start)];
-}
-function resume_line(state, context) {
-  const exclude = [.../* @__PURE__ */ new Set([...context.exclude, ...state.exclude])];
-  const flags = ["--owner", context.owner, "--active", state.active, ...context.forwarded];
-  if (exclude.length > 0) flags.push("--exclude", exclude.join(LIST_SEPARATOR));
-  if (context.window !== void 0) flags.push("--window", context.window);
-  if (state.stopped_by !== void 0) flags.push("--stopped", state.stopped_by);
-  return `resume: ${[...flags, ...triage_line_flags(state)].join(" ")}`;
-}
-var backlog_drive_args = {
-  USAGE,
-  beside_flags,
-  parse,
-  resume_line
-};
-
-export {
-  backlog_drive_retrospective_unit,
-  backlog_drive_args
-};

package/dist/commands/chunk-CNL3SLM6.js

@@ -1,116 +0,0 @@
-import {
-  lane_implement_stats
-} from "./chunk-A3JYZWBS.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  delegation_policy
-} from "./chunk-6I2JM5UX.js";
-import {
-  run_event_scope
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/lane/lane-implement-signals.ts
-import path from "node:path";
-var LABEL = "signals";
-var KIND = run_event_stream.EVENT_KIND.LANE_PHASE;
-var PAIR_SEPARATOR = "=";
-var WORD_SEPARATOR = " ";
-var LABEL_INDEX = 1;
-var FIELDS = {
-  edits: "edits",
-  test_related: "test-related",
-  lint_related: "lint-related",
-  investigations: "investigations",
-  unplanned: "unplanned"
-};
-var OUTSIDE_PREFIXES = ["..", ".josh/"];
-var TEST_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh test:related(?![\w:-])/u;
-var LINT_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh lint:related(?![\w:-])/u;
-var EDIT_BAR = 8;
-var RERUN_BAR = 2;
-var INVESTIGATION_BAR = 1;
-var FIELD_ORDER = [
-  "edits",
-  "test_related",
-  "lint_related",
-  "investigations",
-  "unplanned"
-];
-var KEYS = [
-  { field: "unplanned", bar: 0, key: "plan divergence" },
-  { field: "edits", bar: EDIT_BAR, key: "edited files" },
-  { field: "test_related", bar: RERUN_BAR, key: "test:related reruns" },
-  { field: "lint_related", bar: RERUN_BAR, key: "lint:related reruns" },
-  { field: "investigations", bar: INVESTIGATION_BAR, key: "investigation units" }
-];
-function edited_files(calls, root) {
-  const files = calls.filter((call) => lane_implement_stats.EDIT_TOOLS.has(call.tool ?? "")).map((call) => call.file_path).filter((file) => file !== void 0).map((file) => path.relative(root, file));
-  return [...new Set(files)].filter(
-    (file) => OUTSIDE_PREFIXES.every((prefix) => !file.startsWith(prefix))
-  );
-}
-function command_count(calls, pattern) {
-  return calls.filter((call) => pattern.test(call.command ?? "")).length;
-}
-function is_investigator(call) {
-  return call.subagent?.type.split(":").at(-1) === delegation_policy.INVESTIGATOR_AGENT;
-}
-function counts_of(calls, planned, root) {
-  const edits = edited_files(calls, root);
-  const plan = new Set(planned);
-  const outside = edits.filter((file) => !plan.has(file) && !test_declared_logic.is_test_file(file));
-  return {
-    edits: edits.length,
-    test_related: command_count(calls, TEST_RELATED),
-    lint_related: command_count(calls, LINT_RELATED),
-    investigations: calls.filter((call) => is_investigator(call)).length,
-    unplanned: outside.length
-  };
-}
-function text_of(issue, signals) {
-  const pairs = FIELD_ORDER.map(
-    (field) => `${FIELDS[field]}${PAIR_SEPARATOR}${String(signals[field])}`
-  );
-  return [issue_cite.plain_for("program", issue), LABEL, ...pairs].join(WORD_SEPARATOR);
-}
-function is_signals_of(event, issue) {
-  const label = event.text.split(WORD_SEPARATOR)[LABEL_INDEX];
-  return event.kind === KIND && label === LABEL && run_event_scope.issue_named(event) === String(issue);
-}
-function pair_of(word) {
-  const [name = "", value = ""] = word.split(PAIR_SEPARATOR);
-  return [name, value];
-}
-function parse(text) {
-  const pairs = new Map(text.split(WORD_SEPARATOR).map((word) => pair_of(word)));
-  function read(field) {
-    return Number(pairs.get(FIELDS[field]) ?? 0);
-  }
-  return {
-    edits: read("edits"),
-    test_related: read("test_related"),
-    lint_related: read("lint_related"),
-    investigations: read("investigations"),
-    unplanned: read("unplanned")
-  };
-}
-function signals_of(events, issue) {
-  const event = events.findLast((candidate) => is_signals_of(candidate, issue));
-  return event === void 0 ? void 0 : parse(event.text);
-}
-function keys_of(signals) {
-  return KEYS.filter(({ field, bar }) => signals[field] > bar).map(({ key }) => key);
-}
-var lane_implement_signals = { KIND, counts_of, is_signals_of, keys_of, signals_of, text_of };
-
-export {
-  lane_implement_signals
-};

package/dist/commands/chunk-CNQ7D2GZ.js

@@ -1,104 +0,0 @@
-import {
-  git_worktree
-} from "./chunk-WNBJK6QE.js";
-import {
-  IGNORED_CACHE_FILES
-} from "./chunk-TBIX5FRN.js";
-import {
-  ENV_FILE_NAME
-} from "./chunk-IGD6QJPH.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-
-// scripts/git/git-remote-branch.ts
-async function ask(branch_name) {
-  try {
-    const heads = await git_worktree.ls_remote_branch(branch_name);
-    return heads.trim() === "" ? "absent" : "present";
-  } catch {
-    return "unreachable";
-  }
-}
-var git_remote_branch = {
-  ask
-};
-
-// scripts/lane/lane-leftover.ts
-import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, rmSync } from "node:fs";
-import path from "node:path";
-var REGENERATED_PATHS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  ENV_FILE_NAME,
-  ...IGNORED_CACHE_FILES
-]);
-var GIT_POINTER = ".git";
-var GITDIR_PREFIX = "gitdir: ";
-var NAMED_PATH_LIMIT = 10;
-function parse_objects(listing) {
-  return new Set(listing.split("\n").map((line) => line.split(" ", 1)[0] ?? ""));
-}
-async function recoverable_objects() {
-  return parse_objects(await git_spawn.read(["rev-list", "--objects", "--all"]));
-}
-function blob_id(file) {
-  const content = lstatSync(file).isSymbolicLink() ? Buffer.from(readlinkSync(file)) : readFileSync(file);
-  return createHash("sha1").update(`blob ${String(content.length)}\0`).update(content).digest("hex");
-}
-function walk_files(directory, relative) {
-  return readdirSync(path.join(directory, relative), { withFileTypes: true }).flatMap((entry) => {
-    const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
-    return entry.isDirectory() ? walk_files(directory, child) : child;
-  });
-}
-function list_files(directory) {
-  return readdirSync(directory).filter((name) => !REGENERATED_PATHS.has(name)).flatMap(
-    (name) => lstatSync(path.join(directory, name)).isDirectory() ? walk_files(directory, name) : name
-  );
-}
-function is_dangling_pointer(directory) {
-  const file = path.join(directory, GIT_POINTER);
-  if (!lstatSync(file).isFile()) return false;
-  const pointer = readFileSync(file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX)) return false;
-  return !existsSync(path.resolve(directory, pointer.slice(GITDIR_PREFIX.length)));
-}
-function is_reclaimable_file(directory, relative, recoverable) {
-  if (relative === GIT_POINTER) return is_dangling_pointer(directory);
-  return recoverable.has(blob_id(path.join(directory, relative)));
-}
-function foreign_paths(directory, recoverable) {
-  const pointer = lstatSync(path.join(directory, GIT_POINTER), { throwIfNoEntry: false });
-  if (pointer?.isDirectory() === true) return [GIT_POINTER];
-  return list_files(directory).filter(
-    (relative) => !is_reclaimable_file(directory, relative, recoverable)
-  );
-}
-function refusal(directory, foreign) {
-  const named = foreign.slice(0, NAMED_PATH_LIMIT).join(", ");
-  const rest = foreign.length - NAMED_PATH_LIMIT;
-  const more = rest > 0 ? ` and ${String(rest)} more` : "";
-  return new Error(
-    `${directory} already exists but git does not register it as a work tree, and it holds files the repository does not: ${named}${more}. It was left in place so nothing is lost \u2014 move those files out, delete the directory, and open the lane again.`
-  );
-}
-async function reclaim(directory) {
-  if (!existsSync(directory)) return;
-  const foreign = foreign_paths(directory, await recoverable_objects());
-  if (foreign.length > 0) throw refusal(directory, foreign);
-  rmSync(directory, { force: true, recursive: true });
-}
-var lane_leftover = {
-  blob_id,
-  foreign_paths,
-  parse_objects,
-  reclaim,
-  recoverable_objects
-};
-
-export {
-  git_remote_branch,
-  lane_leftover
-};

package/dist/commands/chunk-COGKULQH.js

@@ -1,119 +0,0 @@
-import {
-  baseline_measure
-} from "./chunk-BMM4RHCG.js";
-import {
-  reproduction_measure
-} from "./chunk-6TIVDEKG.js";
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-
-// scripts/rules/firing-point.ts
-var HOOK_DELIVERABLE_TOOLS = [
-  "Bash",
-  "Edit",
-  "Read",
-  "Write",
-  "AskUserQuestion",
-  "Agent",
-  "Task",
-  "Glob",
-  "Grep",
-  "WebFetch",
-  "Stop"
-];
-var KNOWN_UNDELIVERABLE_TOOLS = ["WebSearch", "TodoWrite", "NotebookEdit"];
-function includes_name(names, name) {
-  return names.includes(name.trim());
-}
-function classify(name) {
-  if (includes_name(HOOK_DELIVERABLE_TOOLS, name)) return "delivered";
-  if (includes_name(KNOWN_UNDELIVERABLE_TOOLS, name)) return "not-delivered";
-  return "unknown";
-}
-var firing_point = {
-  HOOK_DELIVERABLE_TOOLS,
-  KNOWN_UNDELIVERABLE_TOOLS,
-  classify
-};
-
-// scripts/issue/behavior-change-lint.ts
-var DECLARATION_LINE = issue_body_keys.line("kind", "behavior_change");
-var FIRING_POINT_HEADING = issue_body_keys.heading("trigger");
-var BASELINE_HEADING = issue_body_keys.heading("baseline");
-var REPRODUCTION_HEADING = issue_body_keys.heading("reproduction");
-var REQUIRED_HEADINGS = [
-  FIRING_POINT_HEADING,
-  BASELINE_HEADING,
-  REPRODUCTION_HEADING
-];
-var PLACEHOLDER_PREFIX = "<";
-var BACKTICKED = /`([^`]+)`/u;
-var WHITESPACE = /\s+/u;
-var BULLET_MARKER = /^[-*]\s+/u;
-function is_target(body) {
-  return markdown_section.has_line(body, DECLARATION_LINE);
-}
-function missing_headings(body) {
-  return REQUIRED_HEADINGS.filter((heading) => !markdown_section.has_line(body, heading));
-}
-function is_content(line) {
-  return line.length > 0 && !line.startsWith(PLACEHOLDER_PREFIX);
-}
-function first_content_line(lines) {
-  return lines.map((line) => line.trim()).find((line) => is_content(line));
-}
-function firing_point_name(body) {
-  const line = first_content_line(markdown_section.section_lines(body, FIRING_POINT_HEADING));
-  if (line === void 0) return void 0;
-  return BACKTICKED.exec(line)?.[1] ?? line.replace(BULLET_MARKER, "").split(WHITESPACE, 1)[0];
-}
-function firing_point_problem(body) {
-  const name = firing_point_name(body);
-  if (name === void 0) return void 0;
-  if (firing_point.classify(name) === "not-delivered") {
-    return `firing point \`${name}\` is a real tool call, but no hook can deliver a rule on it`;
-  }
-  if (firing_point.classify(name) === "unknown") {
-    return `firing point \`${name}\` is not on the delivery table (not a recognized tool call)`;
-  }
-  return void 0;
-}
-function baseline_problem(body) {
-  if (!markdown_section.has_line(body, BASELINE_HEADING) || baseline_measure.has_command_value(body)) {
-    return void 0;
-  }
-  return "baseline must be written as `command \u2192 value`, not prose (it has to be re-runnable)";
-}
-function reproduction_problem(body) {
-  if (!markdown_section.has_line(body, REPRODUCTION_HEADING) || reproduction_measure.has_command_output(body)) {
-    return void 0;
-  }
-  return 'reproduction must be a command and its actual output (a fenced block), not prose ("\u78BA\u8A8D\u3057\u305F" is not re-runnable)';
-}
-function heading_problems(body) {
-  return missing_headings(body).map((heading) => `missing heading: ${heading}`);
-}
-function problems(body) {
-  if (!is_target(body)) return [];
-  return [
-    ...heading_problems(body),
-    firing_point_problem(body),
-    baseline_problem(body),
-    reproduction_problem(body)
-  ].filter((problem) => problem !== void 0);
-}
-var behavior_change_lint = {
-  is_target,
-  firing_point_name,
-  problems,
-  REQUIRED_HEADINGS,
-  DECLARATION_LINE
-};
-
-export {
-  behavior_change_lint
-};