@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-QUO5B2JH.js

@@ -0,0 +1,260 @@
+import {
+  lane_cache_run
+} from "./chunk-7WTVADW4.js";
+import {
+  lint_timing
+} from "./chunk-OB3WF3DW.js";
+import {
+  eslint_daemon
+} from "./chunk-KTV2HNWB.js";
+import {
+  eslint_cache_dependencies
+} from "./chunk-UBWYGOEC.js";
+import {
+  verification_inputs
+} from "./chunk-HQ5U6OZR.js";
+import {
+  lint_shard
+} from "./chunk-ZECFKW7D.js";
+import {
+  lint_related_scope
+} from "./chunk-BBPESBU3.js";
+import {
+  changed_file_scope
+} from "./chunk-MEJ2CQK2.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  ESLINT_CACHE_FILE,
+  ESLINT_CACHE_FLAGS,
+  PRETTIER_CACHE_FLAGS
+} from "./chunk-TBIX5FRN.js";
+import {
+  eslint_heap
+} from "./chunk-CGYDIYHD.js";
+import {
+  FAIL_EXIT_CODE,
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/lint/lint-parallel.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// scripts/lint/lint-gate-scope.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { environment_flags } from "@joshuafolkken/kit/env";
+var GATE_CACHES = {
+  eslint_file: ESLINT_CACHE_FILE,
+  eslint_flags: ESLINT_CACHE_FLAGS,
+  prettier_flags: PRETTIER_CACHE_FLAGS
+};
+var CI_REASON = "CI lints the whole tree";
+var CONFIG_REASON = "a changed file configures the toolchain or the linters";
+var VOCABULARY = {
+  label: "josh lint --changed",
+  fallback_suffix: "checking the whole tree instead",
+  narrowed_suffix: "checking only them"
+};
+function all_scope(reason) {
+  return { mode: "all", files: [], reason };
+}
+function configures_lint(files, root) {
+  return verification_inputs.configures(
+    gate_labels.LINT_LABEL,
+    files.map((file) => path.relative(root, file).split(path.sep).join("/")),
+    root
+  );
+}
+function resolve_gate_scope(files, root, environment) {
+  if (environment_flags.is_ci_enabled(environment["CI"])) return all_scope(CI_REASON);
+  if (files !== void 0 && configures_lint(files, root)) return all_scope(CONFIG_REASON);
+  return changed_file_scope.resolve_scope(files, lint_related_scope.scope_inputs(existsSync));
+}
+function narrowed_run(files) {
+  return {
+    prettier: lint_related_scope.prettier_arguments(files, GATE_CACHES),
+    eslint: lint_related_scope.eslint_arguments(files, GATE_CACHES),
+    eslint_cache_file: GATE_CACHES.eslint_file
+  };
+}
+function describe_scope(scope, root) {
+  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+}
+var lint_gate_scope = {
+  CHANGED_FLAG: "--changed",
+  CI_REASON,
+  CONFIG_REASON,
+  describe_scope,
+  narrowed_run,
+  resolve_gate_scope
+};
+
+// scripts/lint/lint-parallel.ts
+function eslint_args_of(shard) {
+  return ["exec", "eslint", ...lint_shard.eslint_targets(shard), ...ESLINT_CACHE_FLAGS];
+}
+var ESLINT_ARGS = eslint_args_of(void 0);
+function prettier_check_args(targets) {
+  return ["exec", "prettier", "--check", ...targets, ...PRETTIER_CACHE_FLAGS];
+}
+var PRETTIER_ARGS = prettier_check_args([lint_shard.WHOLE_TREE]);
+function project_prettier_args() {
+  return prettier_check_args(
+    project_checks.prettier_targets(process.cwd(), [lint_shard.WHOLE_TREE])
+  );
+}
+var LEFT_TO_FORMATTING_SHARD = {
+  output: `josh prettier: ${lint_shard.FORMATTING_SHARD_REASON}.
+`,
+  exit_code: 0,
+  elapsed_ms: 0
+};
+function prettier_args_of(shard) {
+  return lint_shard.checks_formatting(shard) ? project_prettier_args() : void 0;
+}
+var GATE_TIMING_LABEL = "lint";
+var COLD_RUN = { warm_daemon: false };
+async function run_eslint_process(eslint) {
+  if (eslint.warm_daemon) return await eslint_daemon.run_or_cold(eslint.args, eslint.call);
+  return await eslint_heap.run_cold(eslint.args);
+}
+async function run_eslint(eslint) {
+  const { cache_file } = eslint;
+  return await lane_cache_run.run(cache_file, async () => {
+    const is_cached = existsSync2(cache_file);
+    const { result, drop } = await eslint_cache_dependencies.guard_counted(
+      cache_file,
+      async () => await run_eslint_process(eslint)
+    );
+    return { ...result, is_cached, drop };
+  });
+}
+function write_output(result) {
+  const { output } = result;
+  if (!output) return;
+  process.stdout.write(output.endsWith("\n") ? output : `${output}
+`);
+}
+function skipped(check, reason) {
+  return { output: `${project_checks.skip_notice(check, reason)}
+`, exit_code: 0, elapsed_ms: 0 };
+}
+async function run_prettier(directory, prettier_args) {
+  if (prettier_args === void 0) return LEFT_TO_FORMATTING_SHARD;
+  const reason = project_checks.prettier_skip_reason(directory);
+  if (reason !== void 0) return skipped("prettier", reason);
+  return await buffered_process.run_buffered_direct(prettier_args);
+}
+async function run_checked_eslint(directory, eslint) {
+  const reason = project_checks.eslint_skip_reason(directory);
+  if (reason !== void 0) return skipped("eslint", reason);
+  return await run_eslint(eslint);
+}
+function is_silent_pass(result) {
+  return result.output === "" && !buffered_process.is_process_failed(result);
+}
+function with_ran_notice(check, result, sibling) {
+  if (!sibling.output.includes(SKIP_MARKER) || !is_silent_pass(result)) return result;
+  return { ...result, output: `${project_checks.ran_notice(check)}
+` };
+}
+function lint_exit_code(prettier, eslint) {
+  return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint) ? FAIL_EXIT_CODE : 0;
+}
+async function run_lint_pair(prettier_args, eslint_args, cache_file, options) {
+  const directory = process.cwd();
+  const [prettier, eslint] = await Promise.all([
+    run_prettier(directory, prettier_args),
+    run_checked_eslint(directory, { args: eslint_args, cache_file, ...options })
+  ]);
+  return { prettier, eslint };
+}
+function write_lint_pair({ prettier, eslint }) {
+  write_output(with_ran_notice("prettier", prettier, eslint));
+  write_output(with_ran_notice("eslint", eslint, prettier));
+  return lint_exit_code(prettier, eslint);
+}
+function timing_line(pair, label, facts) {
+  const { prettier, eslint } = pair;
+  return lint_timing.line({
+    label,
+    prettier_ms: prettier.elapsed_ms,
+    eslint_ms: eslint.elapsed_ms,
+    facts
+  });
+}
+function daemon_fact(eslint) {
+  return eslint.daemon ?? "cold process";
+}
+function drop_fact({ dropped, total }) {
+  return `${String(dropped)} of ${String(total)} cache entries dropped`;
+}
+function cache_fact(eslint) {
+  if (eslint.is_cached !== true) return "cache absent";
+  return eslint.drop === void 0 ? "cache present" : `cache present \xB7 ${drop_fact(eslint.drop)}`;
+}
+async function run_lint_checks(prettier_args, eslint_args, cache_file, options = COLD_RUN) {
+  const { timing } = options;
+  if (timing === void 0) {
+    return write_lint_pair(await run_lint_pair(prettier_args, eslint_args, cache_file, options));
+  }
+  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, options);
+  const exit_code = write_lint_pair(pair);
+  const facts = [timing.targets, daemon_fact(pair.eslint), cache_fact(pair.eslint)];
+  process.stdout.write(timing_line(pair, timing.label, facts));
+  return exit_code;
+}
+async function run_timed_lint_checks(prettier_args, eslint_args, cache_file) {
+  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, COLD_RUN);
+  const exit_code = write_lint_pair(pair);
+  process.stdout.write(timing_line(pair, GATE_TIMING_LABEL, [cache_fact(pair.eslint)]));
+  return exit_code;
+}
+async function run_lint_parallel_checks(options = COLD_RUN) {
+  return await run_lint_checks(project_prettier_args(), ESLINT_ARGS, ESLINT_CACHE_FILE, options);
+}
+async function run_whole_lint_checks(scope_line, shard) {
+  process.stdout.write(`${scope_line}${lint_shard.describe(shard)}
+`);
+  return await run_timed_lint_checks(
+    prettier_args_of(shard),
+    eslint_args_of(shard),
+    ESLINT_CACHE_FILE
+  );
+}
+async function run_changed_lint_checks(shard) {
+  const root = await changed_file_scope.repository_root_or_cwd();
+  const files = await changed_file_scope.read_changed_files(root);
+  const scope = lint_gate_scope.resolve_gate_scope(files, root, process.env);
+  const scope_line = lint_gate_scope.describe_scope(scope, root);
+  if (scope.mode === "all") return await run_whole_lint_checks(scope_line, shard);
+  process.stdout.write(`${scope_line}
+`);
+  const narrowed = lint_gate_scope.narrowed_run(scope.files);
+  return await run_timed_lint_checks(narrowed.prettier, narrowed.eslint, narrowed.eslint_cache_file);
+}
+async function run_lint_command(command_arguments) {
+  const shard = lint_shard.shard_of(command_arguments);
+  if (command_arguments.includes(lint_gate_scope.CHANGED_FLAG)) {
+    return await run_changed_lint_checks(shard);
+  }
+  return await run_lint_checks(prettier_args_of(shard), eslint_args_of(shard), ESLINT_CACHE_FILE);
+}
+var lint_parallel = {
+  run_eslint,
+  run_lint_checks,
+  run_lint_command,
+  run_lint_parallel_checks
+};
+
+export {
+  lint_parallel
+};

