@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-WCYRNNKF.js

@@ -0,0 +1,76 @@
+import {
+  guard_remedy
+} from "./chunk-KK7TEL5G.js";
+import {
+  delivered_rules
+} from "./chunk-FJMXUDEY.js";
+import {
+  hook_decision
+} from "./chunk-GB2BRQVL.js";
+import {
+  hook_context
+} from "./chunk-CUWT6UQO.js";
+import {
+  time_hook_transcript,
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/rule-rewrite.ts
+var REWRITING_RULES = delivered_rules.DELIVERED_RULES.filter(
+  (rule) => guard_remedy.is_rewrite(rule.id) && rule.rewrite !== void 0
+);
+var NOTE_SEPARATOR = "\n\n";
+function read_payload_tail(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload ? transcript_tail.read_tail(
+      time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id)
+    ) : "";
+  } catch {
+    return "";
+  }
+}
+function tail_reader(raw_payload) {
+  const cache = {};
+  return function tail() {
+    cache.tail ??= read_payload_tail(raw_payload);
+    return cache.tail;
+  };
+}
+function fold(name, typed, tail, context) {
+  const folded = { input: typed, notes: [] };
+  for (const rule of REWRITING_RULES) {
+    const input = rule.rewrite?.({ name, input: folded.input }, tail, context);
+    if (input === void 0) {
+      continue;
+    }
+    folded.input = input;
+    folded.notes = [...folded.notes, rule.rewrite_note ?? ""];
+  }
+  return folded;
+}
+function typed_payload(raw_payload) {
+  const fields = json_value.parse_or_undefined(raw_payload);
+  if (!json_value.is_record(fields)) return void 0;
+  const input = fields["tool_input"];
+  return json_value.is_record(input) ? { fields, name: String(fields["tool_name"]), input } : void 0;
+}
+function rewrite(raw_payload, context = hook_context.from_process()) {
+  const typed = delivered_rules.is_enabled() ? typed_payload(raw_payload) : void 0;
+  if (typed === void 0) return void 0;
+  const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload), context);
+  if (notes.length === 0) return void 0;
+  const note = notes.join(NOTE_SEPARATOR);
+  return { payload: JSON.stringify({ ...typed.fields, tool_input: input }), input, note };
+}
+var rule_rewrite = {
+  NOTE_SEPARATOR,
+  rewrite
+};
+
+export {
+  rule_rewrite
+};

package/dist/commands/chunk-WEUUJIWQ.js

