@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-LKSSQVDA.js

@@ -1,49 +0,0 @@
-import {
-  core_budget
-} from "./chunk-ZCHZU6NX.js";
-import {
-  run_startup
-} from "./chunk-RV7EQIE4.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-import {
-  PACKAGE_JSON,
-  package_manifest
-} from "./chunk-WB4T3VY2.js";
-import {
-  INSTALL_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-install.ts
-import { existsSync } from "node:fs";
-var INSTALL_ARGUMENTS = ["install", "--frozen-lockfile"];
-var NO_MANIFEST_OUTPUT = `No ${PACKAGE_JSON} in the lane, so the dependency install was skipped.`;
-function has_manifest(directory) {
-  return existsSync(package_manifest.manifest_path(directory));
-}
-async function install_dependencies(directory) {
-  if (!has_manifest(directory)) return { is_installed: true, output: NO_MANIFEST_OUTPUT };
-  const admitted = await run_startup.waiting("install resource wait");
-  const result = await core_budget.with_command_reservation(
-    core_budget.CORE_WEIGHTS.install,
-    async () => {
-      await admitted();
-      return await run_startup.phase(
-        "dependency install",
-        async () => await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
-          cwd: directory,
-          timeout_ms: INSTALL_TIMEOUT_MS
-        }),
-        { edge_of: (value) => buffered_process.is_process_failed(value) ? "failed" : "done" }
-      );
-    },
-    { memory_mb: core_budget.MEMORY_MB.install, command: "lane install" }
-  );
-  return { is_installed: !buffered_process.is_process_failed(result), output: result.output };
-}
-var lane_install = { install_dependencies };
-
-export {
-  lane_install
-};

package/dist/commands/chunk-LNQOL2CL.js

