@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-TFYYXETQ.js

@@ -1,472 +0,0 @@
-import {
-  repo_party
-} from "./chunk-DKDWOE3C.js";
-import {
-  git_gh_transport
-} from "./chunk-LX2ENXHZ.js";
-import {
-  MERGED_STATE,
-  git_gh_helpers,
-  to_gh_state
-} from "./chunk-IAGENI2U.js";
-import {
-  gh_author_association
-} from "./chunk-5YTEMF4O.js";
-import {
-  git_gh_etag_read,
-  git_gh_issue_memo
-} from "./chunk-IPS7EBE5.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-43DU7DYZ.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-TMFKVJUW.js

@@ -1,121 +0,0 @@
-import {
-  epic_add,
-  epic_reconcile
-} from "./chunk-VY7ZJMDT.js";
-import {
-  epic_bundle_gaps
-} from "./chunk-RFIOZTXY.js";
-import {
-  epic_index
-} from "./chunk-NHTEC5U4.js";
-import {
-  git_gh_issue_write
-} from "./chunk-4F4KARQN.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-blocked-by.ts
-var EPIC_LIMIT = 200;
-var SUCCESS_EXIT_CODE = 0;
-var ALREADY = "already";
-var UNSEEN_EPIC = "the open epics were not read in full, so an epic tracking it may be unseen";
-async function is_blocked(request) {
-  const blockers = await git_gh_issue_read.issue_blocked_by_numbers(request.issue);
-  return blockers.includes(Number(request.prerequisite));
-}
-function is_listed_by(epics, child, epic) {
-  return epic_index.build_tracking_index(epics).get(Number(child))?.includes(epic) === true;
-}
-async function fetch_epics() {
-  const fetched = await epic_index.fetch_epics(EPIC_LIMIT);
-  if (fetched === void 0) throw new Error("the open epics could not be read");
-  return fetched;
-}
-async function tracked_in(issue) {
-  const fetched = await fetch_epics();
-  const epic = epic_index.build_epic_index(fetched.epics).get(Number(issue));
-  if (epic === void 0 && !epic_bundle_gaps.is_membership_established(fetched.cutoff)) {
-    throw new Error(UNSEEN_EPIC);
-  }
-  return { epic, fetched };
-}
-async function tracking_with(issue, children) {
-  const { epic, fetched } = await tracked_in(issue);
-  if (epic === void 0) return void 0;
-  return {
-    epic,
-    lists_children: children.every((child) => is_listed_by(fetched.epics, child, epic))
-  };
-}
-async function tracking_epic(request) {
-  const { epic, fetched } = await tracked_in(request.issue);
-  if (epic === void 0) return void 0;
-  return { epic, is_prerequisite_child: is_listed_by(fetched.epics, request.prerequisite, epic) };
-}
-async function listing_epics(issue) {
-  const fetched = await fetch_epics();
-  if (!epic_bundle_gaps.is_membership_established(fetched.cutoff)) throw new Error(UNSEEN_EPIC);
-  return epic_index.build_tracking_index(fetched.epics).get(Number(issue)) ?? [];
-}
-async function add_to_epic(epic, request) {
-  const code = await epic_add.add_children({
-    epic_number: epic,
-    children: [Number(request.prerequisite)],
-    position: { kind: "before", target: Number(request.issue) }
-  });
-  if (code !== SUCCESS_EXIT_CODE) {
-    throw new Error(`\`epic --add\` into ${session_cite.issue(epic)} failed`);
-  }
-}
-async function record_relation(request) {
-  if (await git_gh_issue_write.issue_add_blocked_by(request.issue, request.prerequisite)) return;
-  throw new Error("the blocked-by relation was not recorded");
-}
-async function refuse_unreconcilable(epic, request) {
-  const link = { blocker: Number(request.prerequisite), blocked: Number(request.issue) };
-  const refusal = await epic_reconcile.refusal_after(epic, link);
-  if (refusal === void 0) return;
-  throw new Error(
-    `\`pnpm josh epic --reconcile ${String(epic)}\` would refuse the relation, so none was recorded: ${refusal}`
-  );
-}
-async function reconcile_epic(epic) {
-  if (await epic_reconcile.reconcile_epic(epic) === SUCCESS_EXIT_CODE) return;
-  throw new Error(
-    `the relation was recorded, but \`pnpm josh epic --reconcile ${String(epic)}\` failed to declare it`
-  );
-}
-async function record_in_epic(tracking, request) {
-  if (tracking.is_prerequisite_child) {
-    await refuse_unreconcilable(tracking.epic, request);
-    await record_relation(request);
-    await reconcile_epic(tracking.epic);
-  } else {
-    await add_to_epic(tracking.epic, request);
-    if (!await is_blocked(request)) await record_relation(request);
-  }
-  return `recorded in epic ${session_cite.issue(tracking.epic)}`;
-}
-async function settle_recorded(request) {
-  const tracking = await tracking_epic(request);
-  if (tracking?.is_prerequisite_child === true) await reconcile_epic(tracking.epic);
-  return ALREADY;
-}
-async function record(request) {
-  if (await is_blocked(request)) return await settle_recorded(request);
-  const tracking = await tracking_epic(request);
-  if (tracking !== void 0 && (request.is_relation_only !== true || tracking.is_prerequisite_child)) {
-    return await record_in_epic(tracking, request);
-  }
-  await record_relation(request);
-  return "recorded";
-}
-var epic_blocked_by = { record, listing_epics, tracking_with };
-
-export {
-  epic_blocked_by
-};