@@ -0,0 +1,84 @@
+// scripts/test/whole-suite-files.ts
+import path from "node:path";
+
+// scripts/test/unit-setup-files.ts
+var STATE_GUARD = ["./tools/test/test-state-guard.ts"];
+var STDOUT_GUARD = ["./tools/test/test-stdout-guard.ts"];
+var TELEGRAM_GUARD = ["./tools/test/test-telegram-guard.ts"];
+var MACHINE_GUARD = ["./tools/test/test-machine-guard.ts"];
+var NETWORK_GUARD = ["./tools/test/test-network-guard.ts"];
+var WORKER_GUARDS = [...STDOUT_GUARD, ...TELEGRAM_GUARD, ...MACHINE_GUARD];
+var READ_RECORDER = ["./tools/test/test-read-recorder.ts"];
+var UNIT_FILE_REPORTER = "./vitest.reporter.config.ts";
+var unit_setup_files = {
+  MACHINE_GUARD,
+  NETWORK_GUARD,
+  READ_RECORDER,
+  STATE_GUARD,
+  STDOUT_GUARD,
+  UNIT_FILE_REPORTER,
+  TELEGRAM_GUARD,
+  WORKER_GUARDS
+};
+
+// scripts/test/whole-suite-files.ts
+var SETUP_FILES = [
+  ...unit_setup_files.NETWORK_GUARD,
+  ...unit_setup_files.STATE_GUARD,
+  ...unit_setup_files.WORKER_GUARDS,
+  ...unit_setup_files.READ_RECORDER
+];
+var ROOT_FILES = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "tsconfig.json",
+  "vitest.config.ts",
+  "vitest.harness.config.ts",
+  // What the read recorder runs in every worker, which no test imports through the setup file.
+  "tools/test/test-read-capture.ts",
+  "scripts/test/test-read-trace.ts"
+];
+var IMPORTED_BY_EVERY_TEST = [
+  "scripts/agent/agent-headless.ts",
+  "scripts/git/constants.ts",
+  "scripts/git/git-location-environment.ts",
+  "scripts/init/init-paths.ts",
+  "scripts/josh/agent-session-environment.ts",
+  "scripts/josh/platform-temporary.ts",
+  "scripts/josh/process-identity.ts",
+  "scripts/josh/process-owner.ts",
+  "scripts/josh/stamp-file.ts",
+  "scripts/lane/lane-child-mark-keys.ts",
+  "scripts/lib/atomic-write.ts",
+  "scripts/lib/json-value.ts",
+  "scripts/lib/read-file.ts",
+  "scripts/lib/timeouts.ts",
+  "scripts/run/run-headless-keys.ts",
+  "scripts/test/unit-durations.ts",
+  "scripts/test/unit-run-marker.ts",
+  "scripts/test/unit-setup-files.ts",
+  "scripts/test/vitest-cache-directory.ts",
+  "scripts/test/vitest-cli-excludes.ts",
+  "tools/test/duration-sequencer.ts",
+  "tools/test/duration-shard.ts",
+  "tools/test/pure-files.ts",
+  "tools/test/test-module-elapsed.ts",
+  "tools/test/test-repository-guard.ts",
+  "tools/test/unit-duration-record.ts",
+  "tools/test/unit-guard-environment.ts",
+  "tools/test/unit-projects.ts",
+  "tools/test/vitest-config-workers.ts",
+  "tools/test/vitest-include-globs.ts"
+];
+var WHOLE_SUITE_FILES = new Set(
+  [...ROOT_FILES, ...IMPORTED_BY_EVERY_TEST, ...SETUP_FILES].map((file) => path.normalize(file))
+);
+var EVERY_TEST_IMPORTS = new Set(
+  IMPORTED_BY_EVERY_TEST.map((file) => path.normalize(file))
+);
+var whole_suite_files = { EVERY_TEST_IMPORTS, WHOLE_SUITE_FILES };
+
+export {
+  whole_suite_files
+};

package/dist/commands/chunk-WNBJK6QE.js

