@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-MDKRTUE4.js

@@ -0,0 +1,288 @@
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  gh_spawn
+} from "./chunk-BFKTUD3V.js";
+import {
+  token_shape
+} from "./chunk-AQ3PMSXK.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+
+// scripts/notify/telegram-notify.ts
+import { z } from "zod";
+
+// scripts/notify/confirmation-options.ts
+var JAPANESE_HEADINGS = {
+  recommended: "\u63A8\u5968:",
+  alternatives: "\u4ED6\u306E\u9078\u629E\u80A2:",
+  none: "\u306A\u3057"
+};
+var ENGLISH_HEADINGS = {
+  recommended: "Recommended:",
+  alternatives: "Alternatives:",
+  none: "none"
+};
+function headings() {
+  const { lang } = session_language.resolve_session_lang();
+  return session_language.is_japanese(lang) ? JAPANESE_HEADINGS : ENGLISH_HEADINGS;
+}
+function alternatives_block(options, labels) {
+  if (options.alternatives.length === 0) return `${labels.alternatives} ${labels.none}`;
+  const lines = options.alternatives.map((alternative) => `- ${alternative}`);
+  return [labels.alternatives, ...lines].join("\n");
+}
+function block(options) {
+  const labels = headings();
+  return `${labels.recommended} ${options.recommended}
+${alternatives_block(options, labels)}`;
+}
+var confirmation_options = { block };
+
+// scripts/notify/notify-opt-in.ts
+var OPT_IN_KEY = "JOSH_NOTIFY_OPT_IN";
+var OPTIONAL_TASK_TYPES = /* @__PURE__ */ new Set(["planning", "completion"]);
+var LIST_SEPARATOR = ",";
+function opted_in_types() {
+  return (process.env[OPT_IN_KEY] ?? "").split(LIST_SEPARATOR).map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+}
+function is_skipped(task_type) {
+  if (!OPTIONAL_TASK_TYPES.has(task_type)) return false;
+  return !opted_in_types().includes(task_type);
+}
+function skip_line(task_type) {
+  return `\u{1F515} ${task_type} notifications are not opted in (${OPT_IN_KEY}).`;
+}
+var notify_opt_in = { is_skipped, skip_line };
+
+// scripts/notify/telegram-notify.ts
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_TEXT_LIMIT = 4096;
+var BODY_TRUNCATION_MARK = "\n...";
+var TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/u;
+var telegram_environment_schema = z.object({
+  telegram_bot_token: z.string().min(1, { message: "TELEGRAM_BOT_TOKEN is required" }),
+  telegram_chat_id: z.string().min(1, { message: "TELEGRAM_CHAT_ID is required" })
+});
+var TASK_DEFINITIONS = {
+  planning: { icon: "\u{1F4CB}", label: "Planning" },
+  completion: { icon: "\u2705", label: "Completion" },
+  failure: { icon: "\u274C", label: "Failure" },
+  warning: { icon: "\u26A0\uFE0F", label: "Completed with a warning" },
+  kickoff_retry: { icon: "\u{1F504}", label: "Kickoff retry" },
+  confirmation: { icon: "\u23F8\uFE0F", label: "Confirmation required" },
+  idle: { icon: "\u{1F4A4}", label: "Backlog run idle \u2014 nothing left to dispatch" },
+  stranded: { icon: "\u{1F6A8}", label: "Run stranded \u2014 nobody is driving it" },
+  progress: { icon: "\u{1F4CA}", label: "Progress" },
+  decision: { icon: "\u{1F916}", label: "Decided by the run \u2014 override with a later decision comment" }
+};
+var NOTIFY_SWITCH_KEY = "JOSH_NOTIFY";
+var NOTIFY_OFF_VALUE = "off";
+var NOT_CONFIGURED_PREFIX = "Telegram is not configured";
+var SEND_FAILED_PREFIX = "Telegram notification failed";
+var REDACTED = "<redacted>";
+var UNKNOWN_ERROR_TEXT = "unknown error";
+function parse_environment_string(value) {
+  return value?.trim() ?? "";
+}
+function join_cause(error) {
+  const { cause } = error;
+  if (!(cause instanceof Error) || cause.message.length === 0) return error.message;
+  return `${error.message}: ${cause.message}`;
+}
+function describe_non_error(error) {
+  return typeof error === "string" ? error : UNKNOWN_ERROR_TEXT;
+}
+function describe_error(error) {
+  if (error instanceof Error) return join_cause(error);
+  return describe_non_error(error);
+}
+function describe_symptom(error) {
+  return error instanceof Error ? error.message : describe_non_error(error);
+}
+function redact_credentials(text, config) {
+  return text.split(config.bot_token).join(REDACTED).split(config.chat_id).join(REDACTED);
+}
+function load_config() {
+  const result = telegram_environment_schema.safeParse({
+    telegram_bot_token: parse_environment_string(process.env["TELEGRAM_BOT_TOKEN"]),
+    telegram_chat_id: parse_environment_string(process.env["TELEGRAM_CHAT_ID"])
+  });
+  if (!result.success) {
+    const error_list = result.error.issues.map((issue) => issue.message).join(", ");
+    throw new Error(`${NOT_CONFIGURED_PREFIX}: ${error_list}`);
+  }
+  return { bot_token: result.data.telegram_bot_token, chat_id: result.data.telegram_chat_id };
+}
+function is_notify_disabled() {
+  return parse_environment_string(process.env[NOTIFY_SWITCH_KEY]).toLowerCase() === NOTIFY_OFF_VALUE;
+}
+function skip_line2(task_type) {
+  if (is_notify_disabled()) {
+    return `\u{1F515} Telegram notifications are disabled (${NOTIFY_SWITCH_KEY}=${NOTIFY_OFF_VALUE}).`;
+  }
+  return notify_opt_in.is_skipped(task_type) ? notify_opt_in.skip_line(task_type) : void 0;
+}
+function build_header(task_type, repo_name) {
+  const { icon, label } = TASK_DEFINITIONS[task_type];
+  if (repo_name === void 0 || repo_name.length === 0) return `${icon} ${label}`;
+  return `${icon} ${repo_name}: ${label}`;
+}
+function push_if_present(target, value) {
+  if (value !== void 0 && value.length > 0) target.push(value);
+}
+function build_title_block(input) {
+  const lines = [build_header(input.task_type, input.repo_name)];
+  push_if_present(lines, input.issue_title);
+  return lines.join("\n");
+}
+function append_url(parts, label, value) {
+  if (value !== void 0 && value.length > 0) parts.push(`${label}: ${value}`);
+}
+function build_url_parts(input) {
+  const parts = [];
+  append_url(parts, "Issue", input.issue_url);
+  append_url(parts, "PR", input.pr_url);
+  return parts;
+}
+function build_blocks(input) {
+  const blocks = [build_title_block(input)];
+  push_if_present(blocks, input.body);
+  push_if_present(blocks, input.choices);
+  blocks.push(...build_url_parts(input));
+  return blocks;
+}
+function join_blocks(input) {
+  return build_blocks(input).join("\n\n");
+}
+function head_of(body, kept) {
+  const head = body.slice(0, kept);
+  return TRAILING_HIGH_SURROGATE.test(head) ? head.slice(0, -1) : head;
+}
+function build_text(input) {
+  const text = join_blocks(input);
+  const overflow = text.length - TELEGRAM_TEXT_LIMIT;
+  if (overflow <= 0 || input.body === void 0) return text;
+  const kept = Math.max(0, input.body.length - overflow - BODY_TRUNCATION_MARK.length);
+  return join_blocks({ ...input, body: `${head_of(input.body, kept)}${BODY_TRUNCATION_MARK}` });
+}
+function outbound_text(input) {
+  token_shape.refuse(join_blocks(input), "The Telegram message");
+  return build_text(input);
+}
+async function post_message(config, text) {
+  const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`;
+  const response = await timed_fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: config.chat_id, text })
+  });
+  if (!response.ok) {
+    throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}`);
+  }
+}
+function build_send_failure(error, config) {
+  const reason = redact_credentials(describe_error(error), config);
+  return new Error(`${SEND_FAILED_PREFIX}: ${reason}`, { cause: new Error(reason) });
+}
+async function send(input) {
+  const skipped = skip_line2(input.task_type);
+  if (skipped !== void 0) {
+    console.info(skipped);
+    return;
+  }
+  const config = load_config();
+  const text = outbound_text(input);
+  try {
+    await post_message(config, text);
+  } catch (error) {
+    throw build_send_failure(error, config);
+  }
+  console.info("\u{1F4F1} Telegram notification sent.");
+}
+function report_send_failure(error, recovery) {
+  console.error("");
+  console.error(`\u2757 ${describe_symptom(error)}`);
+  console.error("   Nobody was notified, and the run carried on.");
+  if (recovery !== void 0) console.error(`   Recovery: ${recovery}`);
+  console.error("");
+}
+async function send_or_report(input, recovery) {
+  try {
+    await send(input);
+    return true;
+  } catch (error) {
+    report_send_failure(error, recovery);
+    return false;
+  }
+}
+var REPO_LOOKUP_TIMEOUT_MS = 5e3;
+async function warn(input) {
+  return await send_or_report(
+    {
+      task_type: "warning",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function confirm(input) {
+  return await send_or_report(
+    {
+      task_type: "confirmation",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      choices: confirmation_options.block(input),
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function headline(task_type, input) {
+  return await send_or_report(
+    {
+      task_type,
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function idle(input) {
+  return await headline("idle", input);
+}
+async function stranded(input) {
+  return await headline("stranded", input);
+}
+async function progress(body) {
+  return await headline("progress", { body, recovery: "pnpm josh run:board --chat" });
+}
+async function decided(input) {
+  return await headline("decision", input);
+}
+var telegram_notify = {
+  confirm,
+  decided,
+  idle,
+  progress,
+  send,
+  send_or_report,
+  stranded,
+  warn
+};
+
+export {
+  confirmation_options,
+  telegram_notify
+};

package/dist/commands/chunk-MFZVRWRS.js

@@ -0,0 +1,34 @@
+import {
+  run_event_scope
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/run/event/run-event-retry.ts
+var RETRY_PREFIX = "retry #";
+function text_of(issue) {
+  return `${RETRY_PREFIX}${String(issue)}`;
+}
+function is_retry(event) {
+  return event.kind === run_event_stream.EVENT_KIND.ADD && event.text.startsWith(RETRY_PREFIX);
+}
+function current_attempts(events) {
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (is_retry(event)) boundaries.set(run_event_scope.issue_named(event), event.pos);
+  }
+  return events.filter(
+    (event) => event.pos >= (boundaries.get(run_event_scope.issue_named(event)) ?? 0)
+  );
+}
+function count_of(events, issue) {
+  return events.filter(
+    (event) => is_retry(event) && run_event_scope.issue_named(event) === String(issue)
+  ).length;
+}
+var run_event_retry = { count_of, current_attempts, is_retry, text_of };
+
+export {
+  run_event_retry
+};

package/dist/commands/chunk-MHXIJKGP.js

@@ -0,0 +1,304 @@
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  lint_related_scope
+} from "./chunk-DLHH3MLS.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 path2 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/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) => path2.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, "vitest.config.", "vite.config."];
+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(path2.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) || path2.extname(relative) === MARKDOWN_EXTENSION;
+}
+function configures_toolchain(relative) {
+  const name = path2.basename(relative);
+  return TOOLCHAIN_FILES.has(name) || name.startsWith(PRETTIER_CONFIG_PREFIX);
+}
+function names_any(relative, prefixes) {
+  const name = path2.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) => path2.relative(root, file).split(path2.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(path2.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 {
+  verification_inputs
+};