@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ISNZX75X.js

@@ -0,0 +1,168 @@
+import {
+  report_format_reference
+} from "./chunk-Q6SKKQVJ.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+
+// scripts/review/test-titles.ts
+var BLOCK_FUNCTION = "describe";
+var STEP_FUNCTION = "step";
+var TEST_FUNCTIONS = /* @__PURE__ */ new Set(["it", "test"]);
+var TITLE_SEPARATOR = " > ";
+var VIRTUAL_FILE_NAME = "test-titles.ts";
+function member_name(api, expression) {
+  return api.isPropertyAccessExpression(expression) ? [expression.name.text] : [];
+}
+function callee_chain(api, expression) {
+  if (api.isIdentifier(expression)) return [expression.text];
+  const is_chained = api.isPropertyAccessExpression(expression) || api.isCallExpression(expression);
+  const chain = is_chained ? callee_chain(api, expression.expression) : void 0;
+  return chain === void 0 ? void 0 : [...chain, ...member_name(api, expression)];
+}
+function is_block(chain) {
+  return chain.includes(BLOCK_FUNCTION);
+}
+function is_test(chain) {
+  const [root = ""] = chain;
+  return TEST_FUNCTIONS.has(root) && !is_block(chain) && !chain.includes(STEP_FUNCTION);
+}
+function title_of(walk, call) {
+  const [first] = call.arguments;
+  if (first === void 0) return void 0;
+  if (walk.api.isStringLiteralLike(first)) return first.text;
+  return walk.api.isTemplateExpression(first) ? first.getText(walk.source) : void 0;
+}
+function named_call(walk, node) {
+  if (!walk.api.isCallExpression(node)) return void 0;
+  const chain = callee_chain(walk.api, node.expression);
+  const title = chain === void 0 ? void 0 : title_of(walk, node);
+  return chain === void 0 || title === void 0 ? void 0 : { chain, title };
+}
+function entered(walk, call, prefix) {
+  if (call === void 0) return prefix;
+  const named = [...prefix, call.title];
+  if (is_test(call.chain)) walk.into.push(named.join(TITLE_SEPARATOR));
+  return is_block(call.chain) ? named : prefix;
+}
+function visit(walk, node, prefix) {
+  const inner = entered(walk, named_call(walk, node), prefix);
+  walk.api.forEachChild(node, (child) => {
+    visit(walk, child, inner);
+  });
+}
+function titles_of(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, true);
+  const into = [];
+  visit({ api, source, into }, source, []);
+  return into;
+}
+function leaf_of(full_name) {
+  return full_name.split(TITLE_SEPARATOR).at(-1) ?? full_name;
+}
+var test_titles = { leaf_of, titles_of };
+
+// scripts/review/removed-tests.ts
+var DISPOSITION_HEADING = "## \u6D88\u3048\u305F\u30C6\u30B9\u30C8\u306E\u51E6\u7F6E";
+var HEADING_LINE = new RegExp(String.raw`^${DISPOSITION_HEADING}[ \t]*$`, "mu");
+var REPLACED = "\u7F6E\u304D\u63DB\u3048";
+var RETIRED = "\u5EC3\u6B62";
+var PENDING_SUFFIX = "\u2014 \u672A\u8A18\u5165";
+var BRIEF_HEADING = "Removed tests";
+var ROW_PATTERN = new RegExp(
+  String.raw`^[-*]\s+\x60(?<title>.+?)\x60\s+—\s+(?<kind>${REPLACED}|${RETIRED}):\s*(?<rest>\S.*)$`,
+  "u"
+);
+var RETIREMENT_PATTERN = /^(?:[\w.-]+\/[\w.-]+)?#\d+\s+\S/u;
+var ROW_FORMAT = `under ${DISPOSITION_HEADING}, one line per removed test: \`- \`<test>\` \u2014 ${REPLACED}: <the test that guards the behavior now>\` or \`- \`<test>\` \u2014 ${RETIRED}: #<Issue that retired the behavior> <reason>\``;
+function unique(titles) {
+  return [...new Set(titles)];
+}
+function leaf_counts(titles) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const title of titles) {
+    const leaf = test_titles.leaf_of(title);
+    counts.set(leaf, (counts.get(leaf) ?? 0) + 1);
+  }
+  return counts;
+}
+function is_moved(arrived, title) {
+  const leaf = test_titles.leaf_of(title);
+  const left = arrived.get(leaf) ?? 0;
+  if (left === 0) return false;
+  arrived.set(leaf, left - 1);
+  return true;
+}
+function removed(base, head) {
+  const base_names = new Set(base);
+  const head_names = new Set(head);
+  const arrived = leaf_counts(unique(head).filter((title) => !base_names.has(title)));
+  return unique(base).filter((title) => !head_names.has(title)).filter((title) => !is_moved(arrived, title));
+}
+function is_cited(groups) {
+  return groups["kind"] === REPLACED || RETIREMENT_PATTERN.test(groups["rest"] ?? "");
+}
+function disposed_title(line) {
+  const groups = ROW_PATTERN.exec(line.trim())?.groups;
+  if (groups === void 0 || !is_cited(groups)) return void 0;
+  return groups["title"];
+}
+function undisposed(removed_titles, pr_body = "") {
+  const disposed = new Set(
+    markdown_section.section_lines(pr_body, DISPOSITION_HEADING).map((line) => disposed_title(line))
+  );
+  return removed_titles.filter((title) => !disposed.has(title));
+}
+function pending_rows(titles) {
+  return titles.map((title) => `- \`${title}\` ${PENDING_SUFFIX}`);
+}
+function has_row(lines, title) {
+  return lines.some((line) => line.trim().startsWith(`- \`${title}\` `));
+}
+function with_pending_rows(body, titles) {
+  const lines = markdown_section.section_lines(body, DISPOSITION_HEADING);
+  const rows = pending_rows(titles.filter((title) => !has_row(lines, title))).join("\n");
+  if (rows === "") return body;
+  if (!HEADING_LINE.test(body)) return `${body.trimEnd()}
+
+${DISPOSITION_HEADING}
+
+${rows}
+`;
+  return body.replace(HEADING_LINE, () => `${DISPOSITION_HEADING}
+
+${rows}`);
+}
+function brief_block(removed_titles) {
+  if (removed_titles.length === 0) return [];
+  return [
+    "",
+    `${BRIEF_HEADING} \u2014 these tests existed at the base and are gone from the change. For each, find the test that guards its behavior now, or the Issue that retired the behavior; a removed test with neither is a finding (missing test). The pull request body must dispose of each ${ROW_FORMAT}, or \`josh followup\` refuses the merge:`,
+    ...pending_rows(removed_titles)
+  ];
+}
+function refusal_message(titles) {
+  return [
+    `Merge refused: this change removes ${String(titles.length)} test(s) the pull request body does not account for.`,
+    `Put these rows into the body's ${DISPOSITION_HEADING} section, replacing each ending with the test that replaced it or the Issue that retired its behavior:`,
+    DISPOSITION_HEADING,
+    "",
+    ...pending_rows(titles),
+    `Write ${ROW_FORMAT} \u2014 format: ${report_format_reference.pointer(report_format_reference.REMOVED_TESTS_HEADING)}`,
+    "Write it into the `--body-file` before `josh ship`, or update an open PR with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run."
+  ].join("\n");
+}
+var removed_tests = {
+  brief_block,
+  DISPOSITION_HEADING,
+  refusal_message,
+  removed,
+  ROW_FORMAT,
+  undisposed,
+  with_pending_rows
+};
+
+export {
+  test_titles,
+  removed_tests
+};

