@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-OZZWRJQI.js

@@ -1,246 +0,0 @@
-import {
-  run_record_path
-} from "./chunk-WL5JHB3I.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  atomic_write
-} from "./chunk-KSR23NYN.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/test/test-read-map.ts
-import { readdirSync, readFileSync, rmSync, statSync } from "node:fs";
-import path2 from "node:path";
-
-// scripts/test/test-read-trace.ts
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-var RECORD_DIRECTORY_KEY = "JOSH_TEST_READS_DIRECTORY";
-var ROOT_KEY = "JOSH_TEST_READS_ROOT";
-var FILE_URL_PREFIX = "file://";
-var NODE_MODULES = "node_modules";
-var GIT_DIRECTORY = ".git";
-var ROOT_ENTRY = ".";
-var LISTING_READS = /* @__PURE__ */ new Set([
-  "readdir",
-  "readdirSync",
-  "opendir",
-  "opendirSync"
-]);
-var KIND_SUFFIX = { listing: "*", walk: "**" };
-function is_recursive(options) {
-  return typeof options === "object" && options !== null && Reflect.get(options, "recursive") === true;
-}
-function read_kind(name, options) {
-  if (!LISTING_READS.has(name)) return "path";
-  return is_recursive(options) ? "walk" : "listing";
-}
-function read_key(relative, kind) {
-  return kind === "path" ? relative : path.join(relative, KIND_SUFFIX[kind]);
-}
-function script_path(script_name) {
-  if (script_name.startsWith(FILE_URL_PREFIX)) return fileURLToPath(script_name);
-  return path.isAbsolute(script_name) ? script_name : void 0;
-}
-function is_outside(relative) {
-  return relative.startsWith("..") || path.isAbsolute(relative);
-}
-function is_ignored(relative) {
-  const segments = relative.split(path.sep);
-  return segments.includes(NODE_MODULES) || segments[0] === GIT_DIRECTORY;
-}
-function repository_path(root, file_path) {
-  const relative = path.relative(root, file_path);
-  if (relative === "") return ROOT_ENTRY;
-  return is_outside(relative) || is_ignored(relative) ? void 0 : relative;
-}
-function read_target(argument, cwd) {
-  if (typeof argument === "string") return path.resolve(cwd, argument);
-  if (argument instanceof URL) return fileURLToPath(argument);
-  return void 0;
-}
-function frame_reader(query, frame) {
-  const file_path = script_path(frame.script_name);
-  if (file_path === void 0 || file_path === query.recorder) return void 0;
-  const relative = repository_path(query.root, file_path);
-  return relative === ROOT_ENTRY ? void 0 : relative;
-}
-function stack_reader(query) {
-  const outermost = query.frames.findLast((frame) => frame_reader(query, frame) !== void 0);
-  if (outermost?.function_name !== "") return void 0;
-  return frame_reader(query, outermost);
-}
-function add_reader(records, read_path, reader) {
-  const readers = records.get(read_path) ?? /* @__PURE__ */ new Set();
-  readers.add(reader);
-  records.set(read_path, readers);
-}
-function to_records(records) {
-  return Object.fromEntries([...records].map(([read_path, readers]) => [read_path, [...readers]]));
-}
-var test_read_trace = {
-  RECORD_DIRECTORY_KEY,
-  ROOT_ENTRY,
-  ROOT_KEY,
-  add_reader,
-  read_key,
-  read_kind,
-  read_target,
-  repository_path,
-  script_path,
-  stack_reader,
-  to_records
-};
-
-// scripts/test/test-read-map.ts
-var MAP_VERSION = 8;
-var MAP_FILE_STEM = "test-read-map";
-var RECORD_EXTENSION = ".json";
-var STALE_AFTER_MS = 6048e5;
-function record_pairs(record) {
-  return Object.entries(record).flatMap(
-    ([read_path, readers]) => readers.map((reader) => [read_path, reader])
-  );
-}
-function merge_records(records) {
-  const merged = /* @__PURE__ */ new Map();
-  const pairs = records.flatMap((record) => record_pairs(record));
-  for (const [read_path, reader] of pairs) {
-    test_read_trace.add_reader(merged, read_path, reader);
-  }
-  return test_read_trace.to_records(merged);
-}
-function is_object(value) {
-  return typeof value === "object" && value !== null;
-}
-function is_string_array(value) {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-function is_read_records(value) {
-  return is_object(value) && Object.values(value).every(is_string_array);
-}
-function is_digest_record(value) {
-  if (!is_object(value) || Array.isArray(value)) return false;
-  return Object.values(value).every((digest) => typeof digest === "string");
-}
-var FIELD_CHECKS = [
-  ["version", (field) => field === MAP_VERSION],
-  ["commit", (field) => typeof field === "string"],
-  ["dirty", is_digest_record],
-  ["change", is_string_array],
-  ["directories", is_string_array],
-  ["readers", is_read_records]
-];
-function is_read_map(value) {
-  if (!is_object(value)) return false;
-  return FIELD_CHECKS.every(([field, is_valid]) => is_valid(Reflect.get(value, field)));
-}
-function changed_since_tree(map, since, current) {
-  const fresh = since.filter((file) => !Object.hasOwn(map.dirty, file));
-  const moved = Object.entries(map.dirty).filter(([file, digest]) => current[file] !== digest).map(([file]) => file);
-  return [.../* @__PURE__ */ new Set([...fresh, ...moved])];
-}
-function parse_map(text) {
-  const value = json_value.parse_or_undefined(text);
-  return is_read_map(value) ? value : void 0;
-}
-function parse_records(text) {
-  const value = json_value.parse_or_undefined(text);
-  return is_read_records(value) ? value : {};
-}
-function directories_above(relative) {
-  const parent = path2.dirname(relative);
-  if (parent === relative) return [];
-  return [parent, ...directories_above(parent)];
-}
-function created_directories(directories, recorded) {
-  return directories.filter(
-    (directory) => directory !== test_read_trace.ROOT_ENTRY && !recorded.has(directory)
-  );
-}
-function lookup_keys(relative, recorded) {
-  if (run_record_path.is_run_record(relative)) return [relative];
-  const directories = directories_above(relative);
-  const created = created_directories(directories, recorded);
-  const listed = [
-    directories[0] ?? test_read_trace.ROOT_ENTRY,
-    ...created.map((directory) => path2.dirname(directory))
-  ];
-  return [
-    relative,
-    ...created,
-    ...listed.map((directory) => test_read_trace.read_key(directory, "listing")),
-    ...directories.map((directory) => test_read_trace.read_key(directory, "walk"))
-  ];
-}
-function readers_of(map, relative) {
-  const keys = lookup_keys(relative, new Set(map.directories));
-  return [...new Set(keys.flatMap((key) => map.readers[key] ?? []))];
-}
-function in_unread_directory(map, relative) {
-  if (run_record_path.is_run_record(relative)) return true;
-  const directory = path2.dirname(relative);
-  const change = new Set(map.change);
-  const keys = Object.keys(map.readers).filter((key) => !change.has(key));
-  return keys.every((key) => path2.dirname(key) !== directory);
-}
-function map_path(root, version = MAP_VERSION) {
-  const common = git_common_directory.repository(root);
-  const name = `${MAP_FILE_STEM}.v${String(version)}${RECORD_EXTENSION}`;
-  return common === void 0 ? void 0 : path2.join(common, git_common_directory.STATE_DIRECTORY, name);
-}
-function is_map_file(name) {
-  return name.startsWith(MAP_FILE_STEM) && name.endsWith(RECORD_EXTENSION);
-}
-function is_stale(file_path, now) {
-  const modified = statSync(file_path, { throwIfNoEntry: false })?.mtimeMs ?? now;
-  return now - modified > STALE_AFTER_MS;
-}
-function prune_stale_maps(directory) {
-  const now = Date.now();
-  const maps = readdirSync(directory).filter((name) => is_map_file(name)).map((name) => path2.join(directory, name));
-  for (const file_path of maps) {
-    if (is_stale(file_path, now)) rmSync(file_path, { force: true });
-  }
-}
-function read_text(file_path) {
-  try {
-    return readFileSync(file_path, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-function read_map(root) {
-  const file_path = map_path(root);
-  const text = file_path === void 0 ? void 0 : read_text(file_path);
-  return text === void 0 ? void 0 : parse_map(text);
-}
-function write_map(root, map) {
-  const file_path = map_path(root, map.version);
-  if (file_path === void 0) return;
-  atomic_write.replace_file(file_path, JSON.stringify(map));
-  prune_stale_maps(path2.dirname(file_path));
-}
-function collect_records(directory) {
-  return readdirSync(directory).filter((name) => name.endsWith(RECORD_EXTENSION)).map((name) => parse_records(read_text(path2.join(directory, name)) ?? ""));
-}
-var test_read_map = {
-  MAP_VERSION,
-  changed_since_tree,
-  collect_records,
-  in_unread_directory,
-  map_path,
-  merge_records,
-  parse_map,
-  read_map,
-  readers_of,
-  write_map
-};
-
-export {
-  test_read_trace,
-  test_read_map
-};

package/dist/commands/chunk-P3H3DKTE.js

@@ -1,69 +0,0 @@
-import {
-  moved_paths
-} from "./chunk-RUIBQMOV.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  verification_inputs
-} from "./chunk-34KZDKQJ.js";
-
-// scripts/gate/since-green.ts
-var SINCE_GREEN = "since its last green run on this checkout";
-var UNMOVED_REASON = `nothing moved ${SINCE_GREEN}`;
-function describe(label, moved) {
-  return `${label}: reading only the ${String(moved.length)} file(s) changed ${SINCE_GREEN}.`;
-}
-function is_narrowed(out) {
-  return out.includes(SINCE_GREEN);
-}
-var FALLBACK = {
-  NO_RECORD: "no-record",
-  INPUT_MISMATCH: "input-mismatch",
-  NO_BASE: "no-base",
-  CONFIG_FILE: "config-file",
-  AFTER_RED: "after-red",
-  NO_READ_MAP: "no-read-map",
-  HUB: "hub"
-};
-var FALLBACK_MARK = "whole branch \u2014 since-green fell back:";
-var FALLBACK_PATTERN = new RegExp(`${FALLBACK_MARK} ([a-z-]+)`, "u");
-function fallback_line(label, reason) {
-  return `${label}: ${FALLBACK_MARK} ${reason}.`;
-}
-function fallbacks_of(out) {
-  const reasons = out.split("\n").map((line) => FALLBACK_PATTERN.exec(line)?.[1]);
-  return [...new Set(reasons.filter((reason) => reason !== void 0))];
-}
-function narrowed_verdict(label, parts) {
-  if (parts === void 0) return { fallback: FALLBACK.NO_BASE };
-  if (verification_inputs.configures(label, moved_paths.union_of(parts))) {
-    return { fallback: FALLBACK.CONFIG_FILE };
-  }
-  return { parts };
-}
-async function read_verdict(stamp, label, source, tree) {
-  const record = stamp.read(source);
-  if (record === void 0) return { fallback: FALLBACK.NO_RECORD };
-  if (!stamp.describes_inputs(record)) return { fallback: FALLBACK.INPUT_MISMATCH };
-  const parts = await moved_paths.moved_parts(record, tree ?? await gate_tree.read_gate_tree());
-  return narrowed_verdict(label, parts);
-}
-async function read_moved_parts(stamp, label, source, tree) {
-  const verdict = await read_verdict(stamp, label, source, tree);
-  return "parts" in verdict ? verdict.parts : void 0;
-}
-var since_green = {
-  FALLBACK,
-  UNMOVED_REASON,
-  describe,
-  fallback_line,
-  fallbacks_of,
-  is_narrowed,
-  read_moved_parts,
-  read_verdict
-};
-
-export {
-  since_green
-};

package/dist/commands/chunk-P4D5RESF.js

@@ -1,88 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/git/main-merge-guard.ts
-var STATUS_CODE_LENGTH = 2;
-var STATUS_PREFIX_LENGTH = STATUS_CODE_LENGTH + 1;
-var RENAME_SEPARATOR = " -> ";
-var UNMERGED_CODES = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
-var UNSTAGED_INDEX_CODES = /* @__PURE__ */ new Set([" ", "?", "!"]);
-var DIRECTORY_SUFFIX = "/";
-var COMMIT_COMMAND = "`pnpm josh git -y`";
-var LANE_COMMIT_COMMAND = '`pnpm josh git -y --skip-push --skip-pr "<title> #<N>"`';
-var PROCEDURE_POINTER = '`.claude/skills/workflow-commands/chain-rule.md` \u2192 "origin/main is merged in before the gate"';
-var MERGE_RERUN = "`pnpm josh main:merge`";
-function status_lines(status) {
-  return status.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH);
-}
-function line_paths(line) {
-  return line.slice(STATUS_PREFIX_LENGTH).split(RENAME_SEPARATOR);
-}
-function unmerged_paths(status) {
-  return status_lines(status).filter((line) => UNMERGED_CODES.has(line.slice(0, STATUS_CODE_LENGTH))).flatMap((line) => line_paths(line));
-}
-function staged_paths(status) {
-  return status_lines(status).filter((line) => !UNSTAGED_INDEX_CODES.has(line.charAt(0))).flatMap((line) => line_paths(line));
-}
-function covers(uncommitted, incoming) {
-  if (uncommitted.endsWith(DIRECTORY_SUFFIX)) return incoming.startsWith(uncommitted);
-  return uncommitted === incoming;
-}
-function overlapping_paths(status, incoming) {
-  const uncommitted = status_lines(status).flatMap((line) => line_paths(line));
-  return uncommitted.filter((path) => incoming.some((changed) => covers(path, changed)));
-}
-function commit_command(is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
-  return is_lane_child ? LANE_COMMIT_COMMAND : COMMIT_COMMAND;
-}
-function unresolved_message(prefix, paths, rerun, commit = commit_command()) {
-  return `${prefix}: the index still holds unresolved paths (${paths.join(", ")}). Remove the conflict markers, then finish through ${commit} \u2014 it stages and commits them, so no \`git add\` permission is needed, and inside a lane this is Tier A. Rerun ${rerun} after it (${PROCEDURE_POINTER}).`;
-}
-function staged_message(paths, commit) {
-  return `main:merge: the index holds staged changes (${paths.join(", ")}), which git refuses to merge over. Commit them first through ${commit}, then rerun \`pnpm josh main:merge\` (${PROCEDURE_POINTER}).`;
-}
-function overlap_message(default_branch, paths, commit) {
-  return `main:merge: uncommitted changes touch files origin/${default_branch} also changed (${paths.join(", ")}). Commit the work first through ${commit}, then rerun \`pnpm josh main:merge\`. Never stash around the merge \u2014 a stash reapplied over it leaves the conflict half-recorded in the index (${PROCEDURE_POINTER}).`;
-}
-function conflict_hint(commit = commit_command()) {
-  return `main:merge: finish a conflicted merge by removing the conflict markers, then ${commit} records the merge commit \u2014 no \`git add\` permission is needed (${PROCEDURE_POINTER}).`;
-}
-function merge_refusal(status, incoming, default_branch, commit) {
-  if (incoming.length === 0) return void 0;
-  const staged = staged_paths(status);
-  if (staged.length > 0) return staged_message(staged, commit);
-  const overlap = overlapping_paths(status, incoming);
-  return overlap.length > 0 ? overlap_message(default_branch, overlap, commit) : void 0;
-}
-function refusal(status, incoming, default_branch, commit = commit_command()) {
-  const unmerged = unmerged_paths(status);
-  if (unmerged.length > 0) return unresolved_message("main:merge", unmerged, MERGE_RERUN, commit);
-  return merge_refusal(status, incoming, default_branch, commit);
-}
-async function incoming_paths(default_branch) {
-  const output = await git_spawn.read([
-    "diff",
-    "--name-only",
-    "--no-renames",
-    `HEAD...origin/${default_branch}`
-  ]);
-  return output.split("\n").filter((line) => line !== "");
-}
-var main_merge_guard = {
-  commit_command,
-  conflict_hint,
-  incoming_paths,
-  overlapping_paths,
-  refusal,
-  staged_paths,
-  unmerged_paths,
-  unresolved_message
-};
-
-export {
-  main_merge_guard
-};

package/dist/commands/chunk-P4KIQRSL.js

@@ -1,119 +0,0 @@
-import {
-  process_owner_schema
-} from "./chunk-HLUS2M3D.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/git/repository-lock.ts
-import { randomUUID } from "node:crypto";
-import { linkSync, renameSync, rmSync } from "node:fs";
-var POLL_INTERVAL_MS = 200;
-var SYNC_POLL_INTERVAL_MS = 10;
-var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
-function lock_path(prefix, cwd) {
-  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
-}
-function parse_owner(raw) {
-  if (raw === void 0) return void 0;
-  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
-  return parsed.success ? parsed.data : void 0;
-}
-function read_owner(target) {
-  return parse_owner(stamp_file.read_stamp_text(target));
-}
-function is_owner_gone(owner) {
-  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
-}
-function restore(aside, target) {
-  try {
-    linkSync(aside, target);
-  } catch {
-  }
-}
-function stale_record(target, is_gone) {
-  const raw = stamp_file.read_stamp_text(target);
-  const owner = parse_owner(raw);
-  return owner !== void 0 && is_gone(owner) ? raw : void 0;
-}
-function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID()}`;
-  try {
-    renameSync(target, aside);
-    return aside;
-  } catch {
-    return void 0;
-  }
-}
-function clear_stale(target, is_gone = is_owner_gone) {
-  const raw = stale_record(target, is_gone);
-  if (raw === void 0) return;
-  const aside = move_aside(target);
-  if (aside === void 0) return;
-  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
-  rmSync(aside, { force: true });
-}
-function claim(target) {
-  clear_stale(target);
-  return stamp_file.create_stamp(target, process_identity.own_fields());
-}
-function release(target) {
-  const owner = read_owner(target);
-  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
-    stamp_file.remove_stamp(target);
-  }
-}
-async function acquire(target, max_wait_ms) {
-  const deadline = Date.now() + max_wait_ms;
-  return await poll.wait_for(
-    () => {
-      if (claim(target)) return true;
-      return Date.now() >= deadline ? false : void 0;
-    },
-    { interval_ms: POLL_INTERVAL_MS }
-  );
-}
-function sleep_sync(ms) {
-  Atomics.wait(SLEEP_CELL, 0, 0, ms);
-}
-function acquire_sync(target, max_wait_ms) {
-  const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
-    if (Date.now() >= deadline) return false;
-    sleep_sync(SYNC_POLL_INTERVAL_MS);
-  }
-  return true;
-}
-async function with_lock(work, target, max_wait_ms) {
-  if (!await acquire(target, max_wait_ms)) return void 0;
-  try {
-    return await work();
-  } finally {
-    release(target);
-  }
-}
-function with_lock_sync(work, target, max_wait_ms) {
-  if (!acquire_sync(target, max_wait_ms)) return void 0;
-  try {
-    return work();
-  } finally {
-    release(target);
-  }
-}
-var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
-
-export {
-  repository_lock
-};

package/dist/commands/chunk-P5SOYWH2.js

@@ -1,37 +0,0 @@
-import {
-  run_retrospective
-} from "./chunk-QOSC5RKD.js";
-import {
-  doctor_consumer
-} from "./chunk-KGE4AS2Y.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-
-// scripts/backlog/backlog-drive-retrospective.ts
-var STOP_VERDICT = "stop";
-var EXHAUSTED_ANSWER = "exhausted";
-var RETROSPECTIVE_REASON = "retrospective";
-function is_owed(carry) {
-  const root = find_package_directory(process.cwd());
-  return run_retrospective.is_owed({
-    is_retrospective_enabled: run_retrospective.is_enabled(),
-    is_lane_child: false,
-    is_retrospective_done: carry.retrospective === true,
-    is_consumer: doctor_consumer.is_kit_consumer(root)
-  });
-}
-function is_drain_owed(read, state, verdict) {
-  return read.verdict === verdict && read.answer === EXHAUSTED_ANSWER && state.in_flight.length === 0 && read.is_retrospective_owed === true;
-}
-async function ran(result, read, ports) {
-  if (result.kind === "end" || !is_drain_owed(read, result.state, STOP_VERDICT)) return result;
-  if (await ports.retrospective()) return result;
-  const end = { reason: RETROSPECTIVE_REASON, token: RETROSPECTIVE_REASON, issue: void 0 };
-  return { kind: "end", end, state: result.state };
-}
-var backlog_drive_retrospective = { is_drain_owed, is_owed, ran };
-
-export {
-  backlog_drive_retrospective
-};

package/dist/commands/chunk-P7FPXAHP.js

@@ -1,29 +0,0 @@
-// scripts/version/upgrade-shell-command.ts
-var STEP_SEPARATOR = " && ";
-function update_scope_flag(is_local) {
-  return is_local ? "-D" : "-g";
-}
-function update_argv(latest, is_local, config) {
-  return ["pnpm", "add", update_scope_flag(is_local), `${config.package_name}@${latest}`];
-}
-function format_update_command(latest, is_local, config) {
-  return update_argv(latest, is_local, config).join(" ");
-}
-function build_upgrade_command(latest, is_local, config) {
-  const steps = [update_argv(latest, is_local, config)];
-  if (is_local) steps.push(["node_modules/.bin/tsx", config.fix_gh_packages_path]);
-  return { text: steps.map((step) => step.join(" ")).join(STEP_SEPARATOR), steps };
-}
-function shell_upgrade_command(command) {
-  return { text: command, steps: [["sh", "-c", command]] };
-}
-function build_upgrade_shell_command(latest, is_local, config) {
-  return build_upgrade_command(latest, is_local, config).text;
-}
-
-export {
-  format_update_command,
-  build_upgrade_command,
-  shell_upgrade_command,
-  build_upgrade_shell_command
-};

package/dist/commands/chunk-PE7B7242.js

@@ -1,84 +0,0 @@
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-
-// scripts/run/ship/run-ship-lap.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-import { z } from "zod";
-var ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
-var PARENT_SEPARATOR = " \u203A ";
-var STARTUP_STEP = "startup";
-var lap_scope_schema = z.object({
-  issue: z.number(),
-  stage: z.string(),
-  parent: z.string().optional()
-});
-var STEP = {
-  PRECONDITIONS: "preconditions",
-  SCOPED_PAIR: "scoped pair",
-  GATE: "josh gate",
-  OVERLAP_WAIT: "overlap wait",
-  LOCAL_COMMIT: "local commit",
-  MERGE: "merge",
-  PUSH: "push",
-  COMMIT: "josh git"
-};
-var scope = new AsyncLocalStorage();
-async function to_ledger(lap) {
-  await lane_ledger_write.record_ship_lap(lap);
-}
-async function within(issue, stage, run, parent) {
-  return await scope.run({ issue: Number(issue), stage, parent }, run);
-}
-function inherited() {
-  const text = process.env[ENVIRONMENT_KEY];
-  if (text === void 0 || text === "") return void 0;
-  try {
-    return lap_scope_schema.safeParse(JSON.parse(text)).data;
-  } catch {
-    return void 0;
-  }
-}
-function current_scope() {
-  return scope.getStore() ?? inherited();
-}
-function environment(parent) {
-  const current = current_scope();
-  if (current === void 0) return {};
-  return {
-    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
-  };
-}
-function lap_of(current, step, started_ms, note) {
-  const { parent, ...place } = current;
-  const name = parent === void 0 ? step : `${parent}${PARENT_SEPARATOR}${step}`;
-  return { ...place, step: name, elapsed_ms: performance.now() - started_ms, ...note };
-}
-function no_note() {
-  return {};
-}
-var startup = { recorded: false };
-async function record_startup(current, sink, is_wanted) {
-  if (!is_wanted || startup.recorded || scope.getStore() !== void 0) return;
-  startup.recorded = true;
-  await sink(lap_of(current, STARTUP_STEP, 0, {}));
-}
-async function timed(step, run, { sink = to_ledger, note_of = no_note, startup: with_startup } = {}) {
-  const current = current_scope();
-  if (current === void 0) return await run();
-  await record_startup(current, sink, with_startup !== false);
-  const started_ms = performance.now();
-  const noted = { note: {} };
-  try {
-    const result = await run();
-    noted.note = note_of(result);
-    return result;
-  } finally {
-    await sink(lap_of(current, step, started_ms, noted.note));
-  }
-}
-var run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
-
-export {
-  run_ship_lap
-};