package/dist/commands/chunk-QY7RITZQ.js

@@ -0,0 +1,99 @@
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/rules/rule-value-cache.ts
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import path from "node:path";
+var FALLBACK_DIRECTORY = ["node_modules", ".cache", "josh"];
+var CACHE_FILE = "rule-value.txt";
+var STAMP_FILE = "rule-value.stamp";
+var REFRESH_MINUTES = 15;
+var REFRESH_MS = REFRESH_MINUTES * MS_PER_MINUTE;
+var REFRESH_ARGV = ["josh", "rule:value", "--refresh"];
+var PNPM = "pnpm";
+function cache_path(cwd, file) {
+  const common = git_common_directory.repository(cwd);
+  if (common === void 0) return path.join(cwd, ...FALLBACK_DIRECTORY, file);
+  return path.join(common, git_common_directory.STATE_DIRECTORY, file);
+}
+function read_cached(cwd) {
+  return file_reader.read_if_readable(cache_path(cwd, CACHE_FILE));
+}
+function taken_at_if_fresh(cwd, now_ms) {
+  try {
+    const { mtime } = statSync(cache_path(cwd, CACHE_FILE));
+    return now_ms - mtime.getTime() < REFRESH_MS ? mtime : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function read_fresh(cwd = process.cwd(), now_ms = Date.now()) {
+  const taken_at = taken_at_if_fresh(cwd, now_ms);
+  if (taken_at === void 0) return void 0;
+  const text = read_cached(cwd);
+  return text === void 0 ? void 0 : { text, taken_at };
+}
+function is_refresh_due(cwd, now_ms) {
+  try {
+    return now_ms - statSync(cache_path(cwd, STAMP_FILE)).mtimeMs >= REFRESH_MS;
+  } catch {
+    return true;
+  }
+}
+function write_cache_file(cwd, file, text) {
+  atomic_write.replace_file(cache_path(cwd, file), text);
+}
+function ignore_spawn_error() {
+}
+function start_refresh_default(cwd) {
+  const child = spawn(PNPM, REFRESH_ARGV, { cwd, detached: true, stdio: "ignore" });
+  child.on("error", ignore_spawn_error);
+  child.unref();
+}
+var DEFAULT_PORTS = { now: Date.now, start_refresh: start_refresh_default };
+function is_linked_work_tree(cwd) {
+  return git_common_directory.resolve(cwd) !== void 0;
+}
+function refresh_if_due(cwd, ports) {
+  if (is_linked_work_tree(cwd) || !is_refresh_due(cwd, ports.now())) return;
+  write_cache_file(cwd, STAMP_FILE, new Date(ports.now()).toISOString());
+  ports.start_refresh(cwd);
+}
+function emit(cwd = process.cwd(), ports = DEFAULT_PORTS) {
+  const cached = read_cached(cwd);
+  if (cached !== void 0) process.stderr.write(cached);
+  try {
+    refresh_if_due(cwd, ports);
+  } catch {
+  }
+}
+function store(text, cwd = process.cwd()) {
+  if (is_linked_work_tree(cwd)) return;
+  write_cache_file(cwd, CACHE_FILE, `${text}
+`);
+}
+var rule_value_cache = {
+  CACHE_FILE,
+  REFRESH_MS,
+  STAMP_FILE,
+  cache_path,
+  emit,
+  is_linked_work_tree,
+  read_fresh,
+  store
+};
+
+export {
+  rule_value_cache
+};

package/dist/commands/chunk-R4GZWGIN.js

@@ -0,0 +1,160 @@
+import {
+  run_ship_lap
+} from "./chunk-3W2TJZMD.js";
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  direct_importers
+} from "./chunk-7GICNM73.js";
+import {
+  related_scope
+} from "./chunk-QA44M56F.js";
+import {
+  tree_verdict
+} from "./chunk-V6WHDQAZ.js";
+import {
+  scoped_green
+} from "./chunk-77R6JEET.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  test_unit_guard
+} from "./chunk-TXXEXJAV.js";
+import {
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+
+// scripts/test/test-related-touched.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+var TOUCHED_FLAG = "--touched";
+var TOUCHED_KIND = "touched";
+var TEST_SUFFIX = ".test.ts";
+var TOUCHED_REASON = "the diff test files, their modules' same-named tests, direct test importers and pinned tests";
+var NOTHING_TOUCHED_REASON = "no changed file reaches a touched test";
+function list_directory(directory) {
+  try {
+    return readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function is_named_after(module_file, name) {
+  const stem = path.basename(module_file, path.extname(module_file));
+  return name.startsWith(`${stem}.`) && name.endsWith(TEST_SUFFIX);
+}
+function tests_of(root, file, list) {
+  const directory = path.dirname(file);
+  const names = list(path.join(root, directory));
+  if (file.endsWith(TEST_SUFFIX)) return names.includes(path.basename(file)) ? [file] : [];
+  if (!related_scope.is_relatable(file)) return [];
+  return names.filter((name) => is_named_after(file, name)).map((name) => path.join(directory, name));
+}
+function touched_tests(root, changed, list = list_directory) {
+  const tests = changed.flatMap((file) => tests_of(root, file, list));
+  return [.../* @__PURE__ */ new Set([...tests, ...test_related_pins.pinned_tests(changed)])];
+}
+function touched_scope(root, changed, list = list_directory) {
+  const { UNREADABLE_REASON } = related_scope;
+  if (changed === void 0) return { mode: "all", files: [], reason: UNREADABLE_REASON };
+  const files = touched_tests(root, changed, list).map((file) => path.join(root, file));
+  if (files.length === 0) return { mode: "none", files: [], reason: NOTHING_TOUCHED_REASON };
+  return { mode: "related", files, reason: TOUCHED_REASON };
+}
+async function read_scope(root, changed) {
+  if (changed === void 0) return touched_scope(root, changed);
+  const importers = await direct_importers.importers_of(
+    root,
+    changed.filter((file) => related_scope.is_relatable(file))
+  );
+  return touched_scope(root, [...changed, ...[...importers.values()].flat()]);
+}
+var test_related_touched = {
+  NOTHING_TOUCHED_REASON,
+  TOUCHED_FLAG,
+  TOUCHED_KIND,
+  TOUCHED_REASON,
+  read_scope,
+  touched_scope,
+  touched_tests
+};
+
+// scripts/test/test-related-verdict.ts
+function touched_target() {
+  return tree_verdict.record_path("test-related-touched-review");
+}
+async function record_touched(given, before, exit_code) {
+  if (given.length !== 1 || given[0] !== test_related_touched.TOUCHED_FLAG) return;
+  await scoped_green.record_if_green(review_stamps.test_related_stamp, {
+    before,
+    exit_code,
+    target: touched_target()
+  });
+}
+function target_of(given) {
+  const arguments_hash = input_fingerprint.of_entries([JSON.stringify([process.cwd(), given])]);
+  return tree_verdict.record_path(`test-related-${arguments_hash}`);
+}
+async function fresh_verdict(before, target, fresh) {
+  const exit_code = await fresh(before);
+  const tail = `${verification_tail.format_verdict("josh test:related", [])}
+`;
+  if (exit_code === 0) {
+    await tree_verdict.record({ before, exit_code, tail }, gate_tree.read_gate_tree, target);
+  }
+  return { exit_code, is_reused: false };
+}
+function preserved_blobs(before) {
+  if (before === void 0) return void 0;
+  const stamp = review_stamps.test_related_stamp.read();
+  if (stamp === void 0 || !scoped_green.is_unmoved(before, { files: stamp.files, base: stamp.base }) || !review_stamps.test_related_stamp.describes_inputs(stamp)) {
+    return void 0;
+  }
+  return stamp.blobs;
+}
+async function reused_verdict(given, before, target, kept) {
+  if (given.length === 0) {
+    const blobs = preserved_blobs(before);
+    await scoped_green.record_if_green(review_stamps.test_related_stamp, {
+      before,
+      exit_code: 0,
+      ...blobs !== void 0 && { blobs }
+    });
+  }
+  await record_touched(given, before, 0);
+  return { exit_code: tree_verdict.replay(kept, target), is_reused: true };
+}
+async function checked(given, fresh) {
+  const before = await scoped_green.read_before([]);
+  const target = target_of(given);
+  const kept = tree_verdict.read(before, target);
+  if (kept?.exit_code === 0) return await reused_verdict(given, before, target, kept);
+  const result = await fresh_verdict(before, target, fresh);
+  await record_touched(given, before, result.exit_code);
+  return result;
+}
+async function run(given, fresh) {
+  if (!test_unit_guard.is_running(process.cwd())) return await fresh(void 0);
+  const outcome = await run_ship_lap.timed(
+    "test:related",
+    async () => await checked(given, fresh),
+    {
+      note_of: (result) => ({ is_reused: result.is_reused })
+    }
+  );
+  return outcome.exit_code;
+}
+var test_related_verdict = { run, touched_target };
+
+export {
+  test_related_touched,
+  test_related_verdict
+};

package/dist/commands/chunk-RETTGONB.js

@@ -0,0 +1,84 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.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-RH4LJ4D6.js

@@ -0,0 +1,69 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/baseline-measure.ts
+var BASELINE_HEADING = issue_body_keys.heading("baseline");
+var BASELINE_LINE = /^-\s*`([^`]+)`\s*(?:→|->)\s*(\S.*)$/u;
+var VALUE_GROUP = 2;
+var LEDGER_KEY_PREFIX = "- k:";
+var LEDGER_DEPTH = "d1";
+var FIELD_SEPARATOR = " | ";
+var FIELD_SEPARATOR_REPLACEMENT = " ; ";
+var REMEASURE_COMMAND = "pnpm josh measure:rerun";
+var NON_SLUG_RUN = /[^a-z0-9]+/gu;
+var EMPTY_SLUG_FALLBACK = "baseline";
+function normalize(value) {
+  return value.trim();
+}
+function parse_baselines(body) {
+  return markdown_section.section_lines(body, BASELINE_HEADING).map((line) => BASELINE_LINE.exec(line.trim())).filter((match) => match !== null).map((match) => ({ command: match[1] ?? "", value: normalize(match[VALUE_GROUP] ?? "") }));
+}
+function has_command_value(body) {
+  return parse_baselines(body).length > 0;
+}
+function is_no_change(before, after) {
+  return normalize(before) === normalize(after);
+}
+function format_pair(baseline, after) {
+  return [
+    `\`${baseline.command}\``,
+    `  before: ${normalize(baseline.value)}`,
+    `  after:  ${normalize(after)}`
+  ].join("\n");
+}
+function sanitize_field(text) {
+  return text.split(FIELD_SEPARATOR).join(FIELD_SEPARATOR_REPLACEMENT).trim();
+}
+function slug_of(command) {
+  const runs = command.toLowerCase().replaceAll(NON_SLUG_RUN, "-").split("-");
+  const slug = runs.filter(Boolean).join("-");
+  return slug === "" ? EMPTY_SLUG_FALLBACK : slug;
+}
+function ledger_line(baseline, date) {
+  const what = sanitize_field(
+    `\u53CD\u8A3C: ${baseline.command} \u306F before/after \u3068\u3082 ${normalize(baseline.value)}\uFF08\u5909\u5316\u306A\u3057\uFF09`
+  );
+  return [
+    `${LEDGER_KEY_PREFIX}${slug_of(baseline.command)}`,
+    LEDGER_DEPTH,
+    date,
+    REMEASURE_COMMAND,
+    what
+  ].join(FIELD_SEPARATOR);
+}
+var baseline_measure = {
+  parse_baselines,
+  has_command_value,
+  is_no_change,
+  format_pair,
+  ledger_line,
+  slug_of
+};
+
+export {
+  baseline_measure
+};