package/dist/commands/chunk-TRHWBUWE.js

@@ -1,61 +0,0 @@
-import {
-  review_comment_round
-} from "./chunk-2OEXY4GM.js";
-import {
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  lane_child_marker
-} from "./chunk-XXPDFJRI.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-
-// scripts/review/review-comment-carry.ts
-import { rmSync } from "node:fs";
-import path from "node:path";
-var CARRIED_LINE = "review-finding line(s) recorded on closed issues after their pull requests opened into the ledger.";
-var CARRY_FAILED_LINE = "Could not carry the closed issues\u2019 comment rounds into the ledger; the next carry retries:";
-var LANE_CARRY_LINE = "Not carrying the closed issues\u2019 comment rounds: a lane leaves them to `pnpm josh observations:flush`.";
-var UNKNOWN_CHECKOUT_LINE = "Not carrying the closed issues\u2019 comment rounds: Git could not identify this checkout; `pnpm josh observations:flush` carries them later.";
-var GIT_DIRECTORY_COUNT = 2;
-var UNTRACKED_PREFIX = "?? ";
-function discard_uncommitted(status_output, root) {
-  const untracked = status_output.split("\n").filter((line) => line.startsWith(UNTRACKED_PREFIX));
-  const carried = untracked.map((line) => observation_ledger.status_path(line)).filter((file_path) => review_comment_round.is_carried_file(file_path));
-  for (const file_path of carried) rmSync(path.join(root, file_path), { force: true });
-}
-async function carry_reported(root) {
-  try {
-    const count = await review_comment_round.carry(root);
-    if (count > 0) console.info(`Carried ${String(count)} ${CARRIED_LINE}`);
-  } catch (error) {
-    console.warn(`${CARRY_FAILED_LINE} ${error_text.message_of(error)}`);
-  }
-}
-async function carry_from_record(root) {
-  const directories = lane_child_marker.is_child_of(root) ? void 0 : git_common_directory.directories(root);
-  if (directories === void 0 || git_common_directory.select_linked(directories) !== void 0) {
-    console.info(LANE_CARRY_LINE);
-    return;
-  }
-  if (directories.length !== GIT_DIRECTORY_COUNT) {
-    console.warn(UNKNOWN_CHECKOUT_LINE);
-    return;
-  }
-  await carry_reported(root);
-}
-var review_comment_carry = {
-  CARRIED_LINE,
-  CARRY_FAILED_LINE,
-  carry_reported,
-  carry_from_record,
-  discard_uncommitted
-};
-
-export {
-  review_comment_carry
-};

package/dist/commands/chunk-TROCFVCU.js

@@ -1,45 +0,0 @@
-import {
-  review_comment_round
-} from "./chunk-2OEXY4GM.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  observation_ledger_home
-} from "./chunk-QXBOECGL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/review/review-record.ts
-async function has_comment_record(issue, read) {
-  try {
-    const lines = await read(issue);
-    return review_finding_ledger.has_issue_record(lines.join("\n"), issue);
-  } catch {
-    return false;
-  }
-}
-async function is_recorded(content, issue, read) {
-  if (review_finding_ledger.has_issue_record(content, issue)) return true;
-  return await has_comment_record(issue, read);
-}
-async function check(issue, root = observation_ledger_home.ledger_root(), read_comment_lines = review_comment_round.issue_lines) {
-  const content = await observation_ledger_home.read(root);
-  if (content === void 0) return { status: "not-required" };
-  if (await is_recorded(content, issue, read_comment_lines)) return { status: "ok", issue };
-  return { status: "missing", issue };
-}
-var MISSING_REASON = "No review round is recorded for this issue, so there is no evidence `/code-review` ran. A round whose findings are never recorded leaves the recurrence ledger blind, which is indistinguishable from a round nobody reviewed \u2014 so an unrecorded round is refused (joshuafolkken/kit#2343).";
-var REMEDY = "Record the round with `pnpm josh review:record --issue <N> [<category>:<severity>:<file> ...]` \u2014 a clean round is a call with no findings, which records one zero-finding line \u2014 then reissue the merge.";
-function refusal_message(issue) {
-  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
-}
-var review_record = {
-  check,
-  refusal_message
-};
-
-export {
-  review_record
-};