@@ -1,321 +0,0 @@
-import {
-  bash_output_cap_reader
-} from "./chunk-JFLFGLE4.js";
-import {
-  cost_tokens,
-  lane_instructions
-} from "./chunk-4I5AA4P5.js";
-import {
-  document_section
-} from "./chunk-NDWZTWXV.js";
-import {
-  PACKAGE_DIR
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/document/entry-read-set.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-
-// scripts/document/read-set-cost.ts
-var NOTHING = 0;
-var ONE_LINE = 1;
-function cost_of(text) {
-  return { bytes: Buffer.byteLength(text, "utf8"), tokens: cost_tokens.estimate(text) };
-}
-function total(costs) {
-  const running = { bytes: NOTHING, tokens: NOTHING };
-  for (const cost of costs) {
-    running.bytes += cost.bytes;
-    running.tokens += cost.tokens;
-  }
-  return running;
-}
-function add_range(charged, found) {
-  for (let index = found.first_line; index <= found.last_line; index += ONE_LINE) charged.add(index);
-}
-function charged_lines(markdown, headings) {
-  const charged = /* @__PURE__ */ new Set();
-  for (const heading of headings) {
-    const found = document_section.section(markdown, heading);
-    if (found === void 0) return void 0;
-    add_range(charged, found);
-  }
-  return charged;
-}
-function extend_or_start(runs, index) {
-  const current = runs.at(-1);
-  if (current?.at(-1) === index - ONE_LINE) current.push(index);
-  else runs.push([index]);
-}
-function contiguous_runs(charged) {
-  const runs = [];
-  const ascending = [...charged].toSorted((left, right) => left - right);
-  for (const index of ascending) extend_or_start(runs, index);
-  return runs;
-}
-function run_text(lines, run) {
-  return run.map((index) => lines[index] ?? "").join("\n");
-}
-function scoped_file_cost(markdown, headings) {
-  const charged = charged_lines(markdown, headings);
-  if (charged === void 0) return cost_of(markdown);
-  const lines = markdown.split("\n");
-  return total(contiguous_runs(charged).map((run) => cost_of(run_text(lines, run))));
-}
-var read_set_cost = { cost_of, scoped_file_cost, total };
-
-// scripts/document/read-set-point-of-use.ts
-var POINT_OF_USE_FILES = /* @__PURE__ */ new Set([
-  "latest-gate.md",
-  "followup.md",
-  "chain-rule.md",
-  "background-commands.md",
-  "pre-gate-cut.md",
-  "progress-watcher.md",
-  "backlogrun-child.md",
-  "backlogrun-lanes.md",
-  "backlogrun-progress.md",
-  "backlogrun-park.md",
-  "backlogrun-steps.md",
-  // Read only when a delegated unit goes silent or a lane's pull request conflicts with `main` — a
-  // failure path, so a run in which nothing fails never reads it.
-  "backlogrun-recovery.md",
-  // Read only when `run:step` prints `pnpm josh retrospective` at a run's stop position — the very
-  // end of a run, never the entry. Kept out of every entry's read for the
-  // same reason the phase documents above are: no run that never drains its backlog reaches it.
-  "retrospective.md"
-]);
-var DEFERRED_DECISIONS = /* @__PURE__ */ new Set(["delegation.md", "issue-scout.md"]);
-var SPLIT_ASSESSMENT = "split-assessment.md";
-var POINT_OF_USE_BY_ENTRY = /* @__PURE__ */ new Map([
-  ["kickoff", DEFERRED_DECISIONS],
-  ["fullrun", DEFERRED_DECISIONS],
-  ["halfrun", DEFERRED_DECISIONS],
-  ["prrun", DEFERRED_DECISIONS],
-  ["backlogrun", /* @__PURE__ */ new Set([...DEFERRED_DECISIONS, "fullrun.md", SPLIT_ASSESSMENT])],
-  ["lane-child", /* @__PURE__ */ new Set([SPLIT_ASSESSMENT])]
-]);
-var NO_PER_ENTRY_FILES = /* @__PURE__ */ new Set();
-function is_point_of_use(entry, file) {
-  if (POINT_OF_USE_FILES.has(file)) return true;
-  return (POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES).has(file);
-}
-function point_of_use_files(entry, cited) {
-  const reached = [...POINT_OF_USE_FILES].filter((file) => cited.has(file));
-  return [...reached, ...POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES];
-}
-var read_set_point_of_use = {
-  POINT_OF_USE_FILES,
-  POINT_OF_USE_BY_ENTRY,
-  is_point_of_use,
-  point_of_use_files
-};
-
-// scripts/document/entry-read-set.ts
-var { POINT_OF_USE_FILES: POINT_OF_USE_FILES2, POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2, is_point_of_use: is_point_of_use2, point_of_use_files: point_of_use_files2 } = read_set_point_of_use;
-var { cost_of: cost_of2, scoped_file_cost: scoped_file_cost2, total: total2 } = read_set_cost;
-var SKILL_DIRECTORY = path.join(".claude", "skills", "workflow-commands");
-var SKILL_FILE = "SKILL.md";
-var LANE_CHILD = "lane-child";
-var TABLE_SECTION = "1. Which file to read";
-var NOTHING2 = 0;
-var HEADING_JOINER = '" + "';
-var SUBSECTION_PREFIX = "### ";
-var TABLE_ROW = /^\|(?<entry>[^|]+)\|(?<files>[^|]+)\|\s*$/u;
-var MARKDOWN_NAME = /`(?<name>[\w.-]+\.md)`/gu;
-var ENTRY_KEYWORD = /`(?<keyword>[a-z]+)/u;
-var SECTION_REFERENCE = /`(?<file>[\w.-]+\.md)` *→ *"(?<heading>[^"]+)"/gu;
-var WHITESPACE_RUN = /\s+/gu;
-function document_path(root, name) {
-  const in_project = path.join(root, SKILL_DIRECTORY, name);
-  const in_package = path.join(PACKAGE_DIR, SKILL_DIRECTORY, name);
-  const project_manifest = path.join(root, "package.json");
-  if (root !== "" && existsSync(project_manifest) && existsSync(in_package)) return in_package;
-  return existsSync(in_project) ? in_project : in_package;
-}
-function read_document(root, name) {
-  return document_section.read_optional(document_path(root, name)) ?? "";
-}
-function unique(names) {
-  return [...new Set(names)];
-}
-function all_matches(text, pattern) {
-  const scanner = new RegExp(pattern.source, pattern.flags);
-  const found = [];
-  let match = scanner.exec(text);
-  while (match !== null) {
-    found.push(match);
-    match = scanner.exec(text);
-  }
-  return found;
-}
-function group_of(match, name) {
-  return match.groups?.[name] ?? "";
-}
-function names_in(text) {
-  return all_matches(text, MARKDOWN_NAME).map((match) => group_of(match, "name"));
-}
-function columns_of(line) {
-  const groups = TABLE_ROW.exec(line)?.groups;
-  if (groups === void 0) return void 0;
-  const { entry = "", files = "" } = groups;
-  return { entry, files };
-}
-function to_row(line) {
-  const columns = columns_of(line);
-  if (columns === void 0) return void 0;
-  const { keyword } = ENTRY_KEYWORD.exec(columns.entry)?.groups ?? {};
-  return keyword === void 0 ? void 0 : { keyword, files: names_in(columns.files) };
-}
-function push_row(rows, line) {
-  const row = to_row(line);
-  if (row !== void 0 && row.files.length > NOTHING2) rows.set(row.keyword, row.files);
-}
-function table_rows(root) {
-  const rows = /* @__PURE__ */ new Map();
-  const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION);
-  const lines = (found?.text ?? "").split("\n");
-  for (const line of lines) {
-    if (line.startsWith(SUBSECTION_PREFIX)) break;
-    push_row(rows, line);
-  }
-  return rows;
-}
-function files_for(root, entry) {
-  if (entry === LANE_CHILD) return [path.basename(lane_instructions.WORKFLOW_ENTRY)];
-  const declared = table_rows(root).get(entry) ?? [];
-  return unique([SKILL_FILE, ...declared]).filter((file) => !is_point_of_use2(entry, file));
-}
-function fold(text) {
-  return text.replaceAll(WHITESPACE_RUN, " ").trim();
-}
-function is_sibling_document(root, name) {
-  return document_section.read_optional(document_path(root, name)) !== void 0;
-}
-function is_counted(root, entry, reference, files) {
-  if (is_point_of_use2(entry, reference.file)) return false;
-  return !files.includes(reference.file) && is_sibling_document(root, reference.file);
-}
-function to_reference(match) {
-  return { file: group_of(match, "file"), heading: fold(group_of(match, "heading")) };
-}
-function references_from(root, entry, text, files) {
-  return all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match)).filter((reference) => is_counted(root, entry, reference, files));
-}
-function sort_key(reference) {
-  return `${reference.file} ${reference.heading}`;
-}
-function dedupe(references) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const reference of references) seen.set(sort_key(reference), reference);
-  return [...seen].map(([, reference]) => reference);
-}
-function sections_for(root, entry, files) {
-  const found = files.filter((file) => file !== SKILL_FILE).flatMap((file) => references_from(root, entry, read_document(root, file), files));
-  return dedupe(found).toSorted((left, right) => sort_key(left).localeCompare(sort_key(right)));
-}
-function read_set(root, entry) {
-  const files = files_for(root, entry);
-  return { entry, files, sections: sections_for(root, entry, files) };
-}
-function section_cost(root, reference) {
-  const found = document_section.section(read_document(root, reference.file), reference.heading);
-  return {
-    ...reference,
-    // **An unresolvable reference is charged at the whole file.** Reporting it at zero would let a
-    // broken pointer read as a saving, which is the one direction this measurement must not move.
-    cost: cost_of2(found?.text ?? read_document(root, reference.file)),
-    is_resolved: found !== void 0
-  };
-}
-function referenced_cost(root, sections) {
-  const files = unique(sections.map((reference) => reference.file));
-  return total2(files.map((file) => cost_of2(read_document(root, file))));
-}
-function headings_for(sections, file) {
-  return sections.filter((reference) => reference.file === file).map((one) => one.heading);
-}
-function scoped_cost(root, sections) {
-  const files = unique(sections.map((reference) => reference.file));
-  return total2(
-    files.map((file) => scoped_file_cost2(read_document(root, file), headings_for(sections, file)))
-  );
-}
-function file_costs(root, names) {
-  return names.map((file) => ({ file, cost: cost_of2(read_document(root, file)) }));
-}
-function point_of_use_cost(root, file, references) {
-  const markdown = read_document(root, file);
-  const headings = unique(references.filter((one) => one.file === file).map((one) => one.heading));
-  if (headings.length === NOTHING2) {
-    return { file, heading: "", cost: cost_of2(markdown), is_resolved: true };
-  }
-  return {
-    file,
-    heading: headings.join(HEADING_JOINER),
-    cost: scoped_file_cost2(markdown, headings),
-    is_resolved: headings.every(
-      (heading) => document_section.section(markdown, heading) !== void 0
-    )
-  };
-}
-function path_texts(root, entry, table_text) {
-  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
-  const rows = table_text.split("\n").filter((line) => line.startsWith("|") && line.includes(`\`${entry}\``));
-  return [...manifests.map((file) => read_document(root, file)), ...rows];
-}
-function point_of_use_references(root, entry, table_text) {
-  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
-  const texts = [table_text, ...manifests.map((file) => read_document(root, file))];
-  return texts.flatMap(
-    (text) => all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match))
-  );
-}
-function entry_table_text(root) {
-  return document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? "";
-}
-function point_of_use_costs(root, entry, also) {
-  const table_text = entry === LANE_CHILD ? "" : entry_table_text(root);
-  const references = point_of_use_references(root, entry, table_text);
-  const named = path_texts(root, entry, table_text).flatMap((text) => names_in(text));
-  const cited = /* @__PURE__ */ new Set([...also, ...named]);
-  return point_of_use_files2(entry, cited).map((file) => point_of_use_cost(root, file, references));
-}
-function costed(root, entry, also = /* @__PURE__ */ new Set()) {
-  const { files, sections } = read_set(root, entry);
-  const own_costs = file_costs(root, files);
-  const section_costs = sections.map((reference) => section_cost(root, reference));
-  const own = total2(own_costs.map((row) => row.cost));
-  return {
-    entry,
-    files: own_costs,
-    sections: section_costs,
-    point_of_use: point_of_use_costs(root, entry, also),
-    bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
-    whole: total2([own, referenced_cost(root, sections)]),
-    scoped: total2([own, scoped_cost(root, sections)])
-  };
-}
-function entries(root) {
-  return [...table_rows(root)].map(([keyword]) => keyword);
-}
-var entry_read_set = {
-  HARNESS_DEFAULT_CAP_CHARS: bash_output_cap_reader.HARNESS_DEFAULT_CAP_CHARS,
-  POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2,
-  POINT_OF_USE_FILES: POINT_OF_USE_FILES2,
-  SECTION_REFERENCE,
-  SKILL_DIRECTORY,
-  SKILL_FILE,
-  TABLE_SECTION,
-  bash_output_cap: bash_output_cap_reader.bash_output_cap,
-  cost_of: cost_of2,
-  costed,
-  document_path,
-  entries,
-  read_set,
-  total: total2
-};
-
-export {
-  entry_read_set
-};