package/dist/commands/chunk-ISY5TFYT.js

@@ -0,0 +1,80 @@
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  run_liveness
+} from "./chunk-L7GYJHDX.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-report.ts
+var NO_LANES = "No lanes are open.";
+var OPEN_STATE = "open";
+var STRANDED_STATE = "stranded";
+var UNREADABLE_STATE = "unreadable";
+var UNKNOWN_VALUE = "-";
+var COLUMN_SEPARATOR = "  ";
+function lane_state(lane) {
+  if (lane.is_stranded) return STRANDED_STATE;
+  if (lane.seat_problem !== void 0) return lane.seat_problem;
+  if (lane.seat_held === false) return "seat released";
+  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE;
+}
+function value_or_unknown(value) {
+  return value === void 0 ? UNKNOWN_VALUE : String(value);
+}
+function output_column(output) {
+  return `output ${output ?? UNKNOWN_VALUE}`;
+}
+function profile_column(lane) {
+  return `profile ${lane.profile === void 0 ? UNKNOWN_VALUE : agent_role_profile.describe(lane.profile)}`;
+}
+function event_column(lane) {
+  if (lane.output === void 0) return "agent -";
+  const state = run_liveness.describe_agent_state(lane.output);
+  return state ?? "agent -";
+}
+var PLAIN_CITE = issue_cite.citer(void 0, /* @__PURE__ */ new Map());
+function describe_lane(lane, cite = PLAIN_CITE) {
+  return [
+    cite(lane.issue),
+    `seat ${value_or_unknown(lane.seat)}`,
+    `dev ${value_or_unknown(lane.development_port)}`,
+    `preview ${value_or_unknown(lane.preview_port)}`,
+    lane.branch,
+    lane_state(lane),
+    lane.directory,
+    output_column(lane.output),
+    profile_column(lane),
+    event_column(lane)
+  ].join(COLUMN_SEPARATOR);
+}
+function describe_lanes(lanes, cite = PLAIN_CITE) {
+  if (lanes.length === 0) return NO_LANES;
+  return lanes.map((lane) => describe_lane(lane, cite)).join("\n");
+}
+function describe_ports(lane) {
+  if (lane.seat === void 0) return "no lane seat could be read";
+  return `seat ${String(lane.seat)}, dev ${value_or_unknown(lane.development_port)}, preview ${value_or_unknown(lane.preview_port)}`;
+}
+function describe_opened(lane) {
+  return `Opened a lane for ${session_cite.issue(lane.issue)} on ${lane.branch}: ${describe_ports(lane)}.`;
+}
+var lane_report = {
+  NO_LANES,
+  OPEN_STATE,
+  STRANDED_STATE,
+  UNREADABLE_STATE,
+  describe_lane,
+  describe_lanes,
+  describe_opened,
+  lane_state
+};
+
+export {
+  lane_report
+};