@@ -0,0 +1,84 @@
+import {
+  ls_remote_branch_arguments
+} from "./chunk-ZBFNQUY7.js";
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  PORCELAIN_FLAG
+} from "./chunk-B5GXZK3E.js";
+import {
+  INSTALL_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-worktree.ts
+var WORKTREE = "worktree";
+var ORIGIN = "origin";
+var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
+var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
+async function locked(arguments_, timeout_ms) {
+  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
+  const output = await repository_lock.with_lock(
+    async () => await git_spawn.read(arguments_, timeout_ms),
+    target,
+    WORKTREE_LOCK_MAX_WAIT_MS
+  );
+  if (output === void 0) {
+    throw new Error(
+      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
+    );
+  }
+  return output;
+}
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+}
+async function worktree_add(directory, branch_name, start_point) {
+  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
+  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
+}
+async function set_upstream(branch_name) {
+  await locked(["config", `branch.${branch_name}.remote`, ORIGIN]);
+  await locked(["config", `branch.${branch_name}.merge`, `refs/heads/${branch_name}`]);
+}
+async function worktree_add_detached(directory, commit) {
+  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
+}
+async function worktree_remove(directory) {
+  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
+}
+async function worktree_prune() {
+  return await locked([WORKTREE, "prune"]);
+}
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
+}
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
+}
+async function is_linked() {
+  const [own, common] = await git_command.git_directories();
+  return own !== common;
+}
+var git_worktree = {
+  is_linked,
+  branch_delete,
+  ls_remote_branch,
+  set_upstream,
+  worktree_add,
+  worktree_add_detached,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
+
+export {
+  git_worktree
+};

package/dist/commands/chunk-WR5PKCQW.js

@@ -0,0 +1,61 @@
+import {
+  run_preflight
+} from "./chunk-GAVSK6P6.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/git/stash/stash-orphans.ts
+var HASH_PATTERN = /#(?<issue>\d+)\b/u;
+var LEADING_PATTERN = /(?:^|: )(?<issue>\d+): /u;
+var MESSAGE_PATTERNS = [HASH_PATTERN, LEADING_PATTERN];
+var ALL_ISSUE_PATTERN = new RegExp(HASH_PATTERN.source, "gu");
+var BRANCH_PATTERN = /^(?:WIP on|On) (?<issue>\d+)-lane: /u;
+var WIP_PREFIX = "WIP on ";
+var NO_PATTERNS = [];
+var HEADER = "Stashes whose issue is closed, or whose owner cannot be read \u2014 decide for each whether to revive or discard it (none is dropped automatically):";
+var FOOTER = 'Revive: `pnpm josh stash:pop "<message>"` \xB7 Discard: `git stash drop <selector>` \u2014 re-read the selector first, the stack is shared by every lane.';
+var UNKNOWN_OWNER = "owner unknown";
+var COLUMN_SEPARATOR = "  ";
+var LINE_SEPARATOR = "\n";
+function patterns_for(subject) {
+  if (subject.includes(run_preflight.STASH_LABEL_PREFIX)) return NO_PATTERNS;
+  return subject.startsWith(WIP_PREFIX) ? [BRANCH_PATTERN] : [...MESSAGE_PATTERNS, BRANCH_PATTERN];
+}
+function issue_of(subject) {
+  for (const pattern of patterns_for(subject)) {
+    const issue = pattern.exec(subject)?.groups?.["issue"];
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function issues_of(entries) {
+  const issues = entries.map((entry) => issue_of(entry.subject));
+  return [...new Set(issues.filter((issue) => issue !== void 0))];
+}
+function message_issues(subject) {
+  const hashed = [...subject.matchAll(ALL_ISSUE_PATTERN)].map((match) => match.groups?.["issue"]);
+  return [...hashed, LEADING_PATTERN.exec(subject)?.groups?.["issue"]];
+}
+function issues_named(subject) {
+  const branch = BRANCH_PATTERN.exec(subject)?.groups?.["issue"];
+  const named = subject.startsWith(WIP_PREFIX) ? [] : message_issues(subject);
+  const found = [...named, branch].filter((issue) => issue !== void 0);
+  return [...new Set(found)];
+}
+function orphans(entries, closed) {
+  return entries.map((entry) => ({ ...entry, issue: issue_of(entry.subject) })).filter((entry) => entry.issue === void 0 || closed.has(entry.issue));
+}
+function format_line(orphan) {
+  const owner = orphan.issue === void 0 ? UNKNOWN_OWNER : `${session_cite.issue(orphan.issue)} closed`;
+  return `  ${[orphan.selector, owner, orphan.subject].join(COLUMN_SEPARATOR)}`;
+}
+function format_report(found) {
+  if (found.length === 0) return void 0;
+  return [HEADER, ...found.map((orphan) => format_line(orphan)), FOOTER].join(LINE_SEPARATOR);
+}
+var stash_orphans = { format_report, issue_of, issues_named, issues_of, orphans };
+
+export {
+  stash_orphans
+};

package/dist/commands/chunk-WR73HTRG.js

@@ -0,0 +1,121 @@
+import {
+  lane_seed_policy
+} from "./chunk-6NGNMIMT.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-limit-override.ts
+var STREAM_START = 0;
+async function carry_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
+}
+function live_carry(target) {
+  const read = run_carry.read_carry(target);
+  return read.kind === "carried" ? read.carry : void 0;
+}
+async function current_carry() {
+  const target = await carry_target();
+  return target === void 0 ? void 0 : live_carry(target);
+}
+async function read_override() {
+  const carry = await current_carry();
+  return carry?.lane_limit;
+}
+function is_run_live(carry) {
+  return carry.is_handed_off === true || run_carry.is_owner_live(carry);
+}
+async function read_carried() {
+  const carry = await current_carry();
+  if (carry?.lane_limit !== void 0) return carry.lane_limit;
+  return carry !== void 0 && is_run_live(carry) ? carry.launch_limit : void 0;
+}
+async function update_carry(fields) {
+  const target = await carry_target();
+  const carry = target === void 0 ? void 0 : live_carry(target);
+  if (target === void 0 || carry === void 0) return false;
+  stamp_file.write_stamp(target, { ...carry, ...fields });
+  return true;
+}
+async function write_override(limit) {
+  return await update_carry({ lane_limit: limit });
+}
+async function write_launch(limit) {
+  return await update_carry({ launch_limit: limit });
+}
+async function emit_raise(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.LANE_LIMIT, text);
+}
+function never_raised() {
+  return false;
+}
+async function watch_raise() {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0) return never_raised;
+  const start = run_event_stream.read_from(target, STREAM_START).next_position;
+  return function is_raised() {
+    const { events } = run_event_stream.read_from(target, start);
+    return events.some((event) => event.kind === run_event_stream.EVENT_KIND.LANE_LIMIT);
+  };
+}
+var lane_limit_override = {
+  emit_raise,
+  read_carried,
+  read_override,
+  watch_raise,
+  write_launch,
+  write_override
+};
+
+// scripts/lane/lane-capacity.ts
+var DEFAULT_LANE_LIMIT = 4;
+var LANE_LIMIT_KEY = "JOSH_LANE_LIMIT";
+var NO_LANES = 0;
+function read_limit(raw, name) {
+  return cli_flags.read_positive_setting(raw, name, DEFAULT_LANE_LIMIT);
+}
+function environment_limit(environment = process.env) {
+  return read_limit(environment[LANE_LIMIT_KEY], LANE_LIMIT_KEY);
+}
+async function lane_limit(environment = process.env, read_carried2 = lane_limit_override.read_carried) {
+  const carried = await read_carried2();
+  if (carried !== void 0) return { kind: "limit", limit: carried };
+  return environment_limit(environment);
+}
+function seated_limit(limit) {
+  return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT);
+}
+function limit_room(limit, occupied) {
+  return Math.max(NO_LANES, seated_limit(limit) - occupied);
+}
+function free_lanes(limit, occupied, seated = occupied) {
+  const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated;
+  return Math.max(NO_LANES, Math.min(limit_room(limit, occupied), by_seats));
+}
+var lane_capacity = {
+  LANE_LIMIT_KEY,
+  environment_limit,
+  free_lanes,
+  lane_limit,
+  limit_room,
+  read_limit,
+  seated_limit
+};
+
+export {
+  lane_limit_override,
+  lane_capacity
+};