package/dist/commands/chunk-LS7P324N.js

@@ -1,72 +0,0 @@
-import {
-  BLOCKER,
-  PAGE,
-  blocker_node_schema,
-  git_gh_issue_graphql,
-  git_gh_issue_rest
-} from "./chunk-TFYYXETQ.js";
-import {
-  git_gh_transport
-} from "./chunk-LX2ENXHZ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-blocked-by-graphql.ts
-import { z } from "zod";
-var IDS_PER_QUERY = 100;
-var BLOCKED_BY_QUERY = `query($ids: [ID!]!) {
-	nodes(ids: $ids) { ... on Issue { id blockedBy(${PAGE}) { nodes { ${BLOCKER} } } } }
-}`;
-var issue_node_schema = z.object({
-  id: z.string(),
-  blockedBy: z.object({ nodes: z.array(blocker_node_schema) })
-});
-var nodes_schema = z.array(issue_node_schema.nullable());
-var response_schema = z.looseObject({ data: z.looseObject({ nodes: nodes_schema }) });
-function needs_read(row) {
-  if (row.node_id === void 0 || git_gh_issue_rest.is_pull_request(row)) return false;
-  return git_gh_issue_rest.total_blocked_by(row) !== 0;
-}
-function chunks_of(items) {
-  const chunks = [];
-  for (let start = 0; start < items.length; start += IDS_PER_QUERY) {
-    chunks.push(items.slice(start, start + IDS_PER_QUERY));
-  }
-  return chunks;
-}
-function to_blocked_by(row, node) {
-  const nodes = node.blockedBy.nodes.map(
-    (blocker) => git_gh_issue_graphql.to_blocking_issue(blocker)
-  );
-  return { nodes, totalCount: git_gh_issue_rest.total_blocked_by(row) ?? nodes.length };
-}
-async function query_nodes(ids) {
-  const json = await git_gh_transport.query({ query: BLOCKED_BY_QUERY, variables: { ids } });
-  if (json === void 0) return [];
-  return json_value.parse_with(json, response_schema)?.data.nodes ?? [];
-}
-function index_by_id(nodes) {
-  const resolved = nodes.filter((node) => node !== null);
-  return new Map(resolved.map((node) => [node.id, node]));
-}
-async function read_chunk(rows, answered) {
-  const by_id = index_by_id(await query_nodes(rows.map((row) => row.node_id)));
-  for (const row of rows) {
-    const node = by_id.get(row.node_id);
-    if (node !== void 0) answered.set(row, to_blocked_by(row, node));
-  }
-}
-async function read_answered(rows) {
-  const answered = /* @__PURE__ */ new Map();
-  const chunks = chunks_of(rows.filter((row) => needs_read(row)));
-  for (const chunk of chunks) {
-    await read_chunk(chunk, answered);
-  }
-  return answered;
-}
-var git_gh_blocked_by_graphql = { chunks_of, read_answered };
-
-export {
-  git_gh_blocked_by_graphql
-};