package/dist/commands/chunk-IT2O5MOW.js

@@ -0,0 +1,37 @@
+import {
+  lane_plan_check
+} from "./chunk-YJMOFRL7.js";
+import {
+  plan_consumers_section
+} from "./chunk-SB3R6E3R.js";
+import {
+  backlog_overlap
+} from "./chunk-JUQN3OXG.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+
+// scripts/lane/lane-plan-auto.ts
+var SUCCESS_EXIT_CODE = 0;
+var PATH_PLACEHOLDER = "<path>...";
+var IMPORTS_HINT = "Append `--imports <path>...` naming the existing modules the new code imports \u2014 lane:plan probes their main guards before the first edit.";
+function command_of(issue_number, paths) {
+  const named = paths.length === 0 ? PATH_PLACEHOLDER : paths.map((path) => shell_quote.word(path)).join(" ");
+  return `pnpm josh lane:plan ${issue_number} ${named}`;
+}
+function paths_of(plan) {
+  return [...backlog_overlap.declared_paths(plan_consumers_section.without(plan))];
+}
+async function run_from_plan(issue_number, plan, directory = process.cwd()) {
+  const paths = paths_of(plan);
+  const lane = lane_plan_check.plan_of([issue_number, ...paths], /* @__PURE__ */ new Date());
+  console.info(command_of(issue_number, paths));
+  console.info(IMPORTS_HINT);
+  if (lane === void 0) return SUCCESS_EXIT_CODE;
+  return await lane_plan_check.check_plan(lane_plan_check.placed(lane, directory), directory);
+}
+var lane_plan_auto = { IMPORTS_HINT, command_of, paths_of, run_from_plan };
+
+export {
+  lane_plan_auto
+};