package/dist/commands/chunk-WRNMUQTD.js

@@ -0,0 +1,95 @@
+import {
+  stash_args
+} from "./chunk-R7IT5VOL.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/git/stash/stash-pop-cli.ts
+var COMMAND = "stash:pop";
+var POPPED_VERDICT = "popped";
+var CONFLICTED_VERDICT = "conflicted";
+var NO_MATCH_VERDICT = "no-match";
+var AMBIGUOUS_VERDICT = "ambiguous";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function report(verdict, detail, code) {
+  console.info(verdict);
+  console.error(detail);
+  return code;
+}
+function refuse() {
+  console.error(stash_args.usage(COMMAND));
+  return FAILURE_EXIT_CODE;
+}
+async function pop_selected(selector, directory) {
+  try {
+    await git_stash.pop(selector, directory);
+  } catch (error) {
+    if (await git_stash.has_conflict(directory)) {
+      const detail = `Popped ${selector} with conflicts \u2014 resolve them.`;
+      return report(CONFLICTED_VERDICT, detail, SUCCESS_EXIT_CODE);
+    }
+    throw error;
+  }
+  return report(POPPED_VERDICT, `Popped ${selector}.`, SUCCESS_EXIT_CODE);
+}
+var HASH_ARGUMENT = /^[\da-f]{7,40}$/u;
+async function ambiguous(request) {
+  const entries = await git_stash.list_by_hash(request.dir);
+  const hashes = entries.filter((entry) => git_stash.matches(entry.subject, request.message));
+  const named = hashes.map((entry) => entry.selector).join(", ");
+  const detail = `More than one stash matches "${request.message}" \u2014 pop one by its hash: ${named}.`;
+  return report(AMBIGUOUS_VERDICT, detail, FAILURE_EXIT_CODE);
+}
+async function position_of_hash(hash, directory) {
+  const entries = await git_stash.list_by_hash(directory);
+  const [only, ...rest] = entries.filter((entry) => entry.selector.startsWith(hash));
+  if (only === void 0 || rest.length > 0) return void 0;
+  return await git_stash.position_of(only.selector, directory);
+}
+async function pop_hash(hash, directory) {
+  const position = await position_of_hash(hash, directory);
+  if (position === void 0) {
+    return report(NO_MATCH_VERDICT, `No single stash has the hash ${hash}.`, FAILURE_EXIT_CODE);
+  }
+  return await pop_selected(position, directory);
+}
+async function answer(request) {
+  if (HASH_ARGUMENT.test(request.message)) return await pop_hash(request.message, request.dir);
+  const selection = git_stash.select(await git_stash.list(request.dir), request.message);
+  if (selection.kind === "none") {
+    return report(NO_MATCH_VERDICT, `No stash matches "${request.message}".`, FAILURE_EXIT_CODE);
+  }
+  if (selection.kind === "ambiguous") return await ambiguous(request);
+  return await pop_selected(selection.selector, request.dir);
+}
+function report_unknown(error) {
+  console.error(error_text.message_of(error));
+  return FAILURE_EXIT_CODE;
+}
+async function run(argv) {
+  const parsed = stash_args.read_arguments(argv);
+  if (parsed === void 0) return refuse();
+  const request = stash_args.to_request(parsed);
+  if (request === void 0) return refuse();
+  try {
+    return await answer(request);
+  } catch (error) {
+    return report_unknown(error);
+  }
+}
+var stash_pop_cli = {
+  AMBIGUOUS_VERDICT,
+  CONFLICTED_VERDICT,
+  NO_MATCH_VERDICT,
+  POPPED_VERDICT,
+  run
+};
+
+export {
+  stash_pop_cli
+};

