@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-ENKFCOVY.js

@@ -1,472 +0,0 @@
-import {
-  repo_party
-} from "./chunk-6OP63TBT.js";
-import {
-  git_gh_transport
-} from "./chunk-TVZXG4Y4.js";
-import {
-  MERGED_STATE,
-  git_gh_helpers,
-  to_gh_state
-} from "./chunk-4PUKDAXL.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  git_gh_etag_read,
-  git_gh_issue_memo
-} from "./chunk-EWVR5AEX.js";
-import {
-  blocking_issue_schema
-} from "./chunk-34DND4BA.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  gh_failure,
-  git_gh_exec,
-  parse_json_array_or_undefined,
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-issue-graphql.ts
-import { z } from "zod";
-var PAGE = `first: ${String(git_gh_api_path.FULL_PAGE_SIZE)}`;
-var BOT_TYPE = "Bot";
-var BOT_SUFFIX = "[bot]";
-var REPOSITORY_API_URL = "https://api.github.com/repos/";
-var AUTHOR = "author { login type: __typename }";
-var BLOCKER = "number state repository { nameWithOwner }";
-var COMMENT = `url body createdAt authorAssociation ${AUTHOR}`;
-var COMMENTS = `comments(${PAGE}) { pageInfo { hasNextPage } nodes { ${COMMENT} } }`;
-var ISSUE_FIELDS = `number title state body url createdAt authorAssociation ${AUTHOR}
-	labels(${PAGE}) { nodes { name } }
-	blockedBy(${PAGE}) { totalCount nodes { ${BLOCKER} } }`;
-var ISSUE_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
-	repository(owner: $owner, name: $name) {
-		issue(number: $number) {
-			${ISSUE_FIELDS}
-			${COMMENTS}
-		}
-	}
-}`;
-var author_schema = z.object({ login: z.string(), type: z.string() }).nullable();
-var label_schema = z.object({ name: z.string() });
-var page_info_schema = z.object({ hasNextPage: z.boolean() });
-var comment_node_schema = z.object({
-  url: z.string(),
-  body: z.string(),
-  createdAt: z.string(),
-  authorAssociation: z.string(),
-  author: author_schema
-});
-var blocker_node_schema = z.object({
-  number: z.number(),
-  state: z.string(),
-  repository: z.object({ nameWithOwner: z.string() })
-});
-var issue_fields_schema = z.object({
-  number: z.number(),
-  title: z.string(),
-  state: z.string(),
-  body: z.string(),
-  url: z.string(),
-  createdAt: z.string(),
-  authorAssociation: z.string(),
-  author: author_schema,
-  labels: z.object({ nodes: z.array(label_schema) }),
-  blockedBy: z.object({ totalCount: z.number(), nodes: z.array(blocker_node_schema) })
-});
-var comments_schema = z.object({
-  comments: z.object({ pageInfo: page_info_schema, nodes: z.array(comment_node_schema) })
-});
-var issue_schema = issue_fields_schema.extend(comments_schema.shape);
-var response_schema = z.looseObject({
-  data: z.looseObject({ repository: z.looseObject({ issue: issue_schema }) })
-});
-function repository_variables_of(repo) {
-  const identity = repo === void 0 ? repo_party.current_repository() : repo_party.parse_owner_repo(repo);
-  if (identity === void 0) return void 0;
-  return { owner: identity.owner, name: identity.repo };
-}
-function variables_of(issue_number, repo) {
-  const repository = repository_variables_of(repo);
-  if (repository === void 0) return void 0;
-  return { ...repository, number: Number(issue_number) };
-}
-function user_of(author) {
-  if (author === null) return {};
-  const suffix = author.type === BOT_TYPE ? BOT_SUFFIX : "";
-  return { user: { login: `${author.login}${suffix}` } };
-}
-function to_rest_comments(comments) {
-  const rows = comments.map((comment) => ({
-    html_url: comment.url,
-    body: comment.body,
-    created_at: comment.createdAt,
-    author_association: comment.authorAssociation,
-    ...user_of(comment.author)
-  }));
-  return JSON.stringify(rows);
-}
-function to_blocking_issue(blocker) {
-  return {
-    number: blocker.number,
-    state: blocker.state,
-    repository_url: `${REPOSITORY_API_URL}${blocker.repository.nameWithOwner}`
-  };
-}
-function to_blocked_by(issue) {
-  return {
-    nodes: issue.blockedBy.nodes.map((blocker) => to_blocking_issue(blocker)),
-    totalCount: issue.blockedBy.totalCount
-  };
-}
-function to_rest_issue(issue) {
-  return {
-    number: issue.number,
-    title: issue.title,
-    state: issue.state,
-    body: issue.body,
-    html_url: issue.url,
-    created_at: issue.createdAt,
-    author_association: issue.authorAssociation,
-    ...user_of(issue.author),
-    labels: issue.labels.nodes,
-    issue_dependencies_summary: { total_blocked_by: issue.blockedBy.totalCount }
-  };
-}
-function to_issue_with_comments(issue) {
-  if (issue === void 0 || issue.comments.pageInfo.hasNextPage) return void 0;
-  return {
-    rest: to_rest_issue(issue),
-    blocked_by: to_blocked_by(issue),
-    comments_json: to_rest_comments(issue.comments.nodes)
-  };
-}
-async function read_issue(issue_number, repo) {
-  const variables = variables_of(issue_number, repo);
-  if (variables === void 0) return void 0;
-  const json = await git_gh_transport.query({ query: ISSUE_QUERY, variables });
-  if (json === void 0) return void 0;
-  return to_issue_with_comments(json_value.parse_with(json, response_schema)?.data.repository.issue);
-}
-var git_gh_issue_graphql = {
-  read_issue,
-  repository_variables_of,
-  to_blocked_by,
-  to_blocking_issue,
-  to_rest_comments,
-  to_rest_issue
-};
-
-// scripts/gh/git-gh-issue-rest.ts
-import { z as z2 } from "zod";
-var rest_issue_schema = z2.looseObject({
-  number: z2.number(),
-  // The GraphQL id a listing's blocker read addresses the row by (`git-gh-blocked-by-graphql.ts`).
-  node_id: z2.string().optional(),
-  body: z2.string().nullish(),
-  issue_dependencies_summary: z2.looseObject({ total_blocked_by: z2.number().optional() }).nullish(),
-  // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z2.looseObject({ merged_at: z2.string().nullish() }).nullish()
-});
-var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
-var REPOSITORY_URL_GROUP = 1;
-var BLOCKED_BY_FIELD = "blockedBy";
-var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
-var STATE_FIELD = "state";
-var BODY_FIELD = "body";
-var FIELD_SEPARATOR = ",";
-var EMPTY_BODY = "";
-var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
-  ["url", "html_url"],
-  ["createdAt", "created_at"],
-  ["closedAt", "closed_at"],
-  ["stateReason", "state_reason"],
-  ["updatedAt", "updated_at"]
-]);
-var NOT_AN_ISSUE_MESSAGE = "gh api answered something other than an issue object";
-var NOT_AN_ISSUE_LISTING_MESSAGE = "gh api answered something other than an issue listing";
-var NOT_A_BLOCKER_LISTING_MESSAGE = "gh api answered something other than a blocked-by listing";
-function rest_field_name(field) {
-  return REST_FIELD_NAMES.get(field) ?? field;
-}
-function split_fields(fields) {
-  return fields.split(FIELD_SEPARATOR).map((field) => field.trim()).filter((field) => field.length > 0);
-}
-function to_issue_state(rest, value) {
-  if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
-  return typeof value === "string" ? to_gh_state(value) : value;
-}
-function total_blocked_by(rest) {
-  return rest.issue_dependencies_summary?.total_blocked_by;
-}
-function to_gh_field_value(field, rest) {
-  if (field === BLOCKED_BY_COUNT_FIELD) return total_blocked_by(rest);
-  const value = rest[rest_field_name(field)];
-  if (field === STATE_FIELD) return to_issue_state(rest, value);
-  return field === BODY_FIELD ? value ?? EMPTY_BODY : value;
-}
-function parse_rest_issue(rest_json) {
-  const parsed = parse_json_object_or_undefined(rest_json, rest_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_MESSAGE);
-  return parsed;
-}
-function is_pull_request(rest) {
-  return rest.pull_request !== void 0 && rest.pull_request !== null;
-}
-function parse_rest_issues(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_LISTING_MESSAGE);
-  return parsed;
-}
-function empty_blocked_by() {
-  return { nodes: [], totalCount: 0 };
-}
-function repo_of_url(repository_url = "") {
-  const match = REPOSITORY_URL.exec(repository_url);
-  return match?.[REPOSITORY_URL_GROUP];
-}
-function to_blocked_by2(blockers_json, exact_total) {
-  const parsed = parse_json_array_or_undefined(blockers_json, blocking_issue_schema);
-  if (parsed === void 0) throw new Error(NOT_A_BLOCKER_LISTING_MESSAGE);
-  const nodes = parsed.map((blocker) => ({ ...blocker, state: to_gh_state(blocker.state) }));
-  return { nodes, totalCount: exact_total ?? nodes.length };
-}
-function to_gh_issue(rest, fields, blocked_by) {
-  return Object.fromEntries(
-    fields.map((field) => [
-      field,
-      field === BLOCKED_BY_FIELD ? blocked_by : to_gh_field_value(field, rest)
-    ])
-  );
-}
-function to_field_text(value) {
-  if (typeof value === "string") return value;
-  return value === void 0 || value === null ? EMPTY_BODY : JSON.stringify(value);
-}
-var CLOSED = "CLOSED";
-function reference_of_blocker(node, fallback_repo) {
-  const repo = repo_of_url(node.repository_url) ?? fallback_repo;
-  if (node.state === void 0) return { repo, number: node.number };
-  return { repo, number: node.number, state: node.state.toUpperCase() === CLOSED ? CLOSED : "OPEN" };
-}
-var git_gh_issue_rest = {
-  empty_blocked_by,
-  repo_of_url,
-  reference_of_blocker,
-  split_fields,
-  is_pull_request,
-  parse_rest_issue,
-  parse_rest_issues,
-  total_blocked_by,
-  to_blocked_by: to_blocked_by2,
-  to_gh_issue,
-  to_field_text
-};
-
-// scripts/gh/git-gh-reachability.ts
-var RATE_LIMITED_STATUS = 429;
-var SERVER_ERROR_FLOOR = 500;
-function is_retryable_status(status) {
-  if (status >= SERVER_ERROR_FLOOR) return true;
-  return status === RATE_LIMITED_STATUS;
-}
-function classify_status(status) {
-  if (status === void 0) return "unreachable";
-  return is_retryable_status(status) ? "unreachable" : "reachable";
-}
-var gh_reachability = { classify_status };
-
-// scripts/gh/git-gh-issue-read.ts
-async function read_blocked_by_listing(issue_number, repo, exact_total) {
-  const json = await git_gh_issue_memo.read(
-    `${git_gh_api_path.blocked_by_api_path(issue_number, repo)}${git_gh_api_path.FULL_PAGE_QUERY}`
-  );
-  return git_gh_issue_rest.to_blocked_by(json, exact_total);
-}
-async function read_blocked_by(issue_number, rest, repo) {
-  if (git_gh_issue_rest.is_pull_request(rest)) return git_gh_issue_rest.empty_blocked_by();
-  const exact_total = git_gh_issue_rest.total_blocked_by(rest);
-  if (exact_total === 0) return git_gh_issue_rest.empty_blocked_by();
-  return await read_blocked_by_listing(issue_number, repo, exact_total);
-}
-function mark_followup(error) {
-  if (!(error instanceof Error)) return error;
-  const failure = gh_failure.failure_of(error);
-  if (failure === void 0) return error;
-  return gh_failure.attach(error, { ...failure, is_followup: true });
-}
-async function read_relations(issue_number, rest, repo) {
-  try {
-    return await read_blocked_by(issue_number, rest, repo);
-  } catch (error) {
-    throw mark_followup(error);
-  }
-}
-async function read_issue_fields(issue_number, fields, repo, read_path = git_gh_issue_memo.read) {
-  const rest = git_gh_issue_rest.parse_rest_issue(
-    await read_path(git_gh_api_path.issue_api_path(issue_number, repo))
-  );
-  const requested = git_gh_issue_rest.split_fields(fields);
-  const blocked_by = requested.includes(BLOCKED_BY_FIELD) ? await read_relations(issue_number, rest, repo) : void 0;
-  return git_gh_issue_rest.to_gh_issue(rest, requested, blocked_by);
-}
-var NOT_FOUND_STATUS = 404;
-function is_number_unresolved(failure) {
-  return failure.status === NOT_FOUND_STATUS && failure.is_followup !== true;
-}
-function to_unreadable_reason(status) {
-  return gh_reachability.classify_status(status) === "unreachable" ? "unreachable" : "rejected";
-}
-function to_read_failure(error) {
-  const failure = gh_failure.failure_of(error);
-  if (failure === void 0) return { kind: "unreadable", reason: "malformed", status: void 0 };
-  if (is_number_unresolved(failure)) return { kind: "missing" };
-  return {
-    kind: "unreadable",
-    reason: to_unreadable_reason(failure.status),
-    status: failure.status,
-    detail: error instanceof Error ? error.message : String(error)
-  };
-}
-async function issue_view_json_classified(issue_number, fields, repo, read_path) {
-  try {
-    const issue = await read_issue_fields(issue_number, fields, repo, read_path);
-    return { kind: "read", json: JSON.stringify(issue) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field_classified(issue_number, field, repo) {
-  try {
-    const issue = await read_issue_fields(issue_number, field, repo);
-    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue[field]) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field(issue_number, field, repo) {
-  const read = await issue_view_field_classified(issue_number, field, repo);
-  return read.kind === "read" ? read.text : void 0;
-}
-async function issue_get_title(issue_number, repo) {
-  const result = await issue_view_field(issue_number, "title", repo);
-  return result === void 0 ? void 0 : git_gh_helpers.parse_pr_state_string(result);
-}
-async function issue_get_body(issue_number, repo) {
-  return await issue_view_field(issue_number, "body", repo);
-}
-async function issue_get_body_classified(issue_number, repo) {
-  return await issue_view_field_classified(issue_number, "body", repo);
-}
-async function issue_view_json(issue_number, fields, repo, read_path) {
-  const read = await issue_view_json_classified(issue_number, fields, repo, read_path);
-  return read.kind === "read" ? read.json : void 0;
-}
-var STATE_AND_RELATIONS_FIELDS = `number,state,labels,blockedBy,body,${gh_author_association.AUTHOR_FIELDS}`;
-async function issue_get_state_and_relations(issue_number, repo) {
-  return await issue_view_json(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-async function issue_get_state_and_relations_classified(issue_number, repo) {
-  return await issue_view_json_classified(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-function is_unreachable_read(failure) {
-  return failure.kind === "unreadable" && failure.reason === "unreachable";
-}
-var PLAN_FIELDS = "number,title,body,state,url,labels,blockedBy";
-async function issue_get_plan_fields(issue_number) {
-  return await issue_view_json(issue_number, PLAN_FIELDS);
-}
-async function issue_get_plan_fields_classified(issue_number) {
-  return await issue_view_json_classified(issue_number, PLAN_FIELDS);
-}
-async function issue_get_labels_and_body(issue_number) {
-  return await issue_view_json(issue_number, "number,state,labels,body");
-}
-async function issue_list_comments(issue_number, timeout_ms, repo, read_path) {
-  const path = `${git_gh_api_path.issue_comments_api_path(issue_number, repo)}${git_gh_api_path.FULL_PAGE_QUERY}`;
-  try {
-    return await (read_path?.(path) ?? git_gh_exec.exec_gh_api({ path, should_paginate: true, timeout_ms }));
-  } catch {
-    return void 0;
-  }
-}
-async function issue_read_with_comments(issue_number, fields, repo) {
-  const graphql = await git_gh_issue_graphql.read_issue(issue_number, repo);
-  if (graphql === void 0) {
-    const [read, comments_json] = await Promise.all([
-      issue_view_json_classified(issue_number, fields, repo),
-      issue_list_comments(issue_number, void 0, repo)
-    ]);
-    return { read, comments_json };
-  }
-  const requested = git_gh_issue_rest.split_fields(fields);
-  const issue = git_gh_issue_rest.to_gh_issue(graphql.rest, requested, graphql.blocked_by);
-  return {
-    read: { kind: "read", json: JSON.stringify(issue) },
-    comments_json: graphql.comments_json
-  };
-}
-async function read_comments_conditionally(path) {
-  return await git_gh_etag_read.read_listing(path, git_gh_api_path.FULL_PAGE_SIZE);
-}
-async function has_no_relations_endpoint(issue_number, repo) {
-  const status = await git_gh_exec.exec_gh_api_status(
-    git_gh_api_path.blocked_by_api_path(issue_number, repo)
-  );
-  return status === NOT_FOUND_STATUS;
-}
-async function issue_blocked_by_references(issue_number, own_repo, repo) {
-  try {
-    const listing = await read_blocked_by_listing(issue_number, repo);
-    return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, own_repo));
-  } catch (error) {
-    if (await has_no_relations_endpoint(issue_number, repo)) return [];
-    throw error;
-  }
-}
-async function issue_blocked_by_numbers(issue_number, repo) {
-  const references = await issue_blocked_by_references(issue_number, "", repo);
-  return references.map((blocker) => blocker.number);
-}
-var git_gh_issue_read = {
-  issue_blocked_by_numbers,
-  issue_blocked_by_references,
-  issue_get_title,
-  issue_get_body,
-  issue_get_body_classified,
-  issue_view_json,
-  issue_view_json_classified,
-  issue_get_state_and_relations,
-  issue_get_state_and_relations_classified,
-  is_unreachable_read,
-  issue_get_plan_fields,
-  issue_get_plan_fields_classified,
-  issue_get_labels_and_body,
-  issue_list_comments,
-  issue_read_with_comments,
-  read_comments_conditionally
-};
-
-export {
-  PAGE,
-  BLOCKER,
-  COMMENTS,
-  ISSUE_FIELDS,
-  blocker_node_schema,
-  issue_fields_schema,
-  comments_schema,
-  git_gh_issue_graphql,
-  BLOCKED_BY_FIELD,
-  BLOCKED_BY_COUNT_FIELD,
-  git_gh_issue_rest,
-  read_blocked_by,
-  STATE_AND_RELATIONS_FIELDS,
-  PLAN_FIELDS,
-  git_gh_issue_read
-};

package/dist/commands/chunk-ERG4QRNG.js

@@ -1,224 +0,0 @@
-import {
-  test_pinned_logic
-} from "./chunk-Y27PTXXI.js";
-import {
-  review_readers_scan
-} from "./chunk-W6MVQEMO.js";
-import {
-  git_grep_hits
-} from "./chunk-T25S4QHL.js";
-import {
-  COMMAND_MAP
-} from "./chunk-C54QXJD6.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/review/prose-stale-scan.ts
-var CODE_FILE = /\.(?:ts|js)$/u;
-var TEST_FILE = /\.test\.(?:ts|js)$/u;
-var IDENTIFIER_SHAPE = /[_\d]|[a-z][A-Z]/u;
-var REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
-var BACKTICK = "`";
-var SPAN_PARITY = 2;
-var MARKDOWN_EXTENSION = ".md";
-var MARKDOWN_FILE = /\.md$/u;
-var COMMAND = /\bjosh\s+(?<command>[a-z][\w-]*:[\w:-]+)/gu;
-var UPPER_CASE = /^[A-Z][A-Z\d_]*[A-Z\d]$/u;
-var HEADING = /^#{1,6} (?<text>.+)$/u;
-var TOKEN = /[\w-]+(?::[\w-]+)*/gu;
-var COMMENT_LINE = /^\s*(?:\/[/*]|\*|#)/u;
-var OK_LINE = "ok";
-var FOUND_EXIT = 1;
-var FAILED_EXIT = 2;
-function to_terms(kind, words) {
-  return words.map((word) => ({ kind, word }));
-}
-function declared_names(source, is_deleted) {
-  if (is_deleted) return review_readers_scan.reachable_names(source);
-  return review_readers_scan.declarations(source).map((entry) => entry.name);
-}
-function code_terms(source, is_deleted) {
-  const declared = declared_names(source, is_deleted);
-  const listed = [...review_readers_scan.exported_names(source)];
-  const constants = declared.filter((name) => UPPER_CASE.test(name));
-  const names = [...declared.filter((name) => !UPPER_CASE.test(name)), ...listed];
-  return [...to_terms("name", names), ...to_terms("constant", constants)];
-}
-function command_terms(lines) {
-  const commands = lines.flatMap(
-    (line) => [...line.matchAll(COMMAND)].map((match) => match.groups?.["command"] ?? "")
-  );
-  return to_terms("command", commands);
-}
-function headings(lines) {
-  const texts = lines.map((line) => HEADING.exec(line)?.groups?.["text"]?.trim());
-  return texts.filter((text) => text !== void 0 && text !== "");
-}
-function declared_in(lines) {
-  return review_readers_scan.declarations(lines.join("\n")).map((entry) => entry.name);
-}
-function renamed_terms(hunk) {
-  const before = declared_in(hunk.old_lines);
-  const after = declared_in(hunk.new_lines ?? []);
-  const gone = before.filter((name) => !after.includes(name));
-  const fresh = after.filter((name) => !before.includes(name));
-  return gone.flatMap((word, index) => {
-    const renamed_to = fresh[index];
-    if (renamed_to === void 0) return [];
-    return [{ kind: UPPER_CASE.test(word) ? "constant" : "name", word, renamed_to }];
-  });
-}
-function hunk_terms(hunk, deleted) {
-  const lines = hunk.old_lines;
-  const is_code = CODE_FILE.test(hunk.file) && !TEST_FILE.test(hunk.file);
-  const source = lines.join("\n");
-  const code = is_code ? [...code_terms(source, deleted.has(hunk.file)), ...renamed_terms(hunk)] : [];
-  const titled = hunk.file.endsWith(MARKDOWN_EXTENSION) ? to_terms("heading", headings(lines)) : [];
-  return [...code, ...command_terms(lines), ...titled];
-}
-function added_lines(hunks, extension) {
-  return hunks.filter((hunk) => extension.test(hunk.file)).flatMap((hunk) => hunk.new_lines ?? []);
-}
-function kept_of(hunks, registered) {
-  const added = hunks.flatMap((hunk) => hunk.new_lines ?? []);
-  const titles = headings(added_lines(hunks, MARKDOWN_FILE));
-  const declared = declared_in(added_lines(hunks, CODE_FILE));
-  const tokens = added.flatMap((line) => [...line.matchAll(TOKEN)].map((match) => match[0]));
-  return {
-    tokens: new Set(tokens),
-    titles: new Set(titles),
-    declared: new Set(declared),
-    registered
-  };
-}
-function is_removed(term, kept) {
-  if (term.renamed_to !== void 0) return !kept.declared.has(term.word);
-  if (term.kind === "heading") return !kept.titles.has(term.word);
-  if (term.kind === "command" && kept.registered.has(term.word)) return false;
-  return !kept.tokens.has(term.word);
-}
-var EMPTY_TREE = { surviving: /* @__PURE__ */ new Set(), deleted: /* @__PURE__ */ new Set() };
-function stale_terms(hunks, registered, tree = EMPTY_TREE) {
-  const { surviving, deleted } = tree;
-  const kept = kept_of(hunks, registered);
-  const terms = hunks.flatMap((hunk) => hunk_terms(hunk, deleted));
-  const unique = new Map(terms.map((term) => [term.word, term]));
-  return [...unique.values()].filter((term) => !surviving.has(term.word) && is_removed(term, kept));
-}
-function pattern(term) {
-  if (term.kind === "heading") return { target: `"${term.word}"`, flags: [] };
-  return { target: term.word, flags: ["-w"] };
-}
-function is_prose(hit) {
-  return hit.path.endsWith(MARKDOWN_EXTENSION) || COMMENT_LINE.test(hit.excerpt);
-}
-function code_spans(excerpt) {
-  return excerpt.split(BACKTICK).filter((_span, index) => index % SPAN_PARITY === 1);
-}
-function code_shape(word) {
-  const shapes = [
-    String.raw`\.${word}(?![\w$])`,
-    String.raw`(?<![\w$])${word}\(`,
-    String.raw`\{\s*(?:[\w$]+\s*,\s*)*${word}\s*[,}]`,
-    String.raw`\bimport\s+${word}\s+from\b`
-  ];
-  return new RegExp(shapes.join("|"), "u");
-}
-function is_code_use(term, excerpt) {
-  if (term.kind !== "name" || IDENTIFIER_SHAPE.test(term.word)) return true;
-  const word = term.word.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
-  const whole = new RegExp(String.raw`(?<![\w$])${word}(?![\w$])`, "u");
-  return code_spans(excerpt).some((span) => whole.test(span)) || code_shape(word).test(excerpt);
-}
-function reference_lines(reference) {
-  const { kind, word, renamed_to } = reference.term;
-  const label = renamed_to === void 0 ? word : `${word} (renamed to ${renamed_to})`;
-  if (reference.has_failed) return [`search failed: ${kind} ${label}`];
-  return reference.hits.filter((hit) => is_prose(hit) && is_code_use(reference.term, hit.excerpt)).map((hit) => `${hit.path}:${hit.line} ${kind} ${label}`);
-}
-function exit_code_of(references2, lines) {
-  if (references2.some((reference) => reference.has_failed)) return FAILED_EXIT;
-  return lines.length > 0 ? FOUND_EXIT : 0;
-}
-function report(references2) {
-  const lines = references2.flatMap((reference) => reference_lines(reference));
-  return {
-    text: lines.length > 0 ? lines.join("\n") : OK_LINE,
-    exit_code: exit_code_of(references2, lines)
-  };
-}
-var prose_stale_scan = { CODE_FILE, FAILED_EXIT, pattern, report, stale_terms };
-
-// scripts/review/prose-stale-read.ts
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-var SEARCH_PATHS = ["*.md", "prompts", "docs", ".claude", "scripts", ":(exclude)CHANGELOG.md"];
-var CODE_PATHSPECS = ["*.ts", "*.js", ":(exclude)*.test.ts", ":(exclude)*.test.js"];
-async function read_hunks(root, base) {
-  const diff = await git_spawn.read([
-    "-C",
-    root,
-    "diff",
-    "-U0",
-    "--no-color",
-    "--no-ext-diff",
-    "--src-prefix=a/",
-    "--dst-prefix=b/",
-    base
-  ]);
-  return test_pinned_logic.all_hunks(diff);
-}
-async function reference_of(term, root) {
-  const { target, flags } = prose_stale_scan.pattern(term);
-  const { hits, has_failed } = await git_grep_hits.search(target, flags, SEARCH_PATHS, root);
-  return { term, hits, has_failed };
-}
-async function declared_in2(root, files) {
-  const sources = await Promise.all(
-    files.map(async (file) => await readFile(path.join(root, file), "utf8"))
-  );
-  return sources.flatMap(
-    (source) => review_readers_scan.declarations(source).map(({ name }) => name)
-  );
-}
-async function files_writing(root, names) {
-  const results = await Promise.all(
-    names.map(async (name) => await git_grep_hits.search(name, ["-w"], CODE_PATHSPECS, root))
-  );
-  const files = new Set(results.flatMap(({ hits }) => hits.map((hit) => hit.path)));
-  return [...files].filter((file) => existsSync(path.join(root, file)));
-}
-async function declared_elsewhere(root, hunks, deleted) {
-  const gone = hunks.filter((hunk) => deleted.includes(hunk.file));
-  const names = [
-    ...new Set(
-      gone.flatMap((hunk) => review_readers_scan.reachable_names(hunk.old_lines.join("\n")))
-    )
-  ];
-  const declared = new Set(await declared_in2(root, await files_writing(root, names)));
-  return names.filter((name) => declared.has(name));
-}
-async function tree_of(root, hunks) {
-  const files = [...new Set(hunks.map((hunk) => hunk.file))].filter(
-    (file) => prose_stale_scan.CODE_FILE.test(file)
-  );
-  const present = files.filter((file) => existsSync(path.join(root, file)));
-  const names = await declared_in2(root, present);
-  const deleted = files.filter((file) => !present.includes(file));
-  const elsewhere = await declared_elsewhere(root, hunks, deleted);
-  return { surviving: /* @__PURE__ */ new Set([...names, ...elsewhere]), deleted: new Set(deleted) };
-}
-async function references(root, hunks) {
-  const registered = new Set(Object.keys(COMMAND_MAP));
-  const tree = await tree_of(root, hunks);
-  const terms = prose_stale_scan.stale_terms(hunks, registered, tree);
-  return await Promise.all(terms.map(async (term) => await reference_of(term, root)));
-}
-var prose_stale_read = { read_hunks, references };
-
-export {
-  prose_stale_scan,
-  prose_stale_read
-};