@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-U6SMBYTN.js

@@ -0,0 +1,472 @@
+import {
+  repo_party
+} from "./chunk-DKDWOE3C.js";
+import {
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  MERGED_STATE,
+  git_gh_helpers,
+  to_gh_state
+} from "./chunk-2BNLPPP4.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  git_gh_etag_read,
+  git_gh_issue_memo
+} from "./chunk-V6WWW6HX.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-NAZ753DE.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-U7JJGYYY.js

@@ -0,0 +1,30 @@
+import {
+  review_brief
+} from "./chunk-5ZWU2B7T.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+
+// scripts/test/test-e2e-stamp.ts
+function record(tree, target) {
+  try {
+    review_stamps.e2e_stamp.write(tree.files, target, tree.base);
+  } catch {
+  }
+}
+function is_current(tree, source) {
+  if (tree.base === void 0) return false;
+  const stamp = review_brief.matching_stamp(review_stamps.e2e_stamp.read(source), tree.files);
+  return stamp?.base === tree.base;
+}
+async function is_current_tree() {
+  return is_current(await gate_tree.read_gate_tree());
+}
+var test_e2e_stamp = { is_current, is_current_tree, record };
+
+export {
+  test_e2e_stamp
+};

package/dist/commands/chunk-UACWDTJ5.js

@@ -0,0 +1,106 @@
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  run_carry,
+  run_carry_session,
+  run_headless_keys
+} from "./chunk-JSJS3OT7.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/run/run-headless.ts
+var { HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY } = run_headless_keys;
+var HEADLESS_VALUE = "1";
+var SESSION_CUT = { cuts: 1 };
+function environment() {
+  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
+}
+function handoff_child_environment() {
+  return { [HEADLESS_ENV_KEY]: void 0, [HANDOFF_CHILD_KEY]: HEADLESS_VALUE };
+}
+function beside_environment() {
+  return { ...environment(), [BESIDE_CHILD_KEY]: HEADLESS_VALUE };
+}
+function is_started_child(source) {
+  return lane_child_marker.marked_issue(source) !== void 0 || source[HANDOFF_CHILD_KEY] === HEADLESS_VALUE || source[BESIDE_CHILD_KEY] === HEADLESS_VALUE;
+}
+function is_headless(source = process.env) {
+  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
+}
+function is_headless_parent(source) {
+  return is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
+}
+function is_cut_capped(carry, source = process.env) {
+  return !is_headless_parent(source) && run_carry.is_at_cut_cap(carry);
+}
+function is_driving(read) {
+  return read?.kind === "carried" && read.carry.is_handed_off !== true;
+}
+async function carry_target_here() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
+}
+async function read_carry_here() {
+  const target = await carry_target_here();
+  return target === void 0 ? void 0 : run_carry.read_carry(target);
+}
+async function current_carry() {
+  const read = await read_carry_here();
+  return read?.kind === "carried" ? read.carry : void 0;
+}
+function is_owned_here(carry, ancestry) {
+  if (carry.owner_session !== void 0) return carry.owner_session === run_carry_session.own();
+  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
+}
+function driven_here(read, ancestry) {
+  if (read?.kind !== "carried" || !is_driving(read)) return void 0;
+  return is_owned_here(read.carry, ancestry) ? read.carry : void 0;
+}
+async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
+  if (is_started_child(source)) return void 0;
+  return driven_here(await read_carry_here(), ancestry);
+}
+async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
+  return await driving_carry(source, ancestry) !== void 0;
+}
+async function must_keep_waiting(source = process.env, ancestry = lane_reap.own_ancestry) {
+  if (!is_headless_parent(source) || !await lane_registry.has_lanes_in_flight()) return false;
+  return await is_backlog_parent(source, ancestry);
+}
+async function write_cut(source, ancestry) {
+  const target = await carry_target_here();
+  const carry = await driving_carry(source, ancestry);
+  if (target !== void 0 && carry !== void 0) {
+    run_carry.apply_change(target, carry, SESSION_CUT);
+  }
+}
+async function hand_back_at_turn_end(source = process.env, ancestry = lane_reap.own_ancestry) {
+  if (!is_headless_parent(source)) return false;
+  await write_cut(source, ancestry);
+  return await must_keep_waiting(source, ancestry);
+}
+var run_headless = {
+  HEADLESS_ENV_KEY,
+  beside_environment,
+  current_carry,
+  hand_back_at_turn_end,
+  driven_here,
+  driving_carry,
+  environment,
+  handoff_child_environment,
+  is_backlog_parent,
+  is_cut_capped,
+  is_headless,
+  is_headless_parent,
+  is_owned_here,
+  must_keep_waiting
+};
+
+export {
+  run_headless
+};

package/dist/commands/chunk-UBWYGOEC.js

@@ -0,0 +1,86 @@
+import {
+  import_graph
+} from "./chunk-CVZXDKCV.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/lint/eslint-cache-dependencies.ts
+import { rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "flatted";
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function is_entry(item) {
+  if (!is_record(item)) return false;
+  const { key, value } = item;
+  return typeof key === "string" && is_record(value);
+}
+function is_entries(value) {
+  return Array.isArray(value) && value.every((item) => is_entry(item));
+}
+function parsed_or_undefined(content) {
+  try {
+    return parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function read_entries(cache_file) {
+  const content = file_reader.read_optional(cache_file);
+  if (content === void 0) return void 0;
+  const parsed = parsed_or_undefined(content);
+  return is_entries(parsed) ? parsed : void 0;
+}
+function read_or_discard(cache_file) {
+  const entries = read_entries(cache_file);
+  if (entries === void 0) rmSync(cache_file, { force: true });
+  return entries ?? [];
+}
+function write_entries(cache_file, entries) {
+  writeFileSync(cache_file, stringify(entries));
+}
+function recorded_hash(entry) {
+  const { data } = entry.value;
+  if (!is_record(data)) return void 0;
+  const { dependencies } = data;
+  return typeof dependencies === "string" ? dependencies : void 0;
+}
+function drop_stale(cache_file, graph) {
+  const entries = read_or_discard(cache_file);
+  const hashes = new Map(entries.map((entry) => [entry.key, graph.closure_hash(entry.key)]));
+  const kept = entries.filter((entry) => recorded_hash(entry) === hashes.get(entry.key));
+  if (kept.length !== entries.length) write_entries(cache_file, kept);
+  return { hashes, drop: { dropped: entries.length - kept.length, total: entries.length } };
+}
+function record_entry(entry, hashes, graph) {
+  const { data } = entry.value;
+  if (!is_record(data) || "dependencies" in data) return false;
+  Object.assign(data, { dependencies: hashes.get(entry.key) ?? graph.closure_hash(entry.key) });
+  return true;
+}
+function record(cache_file, hashes, graph) {
+  const entries = read_entries(cache_file);
+  if (entries === void 0) return;
+  const recorded = entries.filter((entry) => record_entry(entry, hashes, graph));
+  if (recorded.length > 0) write_entries(cache_file, entries);
+}
+async function guard_counted(cache_file, run, root = process.cwd()) {
+  const graph = await import_graph.create(root);
+  if (graph === void 0) return { result: await run() };
+  const location = path.resolve(root, cache_file);
+  const { hashes, drop } = drop_stale(location, graph);
+  const result = await run();
+  record(location, hashes, graph);
+  return { result, drop };
+}
+async function guard(cache_file, run, root = process.cwd()) {
+  const { result } = await guard_counted(cache_file, run, root);
+  return result;
+}
+var eslint_cache_dependencies = { guard, guard_counted };
+
+export {
+  eslint_cache_dependencies
+};