package/dist/commands/chunk-IV6ETHVB.js

@@ -0,0 +1,155 @@
+import {
+  agent_diagnostics,
+  claude_agent_argv
+} from "./chunk-CHQQ3VTL.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  agent_worker_profile
+} from "./chunk-LL6G34MF.js";
+import {
+  agent_phase_profile,
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+
+// scripts/agent/agent-ship-cap.ts
+function has_phase_model(profile, phase) {
+  return agent_phase_profile.phase_model(profile.role, profile.provider, phase, {}) !== void 0;
+}
+function weaker(profile, resolved) {
+  const { worker, settings } = resolved;
+  const rank = settings.profiles.findIndex((entry) => entry.agent.model === profile.model);
+  const limit = settings.profiles.findIndex((entry) => entry.name === worker.name);
+  return rank <= limit ? profile : { ...profile, model: worker.agent.model };
+}
+function capped_by(profile, result) {
+  if (result.kind === "unset") return { kind: "profile", profile };
+  return result.kind === "rejected" ? result : { kind: "profile", profile: weaker(profile, result) };
+}
+async function capped(resolved, phase, worker) {
+  if (resolved.kind === "rejected" || !has_phase_model(resolved.profile, phase)) return resolved;
+  return capped_by(resolved.profile, await worker());
+}
+var agent_ship_cap = { capped };
+
+// scripts/agent/codex-agent-argv.ts
+import path from "node:path";
+var AGENT_COMMAND = "codex";
+var AGENT_FLAGS = ["exec"];
+var MODEL_FLAG = "--model";
+var CONFIG_FLAG = "-c";
+var JSON_FLAG = "--json";
+var SQLITE_CACHE_PATH = ["node_modules", ".cache", "josh", "openai"];
+var EPHEMERAL_FLAG = "--ephemeral";
+var PERMISSION_ARGUMENTS = [
+  CONFIG_FLAG,
+  'default_permissions=":danger-full-access"',
+  CONFIG_FLAG,
+  'approval_policy="never"'
+];
+function effort_config(profile) {
+  return `model_reasoning_effort="${profile.effort}"`;
+}
+function role_config(profile) {
+  return `shell_environment_policy.set.${agent_session_role.KEY}=${JSON.stringify(profile.role)}`;
+}
+function sqlite_config(cwd) {
+  return `sqlite_home=${JSON.stringify(path.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
+}
+function persistence_arguments(profile) {
+  return profile.role === agent_profile_schema.WORKER ? [] : [EPHEMERAL_FLAG];
+}
+function lane_arguments(cwd, profile) {
+  if (cwd === void 0) return [];
+  return [CONFIG_FLAG, sqlite_config(cwd), ...persistence_arguments(profile)];
+}
+function build(invocation, profile, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      MODEL_FLAG,
+      profile.model,
+      CONFIG_FLAG,
+      effort_config(profile),
+      CONFIG_FLAG,
+      role_config(profile),
+      ...PERMISSION_ARGUMENTS,
+      ...lane_arguments(cwd, profile),
+      JSON_FLAG,
+      invocation
+    ],
+    ends_with_prompt: true
+  };
+}
+var codex_agent_argv = { build };
+
+// scripts/agent/agent-argv.ts
+function build2(invocation, profile, cwd, session_id) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build(invocation, profile, session_id, cwd);
+}
+function build_resume(invocation, profile, session_id, cwd) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build_resume(invocation, profile, session_id, cwd);
+}
+function with_profile_in(invocation, profile, cwd, session_id) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build2(invocation, profile, cwd, session_id), profile };
+}
+function with_resume_in(invocation, profile, session_id, cwd) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build_resume(invocation, profile, session_id, cwd), profile };
+}
+function with_profile(invocation, profile) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build2(invocation, profile), profile };
+}
+function resolve(invocation, role, environment = process.env) {
+  const resolved = agent_role_profile.resolve(role, environment);
+  return resolved.kind === "rejected" ? resolved : with_profile(invocation, resolved.profile);
+}
+function profiled_in(invocation, resolved, cwd) {
+  return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
+}
+async function resume_argv(invocation, profile, phase, site) {
+  const resolved = profile === void 0 ? agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase) : agent_role_profile.with_phase(profile, phase);
+  const capped2 = await agent_ship_cap.capped(
+    resolved,
+    phase,
+    async () => await agent_worker_profile.resolve(site.cwd, site.labels)
+  );
+  return profiled_in(invocation, capped2, site.cwd);
+}
+function resolve_in(invocation, role, cwd, environment = process.env) {
+  return profiled_in(invocation, agent_role_profile.resolve(role, environment), cwd);
+}
+function review_in(invocation, round, cwd, environment = process.env) {
+  const is_reduced = review_prompt_level.level_of(invocation) === "low";
+  return profiled_in(
+    invocation,
+    agent_role_profile.resolve_review(round, environment, is_reduced),
+    cwd
+  );
+}
+var agent_argv = {
+  resolve,
+  resolve_in,
+  review_in,
+  resume_argv,
+  with_profile,
+  with_profile_in,
+  with_resume_in
+};
+
+export {
+  agent_argv
+};

package/dist/commands/chunk-IZPMBGAI.js

@@ -0,0 +1,202 @@
+import {
+  inherited_scope
+} from "./chunk-5OF2B4BF.js";
+import {
+  lane_ledger_kind,
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/startup/run-startup.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// scripts/run/startup/run-startup-schema.ts
+import { z } from "zod";
+var scope_schema = z.object({
+  run: z.string(),
+  attempt: z.string(),
+  issue: z.string().optional(),
+  span: z.string().optional(),
+  parent: z.string().optional(),
+  destination: z.string().optional()
+});
+var entry_schema = scope_schema.omit({ destination: true }).extend({
+  kind: z.literal(lane_ledger_kind.KIND.STARTUP),
+  at: z.string(),
+  at_ms: z.number().nonnegative().optional(),
+  id: z.string(),
+  parent: z.string().optional(),
+  phase: z.string(),
+  edge: z.enum(["start", "done", "failed", "waiting", "api", "cache"]),
+  elapsed_ms: z.number().nonnegative().optional(),
+  metric: z.string().optional(),
+  key: z.string().optional()
+});
+var run_startup_schema = { scope_schema, entry_schema };
+
+// scripts/run/startup/run-startup-store.ts
+import { randomUUID } from "node:crypto";
+async function carried_identity(issue) {
+  const repository = await run_carry.repository_directory();
+  if (repository === void 0) return void 0;
+  const read = run_carry.read_carry(run_carry.carry_path(repository));
+  if (read.kind !== "carried") return void 0;
+  return {
+    run: `${repository}:${read.carry.started_at}`,
+    attempt: randomUUID(),
+    destination: lane_ledger_write.target_of(repository),
+    ...issue !== void 0 && { issue }
+  };
+}
+async function identity(issue) {
+  try {
+    if (process.env["VITEST"] !== void 0) return void 0;
+    return await carried_identity(issue);
+  } catch {
+    return void 0;
+  }
+}
+async function record(entry2, destination) {
+  await lane_ledger_write.record(entry2, destination);
+}
+function counts(rows, edge) {
+  const result = {};
+  for (const row of rows) {
+    if (row.edge !== edge) continue;
+    const key = row.metric ?? "unknown";
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+function is_terminal(row) {
+  return row.edge === "done" || row.edge === "failed" || row.edge === "waiting";
+}
+function summary(start, rows) {
+  const ending = rows.find(is_terminal);
+  return {
+    start,
+    status: ending?.edge ?? "incomplete",
+    elapsed_ms: ending?.elapsed_ms,
+    api: counts(rows, "api"),
+    cache: counts(rows, "cache")
+  };
+}
+function by_span(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of entries) {
+    const group = groups.get(row.id) ?? [];
+    group.push(row);
+    groups.set(row.id, group);
+  }
+  return groups;
+}
+function summarize(entries) {
+  const groups = by_span(entries);
+  return entries.filter((row) => row.edge === "start").map((start) => summary(start, groups.get(start.id) ?? []));
+}
+function timestamp(row) {
+  return row.at_ms ?? Date.parse(row.at);
+}
+function before_end(row, other, endings) {
+  const end = endings.get(other.id);
+  return end !== void 0 && timestamp(row) < end;
+}
+function overlaps(left, right, endings) {
+  if (left.id === right.id || left.key !== right.key) return false;
+  return before_end(left, right, endings) && before_end(right, left, endings);
+}
+function concurrent_misses(entries) {
+  const fills = entries.filter((row) => row.edge === "cache" && row.metric === "fill");
+  const endings = new Map(entries.filter(is_terminal).map((row) => [row.id, timestamp(row)]));
+  return fills.filter((row) => fills.some((other) => overlaps(row, other, endings)));
+}
+var run_startup_store = { identity, record, summarize, concurrent_misses };
+
+// scripts/run/startup/run-startup.ts
+var ENVIRONMENT_KEY = "JOSH_STARTUP_SCOPE";
+var scope = inherited_scope.create(ENVIRONMENT_KEY, run_startup_schema.scope_schema);
+async function record2(row) {
+  try {
+    await run_startup_store.record(row, scope.current()?.destination);
+  } catch {
+  }
+}
+function entry(current, name, edge) {
+  return run_startup_schema.entry_schema.parse({
+    ...current,
+    kind: lane_ledger_kind.KIND.STARTUP,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    at_ms: performance.timeOrigin + performance.now(),
+    id: current.span ?? randomUUID2(),
+    phase: name,
+    edge
+  });
+}
+async function completed(name, run, options) {
+  const current = scope.current();
+  if (current === void 0) return await run();
+  const started = performance.now();
+  await record2(entry(current, name, "start"));
+  const ending = { edge: "failed" };
+  try {
+    const value = await run();
+    ending.edge = options.edge_of?.(value) ?? "done";
+    return value;
+  } finally {
+    await record2({ ...entry(current, name, ending.edge), elapsed_ms: performance.now() - started });
+  }
+}
+async function current_scope(options) {
+  return scope.current() ?? (options.root === true ? await run_startup_store.identity(options.issue) : void 0);
+}
+async function phase(name, run, options = {}) {
+  const current = await current_scope(options);
+  if (current === void 0) return await run();
+  const next = {
+    ...current,
+    parent: current.span,
+    span: randomUUID2(),
+    ...options.issue !== void 0 && { issue: options.issue }
+  };
+  return await scope.within(next, async () => await completed(name, run, options));
+}
+function metric(edge, name, key) {
+  const current = scope.current();
+  if (current === void 0) return;
+  void record2({
+    ...entry(current, "", edge),
+    metric: name,
+    ...key !== void 0 && { key: stamp_file.digest(key) }
+  });
+}
+async function waiting(name) {
+  const current = scope.current();
+  const started = performance.now();
+  const place = { ...current, span: randomUUID2(), parent: current?.span };
+  if (current !== void 0) await record2(entry({ ...current, ...place }, name, "start"));
+  return async () => {
+    if (current === void 0) return;
+    await record2({
+      ...entry({ ...current, ...place }, name, "waiting"),
+      elapsed_ms: performance.now() - started
+    });
+  };
+}
+var run_startup = {
+  ENVIRONMENT_KEY,
+  phase,
+  metric,
+  waiting,
+  environment: scope.environment,
+  within: scope.within
+};
+
+export {
+  run_startup_schema,
+  run_startup
+};