package/dist/commands/chunk-LU5EOGFQ.js

@@ -1,50 +0,0 @@
-import {
-  get_exit_code,
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-
-// scripts/git/git-grep-hits.ts
-var GREP_LINE = /^(?<path>[^:]+):(?<line>\d+):(?<text>.*)$/u;
-var MAX_EXCERPT_LENGTH = 80;
-var ELLIPSIS = "\u2026";
-var GREP_NO_MATCH_EXIT = 1;
-function shorten(text) {
-  const trimmed = text.trim();
-  if (trimmed.length <= MAX_EXCERPT_LENGTH) return trimmed;
-  return `${trimmed.slice(0, MAX_EXCERPT_LENGTH)}${ELLIPSIS}`;
-}
-function to_hit(output_line) {
-  const groups = GREP_LINE.exec(output_line)?.groups;
-  if (groups === void 0) return void 0;
-  const { path, line, text } = groups;
-  return { path, line, excerpt: shorten(text) };
-}
-function parse(stdout) {
-  const hits = stdout.split("\n").map((line) => to_hit(line));
-  return hits.filter((hit) => hit !== void 0);
-}
-async function search(target, flags, pathspecs, root) {
-  const location = root === void 0 ? [] : ["-C", root];
-  const grep_arguments = [
-    ...location,
-    "grep",
-    "-n",
-    "-I",
-    "-F",
-    ...flags,
-    "-e",
-    target,
-    "--",
-    ...pathspecs
-  ];
-  try {
-    return { hits: parse(await git_spawn.read(grep_arguments)), has_failed: false };
-  } catch (error) {
-    return { hits: [], has_failed: get_exit_code(error) !== GREP_NO_MATCH_EXIT };
-  }
-}
-var git_grep_hits = { parse, search };
-
-export {
-  git_grep_hits
-};

package/dist/commands/chunk-LX2ENXHZ.js

@@ -1,197 +0,0 @@
-import {
-  shared_cache
-} from "./chunk-WXLW7S4M.js";
-import {
-  gh_failure,
-  git_gh_exec
-} from "./chunk-43DU7DYZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-transport.ts
-import { z } from "zod";
-
-// scripts/gh/git-gh-rate-limit.ts
-var FORBIDDEN_STATUS = 403;
-var TOO_MANY_REQUESTS_STATUS = 429;
-var RATE_LIMIT_STATUSES = /* @__PURE__ */ new Set([
-  FORBIDDEN_STATUS,
-  TOO_MANY_REQUESTS_STATUS
-]);
-var MILLISECONDS_PER_SECOND = 1e3;
-var RATE_LIMIT_MESSAGE = /rate limit (?:already )?exceeded|exceeded a secondary rate limit/iu;
-var EXHAUSTED_HEADER = /^x-ratelimit-remaining:\s*0\s*$/imu;
-var RESET_HEADER = /^x-ratelimit-reset:\s*(?<epoch>\d+)\s*$/imu;
-var STATUS_PATTERNS = [
-  /\(HTTP (?<status>\d{3})\)/u,
-  /^HTTP\/\S+ (?<status>\d{3})/mu,
-  /"status":\s*"?(?<status>\d{3})/u
-];
-var AUTH_HINT = "check `gh auth status` and the network";
-function status_of(text) {
-  const status = STATUS_PATTERNS.map((pattern) => pattern.exec(text)?.groups?.["status"]).find(
-    (found) => found !== void 0
-  );
-  return status === void 0 ? void 0 : Number(status);
-}
-function is_exhausted(text) {
-  if (RATE_LIMIT_MESSAGE.test(text)) return true;
-  const status = status_of(text);
-  return status !== void 0 && RATE_LIMIT_STATUSES.has(status) && EXHAUSTED_HEADER.test(text);
-}
-function epoch_to_date(epoch) {
-  const seconds = Number(epoch);
-  if (epoch === void 0 || !Number.isSafeInteger(seconds) || seconds <= 0) return void 0;
-  return new Date(seconds * MILLISECONDS_PER_SECOND);
-}
-async function read_reset() {
-  try {
-    const epoch = await git_gh_exec.exec_gh_api({
-      path: "rate_limit",
-      jq_filter: ".resources.core.reset",
-      should_retry: false
-    });
-    return epoch_to_date(epoch.trim());
-  } catch (error) {
-    error_text.trace_swallowed("gh_rate_limit.read_reset", error);
-    return void 0;
-  }
-}
-function exhausted_message(resets_at) {
-  const when = resets_at === void 0 ? "at an unread time" : `at ${resets_at.toISOString()}`;
-  return `GitHub rate limit exhausted, resets ${when} \u2014 wait for the reset; this is not an authentication failure, so do not refresh gh auth`;
-}
-async function failure_hint(text) {
-  if (!is_exhausted(text)) return AUTH_HINT;
-  const resets_at = epoch_to_date(RESET_HEADER.exec(text)?.groups?.["epoch"]) ?? await read_reset();
-  return exhausted_message(resets_at);
-}
-var gh_rate_limit = { AUTH_HINT, exhausted_message, failure_hint, is_exhausted };
-
-// scripts/gh/git-gh-transport.ts
-var TRANSPORT_ENV_VAR = "JOSH_GH_TRANSPORT";
-var GRAPHQL_PATH = "graphql";
-var FORBIDDEN_STATUS2 = 403;
-var MS_KEPT = 36e5;
-var DEFAULT_HOST = "github.com";
-var PROBE_QUERY = "query { viewer { login } }";
-var NOT_PROBED = "not probed";
-var TRANSPORT_CACHE = { prefix: "josh-gh-transport-", ttl_ms: MS_KEPT };
-var REFUSED_MESSAGE = `GitHub refused a GraphQL read, and ${TRANSPORT_ENV_VAR}=graphql forbids reading it through REST \u2014 set it to auto or rest to read where GraphQL is refused`;
-var partial_document_schema = z.looseObject({
-  data: z.looseObject({}),
-  errors: z.array(z.unknown()).nonempty()
-});
-var transport_schema = z.enum(["graphql", "rest"]);
-var setting_schema = z.enum(["auto", "graphql", "rest"]);
-var logins = /* @__PURE__ */ new Map();
-function parse_setting(raw) {
-  if (raw === void 0 || raw === "") return "auto";
-  return setting_schema.safeParse(raw).data;
-}
-function setting() {
-  const raw = process.env[TRANSPORT_ENV_VAR];
-  const parsed = parse_setting(raw);
-  if (parsed === void 0) {
-    throw new Error(`${TRANSPORT_ENV_VAR} must be auto, graphql or rest, not ${String(raw)}`);
-  }
-  return parsed;
-}
-async function read_login(host) {
-  try {
-    return await git_gh_exec.exec_gh_command(["config", "get", "user", "--host", host]);
-  } catch {
-    return "";
-  }
-}
-async function key_of() {
-  const host = process.env["GH_HOST"] ?? DEFAULT_HOST;
-  const login = logins.get(host) ?? read_login(host);
-  logins.set(host, login);
-  return `${host}/${await login}`;
-}
-function is_refused(error) {
-  if (gh_failure.failure_of(error)?.status !== FORBIDDEN_STATUS2) return false;
-  return !gh_rate_limit.is_exhausted(error_text.message_of(error));
-}
-async function send(body) {
-  return await git_gh_exec.exec_gh_api({ path: GRAPHQL_PATH, body: JSON.stringify(body) });
-}
-async function probe() {
-  try {
-    await send({ query: PROBE_QUERY });
-    return "graphql";
-  } catch (error) {
-    return is_refused(error) ? "rest" : void 0;
-  }
-}
-async function current(now_ms = Date.now()) {
-  const chosen = setting();
-  if (chosen !== "auto") return chosen;
-  const request = { slot: TRANSPORT_CACHE, key: await key_of(), schema: transport_schema };
-  return await shared_cache.remember(request, probe, now_ms) ?? "graphql";
-}
-async function on_failure(error, now_ms) {
-  if (!is_refused(error)) return;
-  if (setting() === "graphql") throw new Error(REFUSED_MESSAGE, { cause: error });
-  shared_cache.write(TRANSPORT_CACHE, await key_of(), "rest", now_ms);
-}
-function partial_answer(error) {
-  const body = gh_failure.body_of(error);
-  if (body === void 0) return void 0;
-  return json_value.parse_with(body, partial_document_schema) === void 0 ? void 0 : body;
-}
-async function sent_or_failed(body, now_ms, recovered) {
-  try {
-    return await send(body);
-  } catch (error) {
-    await on_failure(error, now_ms);
-    return recovered?.(error);
-  }
-}
-async function answer_of(body, now_ms, recovered) {
-  if (await current(now_ms) === "rest") return void 0;
-  return await sent_or_failed(body, now_ms, recovered);
-}
-async function query(body, now_ms = Date.now()) {
-  return await answer_of(body, now_ms);
-}
-async function query_partial(body, now_ms = Date.now()) {
-  return await answer_of(body, now_ms, partial_answer);
-}
-async function kept(now_ms) {
-  return shared_cache.read(TRANSPORT_CACHE, await key_of(), transport_schema, now_ms);
-}
-async function known(now_ms = Date.now()) {
-  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
-  if (chosen === void 0) return void 0;
-  return chosen === "auto" ? await kept(now_ms) : chosen;
-}
-async function label(now_ms = Date.now()) {
-  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
-  if (chosen === void 0) return `invalid ${TRANSPORT_ENV_VAR}`;
-  if (chosen !== "auto") return chosen;
-  return `${await kept(now_ms) ?? NOT_PROBED} (auto)`;
-}
-function forget_logins() {
-  logins.clear();
-}
-var git_gh_transport = {
-  current,
-  forget_logins,
-  known,
-  label,
-  query,
-  query_partial,
-  TRANSPORT_CACHE
-};
-
-export {
-  gh_rate_limit,
-  GRAPHQL_PATH,
-  git_gh_transport
-};