@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-XDF25GSU.js

@@ -1,536 +0,0 @@
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-import {
-  token_shape
-} from "./chunk-AQ3PMSXK.js";
-import {
-  gh_api
-} from "./chunk-QVOFWFWC.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  agent_session_environment
-} from "./chunk-HHBC6QZE.js";
-import {
-  get_exit_code,
-  has_timed_out
-} from "./chunk-VJE3RJAX.js";
-import {
-  COMMAND_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync } from "execa";
-
-// scripts/gh/gh-call-kind.ts
-var API = "api";
-var GRAPHQL = "graphql";
-var RATE_LIMIT = "GET rate_limit";
-var GH_PREFIX = "gh ";
-var DEFAULT_METHOD = "GET";
-var BODY_METHOD = "POST";
-var OWNER_REPO = ["repos", "{o}", "{r}"];
-var NUMBER = /^\d+$/u;
-var SHA = /^[\da-f]{7,40}$/u;
-var { METHOD_FLAGS, FIELD_FLAGS: BODY_FLAGS, API_VALUE_TAKING_FLAGS: VALUE_FLAGS } = gh_api;
-var NAME_AFTER = /* @__PURE__ */ new Map([
-  ["commits", "{ref}"],
-  ["branches", "{branch}"],
-  ["heads", "{branch}"],
-  ["labels", "{label}"],
-  ["compare", "{range}"]
-]);
-function placeholder_of(segment, previous = "") {
-  const named = NAME_AFTER.get(previous);
-  if (named !== void 0) return named;
-  if (NUMBER.test(segment)) return "{n}";
-  return SHA.test(segment) ? "{sha}" : segment;
-}
-function normalized(path) {
-  const [bare = ""] = path.replace(/^\//u, "").split("?", 1);
-  const segments = bare.split("/");
-  const is_repo = segments[0] === OWNER_REPO[0];
-  return segments.map(
-    (segment, index) => is_repo && index < OWNER_REPO.length ? OWNER_REPO[index] : placeholder_of(segment, segments[index - 1])
-  ).join("/");
-}
-function of_api(path, method = DEFAULT_METHOD) {
-  const bare = normalized(path);
-  return bare === GRAPHQL ? GRAPHQL : `${method.toUpperCase()} ${bare}`;
-}
-function path_of(arguments_) {
-  const rest = arguments_.slice(1);
-  return rest.find(
-    (argument, index) => !argument.startsWith("-") && !VALUE_FLAGS.has(rest[index - 1] ?? "")
-  ) ?? "";
-}
-function method_of(arguments_) {
-  const flag = arguments_.findIndex((argument) => METHOD_FLAGS.has(argument));
-  if (flag !== -1) return arguments_[flag + 1] ?? DEFAULT_METHOD;
-  return arguments_.some((argument) => BODY_FLAGS.has(argument)) ? BODY_METHOD : DEFAULT_METHOD;
-}
-function of(arguments_) {
-  const [subcommand = "", action = ""] = arguments_;
-  if (subcommand === API) return of_api(path_of(arguments_), method_of(arguments_));
-  const named = action.startsWith("-") ? [subcommand] : [subcommand, action];
-  return `${GH_PREFIX}${named.join(" ")}`.trimEnd();
-}
-function class_of(kind) {
-  if (kind === GRAPHQL) return "graphql";
-  if (kind === RATE_LIMIT) return "free";
-  return kind.startsWith(GH_PREFIX) ? "gh" : "rest";
-}
-var gh_call_kind = { of, of_api, class_of };
-
-// scripts/gh/gh-request-tally.ts
-var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
-function is_state(value) {
-  return typeof value === "object" && value !== null && Reflect.has(value, "endpoints");
-}
-function shared_state() {
-  const existing = Reflect.get(globalThis, STATE_KEY);
-  if (is_state(existing)) return existing;
-  const state = {
-    tally: { calls: 0, not_modified: 0 },
-    endpoints: /* @__PURE__ */ new Map(),
-    core: { read: void 0, start: void 0 }
-  };
-  Reflect.set(globalThis, STATE_KEY, state);
-  return state;
-}
-var { tally, endpoints, core } = shared_state();
-function watch_core(read) {
-  core.read = async () => {
-    try {
-      return await read();
-    } catch {
-      return void 0;
-    }
-  };
-}
-function endpoint_of(kind) {
-  const count = endpoints.get(kind) ?? { calls: 0, not_modified: 0 };
-  endpoints.set(kind, count);
-  return count;
-}
-function snapshot() {
-  const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
-  return { ...tally, endpoints: Object.fromEntries(entries) };
-}
-function count_call(kind) {
-  if (core.read !== void 0) core.start ??= core.read();
-  tally.calls += 1;
-  endpoint_of(kind).calls += 1;
-}
-function count_not_modified(kind) {
-  tally.not_modified += 1;
-  endpoint_of(kind).not_modified += 1;
-}
-function to_delta(start, end) {
-  if (start === void 0 || start.reset_ms !== end?.reset_ms) return void 0;
-  return end.used - start.used;
-}
-async function core_delta() {
-  if (core.read === void 0 || core.start === void 0) return void 0;
-  const [start, end] = await Promise.all([core.start, core.read()]);
-  return to_delta(start, end);
-}
-function reset() {
-  tally.calls = 0;
-  tally.not_modified = 0;
-  endpoints.clear();
-  core.read = void 0;
-  core.start = void 0;
-}
-var gh_request_tally = {
-  watch_core,
-  count_call,
-  count_not_modified,
-  snapshot,
-  core_delta,
-  reset
-};
-
-// scripts/gh/git-gh-check.ts
-import { execa } from "execa";
-var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
-var gh_check = {};
-async function run_gh_check() {
-  try {
-    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
-  } catch {
-    delete gh_check.promise;
-    throw new Error(GH_NOT_INSTALLED_MSG);
-  }
-}
-async function check_gh_installed() {
-  gh_check.promise ??= run_gh_check();
-  await gh_check.promise;
-}
-
-// scripts/git/parse-json-array.ts
-function parse_json_loose(raw_json) {
-  return json_value.parse_or_undefined(raw_json);
-}
-function parse_json_array_or_undefined(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (!Array.isArray(value)) return void 0;
-  return element_schema.array().parse(value);
-}
-function read_json_listing(raw_json, element_schema) {
-  try {
-    const rows = parse_json_array_or_undefined(raw_json, element_schema);
-    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
-  } catch {
-    return { kind: "unexpected_shape" };
-  }
-}
-function parse_json_array_safe(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return [];
-  return element_schema.array().parse(value);
-}
-function parse_json_object_or_undefined(raw_json, schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return void 0;
-  return schema.parse(value);
-}
-var parse_json = {
-  parse_json_object_or_undefined
-};
-
-// scripts/gh/git-gh-failure.ts
-import { z } from "zod";
-var error_document_schema = z.object({ status: z.union([z.string(), z.number()]).optional() }).catch({});
-var GH_FAILURE_FIELD = "gh_failure";
-function has_stdout_field(error) {
-  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
-}
-function has_gh_failure(error) {
-  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
-}
-function parse_response_status(stdout) {
-  const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
-  if (document?.status === void 0) return void 0;
-  const status = Number(document.status);
-  return Number.isSafeInteger(status) ? status : void 0;
-}
-function classify_stdout(stdout) {
-  return { status: parse_response_status(stdout) };
-}
-function attach(error, failure) {
-  Object.defineProperty(error, GH_FAILURE_FIELD, {
-    value: failure,
-    enumerable: false,
-    configurable: true
-  });
-  return error;
-}
-function failure_of(error) {
-  return has_gh_failure(error) ? error.gh_failure : void 0;
-}
-function body_of(error) {
-  const cause = error instanceof Error ? error.cause : void 0;
-  return has_stdout_field(cause) ? cause.stdout : void 0;
-}
-var gh_failure = { attach, body_of, classify_stdout, failure_of, parse_response_status };
-
-// scripts/gh/git-gh-retry.ts
-import { setTimeout as delay } from "node:timers/promises";
-var FIRST_RETRY_DELAY_MS = 2e3;
-var SECOND_RETRY_DELAY_MS = 5e3;
-var RETRY_DELAYS_MS = [FIRST_RETRY_DELAY_MS, SECOND_RETRY_DELAY_MS];
-var MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
-var SERVER_ERROR_FLOOR = 500;
-var GH_AUTH_REQUIRED_EXIT_CODE = 4;
-var SPENT_NOTE = "gh: request failed transiently on every attempt";
-var SUMMARY_STATUS_PATTERN = /\(HTTP (?<status>\d{3})\)/u;
-var DEFAULT_HOOKS = {
-  wait: async (milliseconds) => {
-    await delay(milliseconds);
-  },
-  note: (text) => {
-    process.stderr.write(`${text}
-`);
-  }
-};
-function summary_status(error) {
-  const { status } = SUMMARY_STATUS_PATTERN.exec(error.message)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
-}
-function has_answer(spawn_error) {
-  if (!(spawn_error instanceof Error) || !("stdout" in spawn_error)) return false;
-  return typeof spawn_error.stdout === "string" && spawn_error.stdout.trim().length > 0;
-}
-function is_transient_status(status, spawn_error, is_read) {
-  if (is_read && has_timed_out(spawn_error)) return true;
-  if (status === void 0) return !has_answer(spawn_error);
-  return status >= SERVER_ERROR_FLOOR;
-}
-function is_final_spawn(spawn_error, is_read) {
-  return !is_read && has_timed_out(spawn_error) || get_exit_code(spawn_error) === GH_AUTH_REQUIRED_EXIT_CODE;
-}
-function is_transient_request(error, is_read) {
-  const failure = gh_failure.failure_of(error);
-  if (failure === void 0 || !(error instanceof Error)) return false;
-  const status = failure.status ?? summary_status(error);
-  return !is_final_spawn(error.cause, is_read) && is_transient_status(status, error.cause, is_read);
-}
-function is_transient(error) {
-  return is_transient_request(error, false);
-}
-function first_line(error) {
-  return error_text.message_of(error).split("\n", 1)[0] ?? "";
-}
-function retry_note(error, attempt, wait_ms) {
-  const ordinal = `${String(attempt)}/${String(MAX_ATTEMPTS)}`;
-  return `gh: request failed transiently (attempt ${ordinal}: ${first_line(error)}) \u2014 retrying in ${String(wait_ms)} ms`;
-}
-function retry_delay(error, attempt, is_read) {
-  return is_transient_request(error, is_read) ? RETRY_DELAYS_MS[attempt - 1] : void 0;
-}
-function spent_note(message) {
-  return `${SPENT_NOTE} (${message})`;
-}
-function note_spent(error, attempt, hooks, is_read) {
-  if (attempt === MAX_ATTEMPTS && is_transient_request(error, is_read)) {
-    hooks.note(spent_note(first_line(error)));
-  }
-}
-async function retry_request(request, hooks, attempt, is_read) {
-  try {
-    return await request();
-  } catch (error) {
-    const wait_ms = retry_delay(error, attempt, is_read);
-    if (wait_ms === void 0) {
-      note_spent(error, attempt, hooks, is_read);
-      throw error;
-    }
-    hooks.note(retry_note(error, attempt, wait_ms));
-    await hooks.wait(wait_ms);
-    return await retry_request(request, hooks, attempt + 1, is_read);
-  }
-}
-async function with_retry(request, hooks = DEFAULT_HOOKS, attempt = 1) {
-  return await retry_request(request, hooks, attempt, false);
-}
-async function with_read_retry(request, hooks = DEFAULT_HOOKS) {
-  return await retry_request(request, hooks, 1, true);
-}
-var gh_retry = {
-  MAX_ATTEMPTS,
-  RETRY_DELAYS_MS,
-  is_transient,
-  spent_note,
-  with_retry,
-  with_read_retry
-};
-
-// scripts/gh/git-gh-spawn-width.ts
-var GH_SPAWN_CONCURRENCY = 8;
-
-// scripts/gh/git-gh-exec.ts
-var BODY_FROM_STDIN = "-";
-var GH_REQUEST_TIMEOUT_MS = 6e4;
-function to_timeout_option(timeout_ms) {
-  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
-}
-function direct_environment() {
-  const removed = agent_session_environment.removed_proxy_environment();
-  return Object.keys(removed).length > 0 ? { env: removed } : {};
-}
-function to_spawn_options(timeout_ms, cwd) {
-  return {
-    ...to_timeout_option(timeout_ms),
-    ...direct_environment(),
-    ...cwd !== void 0 && { cwd }
-  };
-}
-var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
-function has_stderr_field(error) {
-  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
-}
-function to_timeout_prefix(error) {
-  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
-}
-function to_gh_error(error) {
-  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
-  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
-  const detail = stdout.length > 0 ? `${summary}
-${stdout}` : summary;
-  return gh_failure.attach(
-    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
-    gh_failure.classify_stdout(stdout)
-  );
-}
-var gh_slots = bounded_pool.limiter(GH_SPAWN_CONCURRENCY);
-async function spawn_gh_command(arguments_, timeout_ms, cwd) {
-  await check_gh_installed();
-  const options = to_spawn_options(timeout_ms, cwd);
-  gh_request_tally.count_call(gh_call_kind.of(arguments_));
-  try {
-    const { stdout } = await execa2("gh", arguments_, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-async function exec_gh_command(arguments_, timeout_ms, cwd) {
-  return await gh_slots.run(async () => await spawn_gh_command(arguments_, timeout_ms, cwd));
-}
-async function spawn_gh_command_with_stdin(input) {
-  await check_gh_installed();
-  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
-  gh_request_tally.count_call(gh_call_kind.of(input.args));
-  try {
-    const { stdout } = await execa2("gh", input.args, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-async function exec_gh_command_with_stdin(input) {
-  return await gh_slots.run(async () => await spawn_gh_command_with_stdin(input));
-}
-var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
-function parse_status_line(output) {
-  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
-}
-function status_of_failure(error) {
-  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
-}
-async function spawn_gh_api_status(path, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    await check_gh_installed();
-    gh_request_tally.count_call(gh_call_kind.of_api(path));
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-async function exec_gh_api_status(path, timeout_ms) {
-  return await gh_slots.run(async () => await spawn_gh_api_status(path, timeout_ms));
-}
-function exec_gh_api_status_sync(path, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  gh_request_tally.count_call(gh_call_kind.of_api(path));
-  try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-var METHOD_FLAG = "--method";
-var INPUT_FLAG = "--input";
-var PAGINATE_FLAG = "--paginate";
-var SLURP_FLAG = "--slurp";
-var JQ_FLAG = "--jq";
-var ALLOW_ESCAPES_FLAG = "--allow-escape-sequences";
-function optional_flag(flag, value) {
-  return value === void 0 ? [] : [flag, value];
-}
-function refuse_credential_body(request) {
-  if (request.body !== void 0) {
-    token_shape.refuse(token_shape.decoded(request.body), `The gh api ${request.path} body`);
-  }
-}
-function to_gh_api_args(request) {
-  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
-  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
-  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
-  const escape_args = request.should_allow_escapes === true ? [ALLOW_ESCAPES_FLAG] : [];
-  return [
-    "api",
-    request.path,
-    ...optional_flag(METHOD_FLAG, request.method),
-    ...body_args,
-    ...paginate_args,
-    ...slurp_args,
-    ...escape_args,
-    ...optional_flag(JQ_FLAG, request.jq_filter)
-  ];
-}
-async function send_gh_api(request) {
-  const args = to_gh_api_args(request);
-  if (request.body === void 0) {
-    return await exec_gh_command(args, request.timeout_ms, request.cwd);
-  }
-  return await exec_gh_command_with_stdin({
-    args,
-    stdin_body: request.body,
-    timeout_ms: request.timeout_ms,
-    cwd: request.cwd
-  });
-}
-async function exec_gh_api(request) {
-  refuse_credential_body(request);
-  if (request.should_retry === false) return await send_gh_api(request);
-  return await gh_retry.with_retry(async () => await send_gh_api(request));
-}
-async function exec_gh_api_uncounted(request) {
-  const options = to_spawn_options(request.timeout_ms, request.cwd);
-  try {
-    const { stdout } = await execa2("gh", to_gh_api_args(request), options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-function exec_gh_api_sync(request) {
-  refuse_credential_body(request);
-  const body_option = request.body === void 0 ? {} : { input: request.body };
-  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
-  const gh_arguments = to_gh_api_args(request);
-  gh_request_tally.count_call(gh_call_kind.of(gh_arguments));
-  try {
-    const { stdout } = execaSync("gh", gh_arguments, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-function read_gh_api_sync(request) {
-  try {
-    return exec_gh_api_sync(request);
-  } catch {
-    return void 0;
-  }
-}
-var git_gh_exec = {
-  direct_environment,
-  exec_gh_command,
-  exec_gh_command_with_stdin,
-  exec_gh_api,
-  exec_gh_api_uncounted,
-  exec_gh_api_sync,
-  read_gh_api_sync,
-  exec_gh_api_status,
-  exec_gh_api_status_sync,
-  parse_status_line
-};
-
-export {
-  gh_call_kind,
-  gh_request_tally,
-  parse_json_array_or_undefined,
-  read_json_listing,
-  parse_json_array_safe,
-  parse_json_object_or_undefined,
-  parse_json,
-  has_stdout_field,
-  gh_failure,
-  gh_retry,
-  GH_SPAWN_CONCURRENCY,
-  has_stderr_field,
-  git_gh_exec
-};

package/dist/commands/chunk-XFPEUYDV.js

@@ -1,67 +0,0 @@
-import {
-  NEEDS_HUMAN_REVIEW_LABEL,
-  PLANNED_LABEL,
-  has_any_label,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-
-// scripts/issue/issue-state.ts
-import { z } from "zod";
-var NO_LABELS = "(none)";
-var LABEL_SEPARATOR = ", ";
-var STATE_LABEL = "state: ";
-var LABELS_LABEL = "labels: ";
-var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
-var YES = "yes";
-var NO = "no";
-var ISSUE_LABEL = "issue: ";
-var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z.looseObject({ name: z.string() });
-var issue_state_schema = z.looseObject({
-  state: z.string(),
-  labels: label_schema.array().optional()
-});
-function parse_issue_state(json) {
-  try {
-    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
-    if (parsed === void 0) return void 0;
-    const labels = parsed.labels ?? [];
-    return {
-      state: parsed.state,
-      labels: labels.map((label) => label.name),
-      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
-    };
-  } catch {
-    return void 0;
-  }
-}
-function format_labels(labels) {
-  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
-}
-function format_issue_state(state) {
-  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
-  return `${STATE_LABEL}${state.state}
-${LABELS_LABEL}${format_labels(state.labels)}
-${human_review}`;
-}
-function format_attributed_issue_state(issue_number, state) {
-  return `${ISSUE_LABEL}${issue_number}
-${format_issue_state(state)}`;
-}
-function is_planned(read) {
-  return read.kind === "state" && has_label_name(read.state.labels, PLANNED_LABEL);
-}
-var issue_state = {
-  is_planned,
-  NO_LABELS,
-  parse_issue_state,
-  format_issue_state,
-  format_attributed_issue_state
-};
-
-export {
-  issue_state
-};

package/dist/commands/chunk-XFWI6WHH.js

@@ -1,60 +0,0 @@
-import {
-  gate_skip
-} from "./chunk-WCEUMOKK.js";
-import {
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/gate/hook-gate-reuse.ts
-var GATE_REUSING_TARGETS = ["pre-commit-type-check", "pre-push-unit"];
-var WORKTREE_COLUMN = 1;
-var UNMODIFIED = " ";
-function is_force_requested(force_environment) {
-  return (process.env[force_environment] ?? "") !== "";
-}
-async function read_status_lines() {
-  try {
-    const status = await git_command.status();
-    return status.split("\n").filter((line) => line !== "").filter((line) => !observation_ledger.is_ledger_line(line));
-  } catch {
-    return void 0;
-  }
-}
-function is_worktree_clean(lines) {
-  return lines?.length === 0;
-}
-function is_index_matching_worktree(lines) {
-  return lines?.every((line) => line[WORKTREE_COLUMN] === UNMODIFIED) === true;
-}
-var ARGUMENTS_MISS = "arguments were passed to the hook";
-function force_miss(force_environment) {
-  return `${force_environment} is set`;
-}
-function hook_reuse(input) {
-  if (input.extra_arguments.length > 0) return { miss: ARGUMENTS_MISS };
-  if (is_force_requested(input.force_env)) return { miss: force_miss(input.force_env) };
-  if (!input.is_tree_carried) return { miss: input.carry_miss };
-  return gate_skip.gate_reuse(input.tree.files, input.tree.base, input.source);
-}
-function miss_kind(miss, input) {
-  if (miss === ARGUMENTS_MISS) return "arguments";
-  if (miss === force_miss(input.force_env)) return "forced";
-  if (miss === input.carry_miss) return "tree-not-carried";
-  return gate_skip.miss_kind(miss);
-}
-var hook_gate_reuse = {
-  GATE_REUSING_TARGETS,
-  hook_reuse,
-  is_force_requested,
-  is_index_matching_worktree,
-  is_worktree_clean,
-  miss_kind,
-  read_status_lines
-};
-
-export {
-  hook_gate_reuse
-};