package/dist/commands/chunk-WROJTXWZ.js

@@ -0,0 +1,138 @@
+import {
+  LEDGER_EXCLUSION_PATHSPEC
+} from "./chunk-SV4FZR24.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/stash/git-stash.ts
+var ENTRY_SEPARATOR = "\n";
+var FIELD_SEPARATOR = "\0";
+var LIST_FORMAT = "--format=%gd%x00%gs";
+var SUBJECT_MESSAGE_SEPARATOR = ": ";
+var HASH_FORMAT = "--format=%H%x00%gs";
+var HASH_POSITION_FORMAT = "--format=%H%x00%gd";
+var NAME_ONLY_FLAG = "--name-only";
+var ADDED_PREFIX = "+";
+var FILE_HEADER_PREFIX = "+++";
+function to_entry(line) {
+  const [selector, subject] = line.split(FIELD_SEPARATOR);
+  if (selector === void 0 || subject === void 0) return void 0;
+  return { selector, subject };
+}
+function parse_entries(raw) {
+  if (raw === "") return [];
+  return raw.split(ENTRY_SEPARATOR).map((line) => to_entry(line)).filter((entry) => entry !== void 0);
+}
+function matches(subject, message) {
+  return subject === message || subject.endsWith(`${SUBJECT_MESSAGE_SEPARATOR}${message}`);
+}
+function select(entries, message) {
+  const found = entries.filter((entry) => matches(entry.subject, message));
+  const [first] = found;
+  if (first === void 0) return { kind: "none" };
+  if (found.length > 1) {
+    return { kind: "ambiguous", selectors: found.map((entry) => entry.selector) };
+  }
+  return { kind: "match", selector: first.selector };
+}
+function git_args(directory, args) {
+  return directory === void 0 ? args : ["-C", directory, ...args];
+}
+async function list(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", LIST_FORMAT])));
+}
+async function pop(selector, directory) {
+  await git_spawn.read(git_args(directory, ["stash", "pop", selector]));
+}
+async function unmerged_paths(directory) {
+  const unmerged = await git_spawn.read(
+    git_args(directory, ["diff", NAME_ONLY_FLAG, "--diff-filter=U"])
+  );
+  return unmerged.split("\n").filter((line) => line !== "");
+}
+async function has_conflict(directory) {
+  const unmerged = await unmerged_paths(directory);
+  return unmerged.length > 0;
+}
+async function status_of(directory, pathspec = []) {
+  return await git_spawn.read(git_args(directory, ["status", "--porcelain", ...pathspec]));
+}
+async function has_changes(directory, pathspec = []) {
+  const status = await status_of(directory, pathspec);
+  return status !== "";
+}
+var DELETION_STATUS = " D ";
+function holds_work(status) {
+  return status.split(ENTRY_SEPARATOR).some((line) => line !== "" && !line.startsWith(DELETION_STATUS));
+}
+async function has_work(directory) {
+  return holds_work(await status_of(directory));
+}
+var STASHABLE_PATHSPEC = ["--", ...LEDGER_EXCLUSION_PATHSPEC];
+async function has_stashable_changes(directory) {
+  return await has_changes(directory, STASHABLE_PATHSPEC);
+}
+async function push(message, directory, pathspec = []) {
+  await git_spawn.read(git_args(directory, ["stash", "push", "-u", "-m", message, ...pathspec]));
+}
+async function list_by_hash(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", HASH_FORMAT])));
+}
+async function changed_paths(hash, directory) {
+  const raw = await git_spawn.read(
+    git_args(directory, ["stash", "show", "--include-untracked", NAME_ONLY_FLAG, hash])
+  );
+  return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+}
+async function untracked_lines(hash, file, directory) {
+  try {
+    const raw = await git_spawn.read(git_args(directory, ["show", `${hash}^3:${file}`]));
+    return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+  } catch {
+    return [];
+  }
+}
+async function added_lines(hash, file, directory) {
+  const diff = await git_spawn.read(git_args(directory, ["diff", `${hash}^1`, hash, "--", file]));
+  if (diff === "") return await untracked_lines(hash, file, directory);
+  return diff.split(ENTRY_SEPARATOR).filter((line) => line.startsWith(ADDED_PREFIX) && !line.startsWith(FILE_HEADER_PREFIX)).map((line) => line.slice(ADDED_PREFIX.length));
+}
+async function position_of(hash, directory) {
+  const raw = await git_spawn.read(git_args(directory, ["stash", "list", HASH_POSITION_FORMAT]));
+  return parse_entries(raw).find((candidate) => candidate.selector === hash)?.subject;
+}
+async function drop_by_hash(hash, directory) {
+  const position = await position_of(hash, directory);
+  if (position === void 0) return false;
+  await git_spawn.read(git_args(directory, ["stash", "drop", position]));
+  return true;
+}
+function work_message(issue, occasion) {
+  return `${issue}: uncommitted work at ${occasion}`;
+}
+var git_stash = {
+  added_lines,
+  changed_paths,
+  drop_by_hash,
+  has_changes,
+  has_conflict,
+  has_stashable_changes,
+  has_work,
+  holds_work,
+  list,
+  list_by_hash,
+  matches,
+  parse_entries,
+  pop,
+  position_of,
+  push,
+  select,
+  STASHABLE_PATHSPEC,
+  unmerged_paths,
+  work_message
+};
+
+export {
+  git_stash
+};