@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-TFYYXETQ.js

@@ -0,0 +1,472 @@
+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

@@ -0,0 +1,121 @@
+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-TNJU4CXD.js

@@ -0,0 +1,32 @@
+import {
+  repo_discovery
+} from "./chunk-MDKDJF2K.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/discovery/session-owner-pin.ts
+var PIN_PREFIX = "josh-session-owner-";
+var PIN_SUFFIX = ".txt";
+function pin_path(repository_path) {
+  return stamp_file.stamp_path(PIN_PREFIX, repository_path, PIN_SUFFIX);
+}
+function pin(repository_path = process.cwd()) {
+  const owner = repo_discovery.resolve_current_owner(repository_path);
+  try {
+    if (owner === void 0) stamp_file.remove_stamp(pin_path(repository_path));
+    else stamp_file.write_text_stamp(pin_path(repository_path), owner);
+  } catch {
+    return void 0;
+  }
+  return owner;
+}
+function pinned(repository_path = process.cwd()) {
+  const text = stamp_file.read_stamp_text(pin_path(repository_path))?.trim();
+  return text === "" ? void 0 : text;
+}
+var session_owner_pin = { pin, pin_path, pinned };
+
+export {
+  session_owner_pin
+};

package/dist/commands/chunk-TRHWBUWE.js

@@ -0,0 +1,61 @@
+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
+};