@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-HLQVLQEB.js

@@ -0,0 +1,177 @@
+import {
+  confirmation_options,
+  telegram_notify
+} from "./chunk-MQNKIKJ6.js";
+import {
+  github_issue_url
+} from "./chunk-S4X5PJV7.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_repo
+} from "./chunk-QRY55H5U.js";
+import {
+  git_error
+} from "./chunk-XMZJB7JP.js";
+import {
+  josh_environment_file
+} from "./chunk-NFKULY26.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/notify/telegram-test-logic.ts
+var VALID_TASK_TYPES = [
+  "planning",
+  "completion",
+  "failure",
+  "warning",
+  "kickoff_retry",
+  "confirmation"
+];
+var DEFAULT_TASK_TYPE = "planning";
+function parse_task_type(raw) {
+  if (raw === void 0) return DEFAULT_TASK_TYPE;
+  const matched = VALID_TASK_TYPES.find((candidate) => candidate === raw);
+  if (matched === void 0) {
+    throw new Error(`Invalid --task-type: ${raw}. Expected one of ${VALID_TASK_TYPES.join(", ")}.`);
+  }
+  return matched;
+}
+var has_flag_value = cli_body.has_value;
+function coalesce(primary, fallback) {
+  if (has_flag_value(primary)) return primary;
+  return fallback;
+}
+function normalize_body(values) {
+  return cli_body.resolve({
+    inline: values.body,
+    file_path: values["body-file"],
+    inline_flag: "--body",
+    file_flag: "--body-file"
+  });
+}
+function require_recommended(values) {
+  const recommended = values.recommended?.trim() ?? "";
+  if (recommended.length === 0) {
+    throw new Error('--task-type confirmation needs --recommended "<the recommended choice>".');
+  }
+  return recommended;
+}
+function given_alternatives(values) {
+  return (values.alternative ?? []).filter((alternative) => alternative.trim().length > 0);
+}
+function build_choices(values, task_type) {
+  if (task_type !== "confirmation") return void 0;
+  return confirmation_options.block({
+    recommended: require_recommended(values),
+    alternatives: given_alternatives(values)
+  });
+}
+function build_input(input) {
+  const task_type = parse_task_type(input.values["task-type"]);
+  return {
+    task_type,
+    repo_name: coalesce(input.values["repo-name"], input.context.repo_name),
+    issue_title: coalesce(input.values["issue-title"], input.context.issue_title),
+    body: normalize_body(input.values),
+    choices: build_choices(input.values, task_type),
+    issue_url: input.values["issue-url"],
+    pr_url: input.values["pr-url"]
+  };
+}
+var telegram_test_logic = {
+  build_input,
+  parse_task_type,
+  has_flag_value
+};
+
+// scripts/notify/telegram-test.ts
+var REPO_NAME_SEPARATOR = "/";
+var ARGV_OFFSET = 2;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh notify [--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...";
+var FREE_TEXT_FLAGS = ["--body", "--issue-title", "--recommended", "--alternative"];
+var OPTIONS = {
+  "task-type": { type: "string" },
+  "repo-name": { type: "string" },
+  "issue-title": { type: "string" },
+  body: { type: "string" },
+  "body-file": { type: "string" },
+  "issue-url": { type: "string" },
+  "pr-url": { type: "string" },
+  recommended: { type: "string" },
+  alternative: { type: "string", multiple: true }
+};
+function parse_cli_arguments() {
+  return cli_flags.values_of(
+    cli_flags.attach_values(process.argv.slice(ARGV_OFFSET), FREE_TEXT_FLAGS),
+    OPTIONS
+  );
+}
+function refuse_usage() {
+  console.error(USAGE);
+  process.exitCode = FAILURE_EXIT_CODE;
+}
+async function fetch_repo_name() {
+  try {
+    const name_with_owner = await git_gh_repo.repo_get_name_with_owner();
+    return name_with_owner?.split(REPO_NAME_SEPARATOR).at(-1);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F  Could not read the repository name, sending without it: ${String(error)}`);
+    return void 0;
+  }
+}
+async function fetch_issue_title(target) {
+  if (target === void 0) return void 0;
+  const title = await git_gh_issue_read.issue_get_title(target.issue_number, target.name_with_owner);
+  if (title === void 0) {
+    console.warn(
+      `\u26A0\uFE0F  Could not read ${session_cite.issue(target.issue_number, void 0, target.name_with_owner)}.`
+    );
+  }
+  return title;
+}
+async function resolve_issue_title(values, target) {
+  if (telegram_test_logic.has_flag_value(values["issue-title"])) return void 0;
+  return await fetch_issue_title(target);
+}
+async function resolve_context(values) {
+  const target = github_issue_url.parse(values["issue-url"]);
+  const pull_target = github_issue_url.parse_pull(values["pr-url"]);
+  const repo_name = target?.repo ?? pull_target?.repo ?? await fetch_repo_name();
+  const issue_title = await resolve_issue_title(values, target);
+  return { repo_name, issue_title };
+}
+async function send_values(values) {
+  const context = await resolve_context(values);
+  await telegram_notify.send(telegram_test_logic.build_input({ values, context }));
+}
+async function main() {
+  josh_environment_file.load_environment_file();
+  const values = parse_cli_arguments();
+  if (values === void 0) {
+    refuse_usage();
+    return;
+  }
+  await send_values(values);
+}
+async function run_cli() {
+  try {
+    await main();
+  } catch (error) {
+    git_error.handle(error);
+  }
+}
+var telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli, send_values };
+
+export {
+  telegram_test
+};

package/dist/commands/chunk-HN3EGYAI.js

@@ -0,0 +1,169 @@
+import {
+  epic_body,
+  epic_promote
+} from "./chunk-LJZERYLG.js";
+import {
+  epic_relations
+} from "./chunk-BAJABWKW.js";
+import {
+  epic_validate
+} from "./chunk-C7JEMYPV.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  EPIC_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-run.ts
+var EPIC_LABEL_COLOR = "#5319e7";
+var EPIC_LABEL_DESCRIPTION = "Tracks a batch of child issues from one split";
+var FAILURE_EXIT_CODE = 1;
+var SUCCESS_EXIT_CODE = 0;
+async function apply_dependencies(input) {
+  const pairs = epic_body.build_dependency_pairs(input.children, input.is_ordered);
+  if (pairs.length === 0) return;
+  const failures = await epic_relations.apply_relations(pairs, "record");
+  console.info(
+    epic_relations.format_relation_report({
+      links: pairs,
+      failures,
+      action: "record"
+    })
+  );
+}
+var ISSUE_URL_NUMBER = /\/(?<number>\d+)\s*$/u;
+function parse_created_number(url) {
+  const { groups } = ISSUE_URL_NUMBER.exec(url.trim()) ?? {};
+  const { number: raw } = groups ?? {};
+  if (raw === void 0) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+async function fill_run_command(epic_number, input) {
+  if (epic_number === void 0) {
+    console.info(
+      `\u26A0\uFE0F  Could not read the new epic's number from its URL; the Execution section still says \`${epic_body.format_run_command(void 0)}\`.`
+    );
+    return;
+  }
+  try {
+    await git_gh_command.issue_edit_body(
+      String(epic_number),
+      epic_body.build_epic_body({
+        children: input.children,
+        rationale: input.rationale,
+        is_ordered: input.is_ordered,
+        origin: input.origin,
+        epic_number
+      })
+    );
+  } catch {
+    console.info("\u26A0\uFE0F  Could not substitute the epic number into the Execution section.");
+  }
+}
+async function create_epic_number(input) {
+  await git_gh_command.label_ensure({
+    name: EPIC_LABEL,
+    color: EPIC_LABEL_COLOR,
+    description: EPIC_LABEL_DESCRIPTION
+  });
+  const body = epic_body.build_epic_body({
+    children: input.children,
+    rationale: input.rationale,
+    is_ordered: input.is_ordered,
+    origin: input.origin
+  });
+  const url = await git_gh_command.issue_create_with_label({
+    title: input.title,
+    label: EPIC_LABEL,
+    body
+  });
+  const epic_number = parse_created_number(url);
+  console.info(`\u{1F4CB} Created epic: ${url}`);
+  await apply_dependencies({ children: input.children, is_ordered: input.is_ordered });
+  await fill_run_command(epic_number, input);
+  console.info(`\u25B6 Run the children with: ${epic_body.format_run_command(epic_number)}`);
+  return epic_number;
+}
+async function create_epic(input) {
+  await create_epic_number(input);
+  return SUCCESS_EXIT_CODE;
+}
+async function write_promoted_issue(input, body) {
+  const issue_number = String(input.epic_number);
+  if (input.title !== void 0) {
+    console.info(`title: ${await git_gh_command.issue_edit_title(issue_number, input.title)}`);
+  }
+  await git_gh_command.issue_edit_body(issue_number, body);
+}
+async function read_promotion_subject(epic_number) {
+  const subject = epic_validate.parse_epic_subject(
+    await git_gh_command.issue_get_labels_and_body(String(epic_number))
+  );
+  if (subject === void 0) {
+    console.error(`\u2716 Could not read issue ${session_cite.issue(epic_number)}.`);
+    return void 0;
+  }
+  if (epic_promote.has_conflicting_tracking(subject.body)) {
+    const reason = epic_promote.conflict_reason(subject.body);
+    console.error(`\u2716 Cannot promote ${session_cite.issue(epic_number)}: ${reason}.`);
+    return void 0;
+  }
+  return subject;
+}
+async function write_promotion(input, existing_body) {
+  const body = epic_promote.build_promoted_body({ ...input, body: existing_body });
+  const tracking_error = epic_promote.find_tracking_error(body, input.children);
+  if (tracking_error !== void 0) {
+    console.error(`\u2716 ${tracking_error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  await write_promoted_issue(input, body);
+  if (await git_gh_command.issue_add_label(String(input.epic_number), EPIC_LABEL)) {
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(
+    `\u2716 Wrote the epic sections to ${session_cite.issue(input.epic_number)} but could not apply the \`${EPIC_LABEL}\` label; apply it by hand.`
+  );
+  return FAILURE_EXIT_CODE;
+}
+async function promote_epic(input) {
+  const subject = await read_promotion_subject(input.epic_number);
+  if (subject === void 0) return FAILURE_EXIT_CODE;
+  await git_gh_command.label_ensure({
+    name: EPIC_LABEL,
+    color: EPIC_LABEL_COLOR,
+    description: EPIC_LABEL_DESCRIPTION
+  });
+  const written = await write_promotion(input, subject.body);
+  if (written !== SUCCESS_EXIT_CODE) return written;
+  console.info(`\u{1F4CB} Promoted ${session_cite.issue(input.epic_number)} to an epic.`);
+  await apply_dependencies({ children: input.children, is_ordered: input.is_ordered });
+  console.info(`\u25B6 Run the children with: ${epic_body.format_run_command(input.epic_number)}`);
+  return SUCCESS_EXIT_CODE;
+}
+async function check_epic(epic_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(String(epic_number));
+  const subject = epic_validate.parse_epic_subject(raw);
+  if (subject === void 0) {
+    console.error(`\u2716 Could not read issue ${session_cite.issue(epic_number)}.`);
+    return FAILURE_EXIT_CODE;
+  }
+  const results = epic_validate.validate_epic(subject);
+  console.info(epic_validate.format_check_report(subject.number, results));
+  return epic_validate.is_epic_valid(results) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var epic_run = {
+  create_epic,
+  create_epic_number,
+  promote_epic,
+  check_epic
+};
+
+export {
+  epic_run
+};

package/dist/commands/chunk-HNZLKGKJ.js

@@ -0,0 +1,43 @@
+import {
+  doctor_consumer
+} from "./chunk-S4OZJIXD.js";
+import {
+  NOTHING_TO_CHECK_MARKER
+} from "./chunk-IW6NWCSN.js";
+
+// scripts/exports/unused-members-check.ts
+import path from "node:path";
+var CHECK = "exports";
+var FAIL_EXIT_CODE = 1;
+var CONSUMER_NOTICE = `josh ${CHECK}: checks only the kit repository itself \u2014 ${NOTHING_TO_CHECK_MARKER} in a consumer project.`;
+function format_member(root, member) {
+  return `${path.relative(root, member.file)}:${String(member.line)}  ${member.namespace}.${member.member}`;
+}
+function report(root, members) {
+  if (members.length === 0) return `josh ${CHECK}: no unused namespace member`;
+  return [
+    `josh ${CHECK}: ${String(members.length)} namespace member(s) nothing reads \u2014 remove each from its namespace object (and the declaration, if nothing in its file uses it either):`,
+    ...members.map((member) => `  ${format_member(root, member)}`)
+  ].join("\n");
+}
+async function find_members(root, files) {
+  const { unused_members } = await import("./unused-members-LOSERD3C.js");
+  if (files === void 0) return unused_members.find_unused_members(root);
+  return await unused_members.find_unused_members_in(root, files);
+}
+async function run_unused_members(root, files) {
+  if (doctor_consumer.is_kit_consumer(root)) {
+    console.info(CONSUMER_NOTICE);
+    return 0;
+  }
+  const members = await find_members(root, files);
+  const output = report(root, members);
+  if (members.length === 0) console.info(output);
+  else console.error(output);
+  return members.length === 0 ? 0 : FAIL_EXIT_CODE;
+}
+var unused_members_check = { run_unused_members, CONSUMER_NOTICE };
+
+export {
+  unused_members_check
+};

package/dist/commands/chunk-HQ5U6OZR.js

@@ -0,0 +1,315 @@
+import {
+  lint_related_scope
+} from "./chunk-BBPESBU3.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  toolchain_inputs
+} from "./chunk-TUIFS5E7.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/gate/verification-inputs.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
+
+// eslint/config-fingerprint.js
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolve } from "import-meta-resolve";
+import ts from "typescript";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../eslint/config-fingerprint.js", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var HASH_ALGORITHM = "sha256";
+var FINGERPRINT_LENGTH = 32;
+var SETTINGS_KEY = "kit_config_fingerprint";
+var PRESET_DIRECTORY = path.dirname(fileURLToPath(__josh_source_url));
+var PRESET_ENTRY = "base.js";
+var MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+var CONFIG_ENTRY_NAMES = MODULE_EXTENSIONS.map((extension) => `eslint.config${extension}`);
+function is_file(file) {
+  return statSync(file, { throwIfNoEntry: false })?.isFile() === true;
+}
+function module_candidates(target) {
+  const typed = target.replace(/\.([cm]?)js$/u, ".$1ts");
+  const bare = MODULE_EXTENSIONS.map((extension) => `${target}${extension}`);
+  const indexes = MODULE_EXTENSIONS.map((extension) => path.join(target, `index${extension}`));
+  return [target, typed, ...bare, ...indexes];
+}
+function resolve_module(target) {
+  return module_candidates(target).find((candidate) => is_file(candidate));
+}
+function is_inside(relative_path) {
+  return relative_path !== "" && !relative_path.startsWith("..") && !path.isAbsolute(relative_path);
+}
+function is_local_module(target) {
+  return path.isAbsolute(target) && (!target.split(path.sep).includes("node_modules") || is_inside(path.relative(PRESET_DIRECTORY, target)));
+}
+function keep_path_spelling(file, target) {
+  const directory = path.dirname(file);
+  const relative = path.relative(realpathSync(directory), target);
+  return path.resolve(directory, relative);
+}
+function resolve_es_module(specifier, file) {
+  const url = resolve(specifier, pathToFileURL(file).href);
+  return url.startsWith("file:") ? fileURLToPath(url) : "";
+}
+function resolve_commonjs_module(specifier, file) {
+  return createRequire(file).resolve(specifier);
+}
+function resolve_package_import(file, specifier, resolver) {
+  try {
+    const target = resolver(specifier, file);
+    return is_local_module(target) ? [keep_path_spelling(file, target)] : [];
+  } catch {
+    return [];
+  }
+}
+function resolve_import(file, specifier) {
+  const relative = specifier.startsWith(".") ? [resolve_module(path.resolve(path.dirname(file), specifier))] : [];
+  return [
+    ...relative,
+    ...resolve_package_import(file, specifier, resolve_es_module),
+    ...resolve_package_import(file, specifier, resolve_commonjs_module)
+  ];
+}
+function list_imports(file) {
+  const source = readFileSync(file, "utf8");
+  return ts.preProcessFile(source, true, true).importedFiles.flatMap((entry) => resolve_import(file, entry.fileName)).filter((resolved) => resolved !== void 0);
+}
+function visit_module(file, reached, pending) {
+  if (reached.has(file) || !is_file(file)) return;
+  reached.add(file);
+  pending.push(...list_imports(file));
+}
+function list_reachable_modules(entries) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [...entries];
+  while (pending.length > 0) visit_module(pending.pop(), reached, pending);
+  return reached;
+}
+function list_config_entries(project_root) {
+  return CONFIG_ENTRY_NAMES.map((name) => path.join(project_root, name)).filter(
+    (file) => is_file(file)
+  );
+}
+function default_entries(directory, project_root) {
+  const project_entries = project_root === void 0 ? [] : list_config_entries(project_root);
+  return [path.join(directory, PRESET_ENTRY), ...project_entries];
+}
+function compare_source_names(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function list_config_sources(directory, entries) {
+  return [...list_reachable_modules(entries)].map((file) => path.relative(directory, file)).filter((relative_path) => is_inside(relative_path)).map((relative_path) => relative_path.split(path.sep).join("/")).toSorted(compare_source_names);
+}
+function compute_config_fingerprint(directory = PRESET_DIRECTORY, entries = default_entries(directory)) {
+  const digest = createHash(HASH_ALGORITHM);
+  for (const relative_path of list_config_sources(directory, entries)) {
+    digest.update(`${relative_path}\0`);
+    digest.update(readFileSync(path.join(directory, relative_path)));
+    digest.update("\0");
+  }
+  return digest.digest("hex").slice(0, FINGERPRINT_LENGTH);
+}
+function create_config_fingerprint_block(project_root) {
+  const entries = default_entries(PRESET_DIRECTORY, project_root);
+  return { settings: { [SETTINGS_KEY]: compute_config_fingerprint(PRESET_DIRECTORY, entries) } };
+}
+var config_fingerprint = {
+  SETTINGS_KEY,
+  compute_config_fingerprint,
+  create_config_fingerprint_block,
+  list_config_entries,
+  list_reachable_modules
+};
+
+// scripts/test/test-runner-config.ts
+import path2 from "node:path";
+var PREFIXES = ["vitest.config.", "vitest.workspace.", "vite.config."];
+function is_config(relative) {
+  if (path2.dirname(relative) !== ".") return false;
+  return PREFIXES.some((prefix) => relative.startsWith(prefix));
+}
+var test_runner_config = { is_config, PREFIXES };
+
+// scripts/gate/verification-inputs.ts
+var GIT_IGNORE = ".gitignore";
+var PRETTIER_IGNORE = ".prettierignore";
+var PRETTIER_IGNORE_FILES = [GIT_IGNORE, PRETTIER_IGNORE];
+var MANIFEST = "package.json";
+var TOOLCHAIN_FILES = /* @__PURE__ */ new Set([
+  ...toolchain_inputs.PACKAGE_FILES.map((relative) => path3.basename(relative)),
+  ".editorconfig",
+  ...PRETTIER_IGNORE_FILES
+]);
+var PRETTIER_CONFIG_PREFIX = ".prettierrc";
+var COMPILER_CONFIG_PREFIXES = ["tsconfig", "svelte.config."];
+var TEST_CONFIG_PREFIXES = [...COMPILER_CONFIG_PREFIXES, ...test_runner_config.PREFIXES];
+var LINT_CONFIG_PREFIXES = ["eslint.config.", "prettier.config.", ...COMPILER_CONFIG_PREFIXES];
+var LINT_CONFIG_DIRECTORIES = /* @__PURE__ */ new Set(["prettier", "tsconfig"]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".vue",
+  ".json",
+  ".jsonc"
+]);
+var MARKDOWN_EXTENSION = ".md";
+var COMMON_ENV = ["NODE_ENV"];
+var ABSENT = "absent";
+function is_source(relative) {
+  return SOURCE_EXTENSIONS.has(path3.extname(relative));
+}
+async function is_lint_input(relative, is_ignored) {
+  if (is_source(relative)) return true;
+  if (!lint_related_scope.is_lintable(relative)) return false;
+  return !await is_ignored(relative);
+}
+async function is_source_input(relative) {
+  return is_source(relative);
+}
+async function is_metrics_input(relative) {
+  return is_source(relative) || path3.extname(relative) === MARKDOWN_EXTENSION;
+}
+function configures_toolchain(relative) {
+  const name = path3.basename(relative);
+  return TOOLCHAIN_FILES.has(name) || name.startsWith(PRETTIER_CONFIG_PREFIX);
+}
+function names_any(relative, prefixes) {
+  const name = path3.basename(relative);
+  return configures_toolchain(relative) || prefixes.some((prefix) => name.startsWith(prefix));
+}
+function configures_compiler(relative) {
+  return names_any(relative, COMPILER_CONFIG_PREFIXES);
+}
+function configures_tests(relative) {
+  return names_any(relative, TEST_CONFIG_PREFIXES);
+}
+function read_lint_config_modules(root) {
+  const entries = config_fingerprint.list_config_entries(root);
+  const modules = [...config_fingerprint.list_reachable_modules(entries)];
+  return new Set(modules.map((file) => path3.relative(root, file).split(path3.sep).join("/")));
+}
+var lint_config_modules_by_root = /* @__PURE__ */ new Map();
+function lint_config_modules(root) {
+  const cached = lint_config_modules_by_root.get(root);
+  if (cached !== void 0) return cached;
+  const modules = read_lint_config_modules(root);
+  lint_config_modules_by_root.set(root, modules);
+  return modules;
+}
+function configures_lint(relative, root) {
+  const [top = ""] = relative.split("/", 1);
+  if (LINT_CONFIG_DIRECTORIES.has(top) || names_any(relative, LINT_CONFIG_PREFIXES)) return true;
+  return lint_config_modules(root).has(relative);
+}
+var LINT = {
+  is_input: is_lint_input,
+  reads: "matched",
+  is_config: configures_lint,
+  tools: ["prettier", "eslint", "typescript"],
+  env: COMMON_ENV
+};
+var UNIT = {
+  is_input: void 0,
+  reads: "recorded",
+  is_config: configures_tests,
+  tools: ["vitest", "typescript"],
+  env: [...COMMON_ENV, "TZ"]
+};
+function compiled(is_input) {
+  return {
+    is_input,
+    reads: "matched",
+    is_config: configures_compiler,
+    tools: ["typescript"],
+    env: COMMON_ENV
+  };
+}
+async function is_any_file() {
+  return true;
+}
+var SPELLING = {
+  is_input: is_any_file,
+  reads: "matched",
+  is_config: configures_toolchain,
+  tools: ["cspell"],
+  env: COMMON_ENV
+};
+var DECLARATIONS = /* @__PURE__ */ new Map([
+  [gate_labels.LINT_LABEL, LINT],
+  [gate_labels.SPELL_CHECK_LABEL, SPELLING],
+  [gate_labels.TYPE_CHECK_LABEL, compiled(is_source_input)],
+  [gate_labels.EXPORTS_LABEL, compiled(is_source_input)],
+  [gate_labels.METRICS_LABEL, compiled(is_metrics_input)],
+  [gate_labels.UNIT_LABEL, UNIT]
+]);
+function declaration_of(label) {
+  return DECLARATIONS.get(label);
+}
+function is_declared(label) {
+  return DECLARATIONS.has(label);
+}
+function configures(label, relatives, root = PROJECT_ROOT) {
+  const declaration = DECLARATIONS.get(label);
+  return declaration === void 0 || relatives.some((relative) => declaration.is_config(relative, root));
+}
+function tool_version(root, tool) {
+  try {
+    const manifest = JSON.parse(
+      readFileSync2(path3.join(root, "node_modules", tool, MANIFEST), "utf8")
+    );
+    return typeof manifest === "object" && manifest !== null && "version" in manifest ? String(manifest.version) : ABSENT;
+  } catch {
+    return ABSENT;
+  }
+}
+function entries_of(declaration, root, environment) {
+  return [
+    ...declaration.tools.map((tool) => `tool:${tool}=${tool_version(root, tool)}`),
+    ...declaration.env.map((name) => `env:${name}=${environment[name] ?? ABSENT}`)
+  ];
+}
+function fingerprint(labels, root = PROJECT_ROOT, environment = process.env) {
+  const declarations = labels.flatMap((label) => DECLARATIONS.get(label) ?? []);
+  const entries = new Set(
+    declarations.flatMap((declaration) => entries_of(declaration, root, environment))
+  );
+  return input_fingerprint.of_entries(entries);
+}
+var DECLARED_LABELS = [...DECLARATIONS.keys()];
+var verification_inputs = {
+  configures,
+  declaration_of,
+  DECLARED_LABELS,
+  fingerprint,
+  is_declared,
+  PRETTIER_IGNORE_FILES
+};
+
+export {
+  config_fingerprint,
+  test_runner_config,
+  verification_inputs
+};