@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-YSLGWRQN.js

@@ -1,646 +0,0 @@
-import {
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-import {
-  CHECK_STATUS_FAIL,
-  CHECK_STATUS_PASS,
-  CHECK_STATUS_PENDING,
-  PrConflictError,
-  is_coderabbit_check,
-  is_coderabbit_rate_limited
-} from "./chunk-WVR4RUFP.js";
-import {
-  josh_verdict
-} from "./chunk-JTU5A4JI.js";
-import {
-  status_icons
-} from "./chunk-65E4OZJ7.js";
-import {
-  time_format
-} from "./chunk-JNV3VRK2.js";
-import {
-  transcript_record
-} from "./chunk-O3NDWYNT.js";
-import {
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  time_instant
-} from "./chunk-DDZVMXZD.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/time-runtime/time-phase-names.ts
-var GATE_PHASE = "gate";
-var PR_PHASE = "pr";
-var MERGE_PHASE = "merge";
-var GATE_COMMAND = "josh gate";
-var COMMAND_PHASES = /* @__PURE__ */ new Map([
-  [GATE_COMMAND, GATE_PHASE],
-  ["josh git", PR_PHASE],
-  ["josh pr", PR_PHASE],
-  ["josh followup", MERGE_PHASE]
-]);
-
-// scripts/time-runtime/time-background.ts
-var NO_BACKGROUND = "";
-var NO_FINISH = 0;
-var LAUNCH_PATTERN = /(?:running in background with ID:|moved to the background \(ID:)\s*([\w-]+)/iu;
-var AGENT_LAUNCH_PATTERN = /^(?:Async agent launched[\s\S]*?\bagentId:\s*|\{"success":[^\n]*?"resumedAgentId":")([\w-]+)/u;
-var FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/u;
-var STOP_PATTERN = /^\{"message":"Successfully stopped task:\s*([\w-]+)/u;
-var OUTPUT_PATTERN = /tasks\/([\w-]+)\.output/u;
-var BASH_ID_KEY = "bash_id";
-function read_id(command) {
-  return OUTPUT_PATTERN.exec(time_shell.unquoted(command))?.[1] ?? NO_BACKGROUND;
-}
-function read_id_of(input) {
-  if (!json_value.is_record(input)) return NO_BACKGROUND;
-  const id = input[BASH_ID_KEY];
-  return typeof id === "string" ? id : read_id(time_shell.bash_command(input));
-}
-function launch_id(text) {
-  return LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function agent_launch_id(text) {
-  return AGENT_LAUNCH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function finished_id(text) {
-  return FINISH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function stopped_id(text) {
-  return STOP_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND;
-}
-function finished_at(lines) {
-  const notices = lines.filter((one) => one.finished_background !== NO_BACKGROUND).toSorted((left, right) => right.timestamp_ms - left.timestamp_ms);
-  return new Map(notices.map((one) => [one.finished_background, one.timestamp_ms]));
-}
-function started_ms(span) {
-  return span.ended_ms - span.duration_ms;
-}
-function read_end_ms(spans, run) {
-  if (run.background_ended_ms === NO_FINISH) return void 0;
-  const found = spans.find(
-    (span) => span.reads_background === run.background_id && span.ended_ms >= run.background_ended_ms
-  );
-  return found?.ended_ms;
-}
-function to_run(spans, launch) {
-  const read = read_end_ms(spans, launch);
-  return {
-    id: launch.background_id,
-    josh_command: launch.josh_command,
-    started_ms: started_ms(launch),
-    ended_ms: read ?? launch.ended_ms,
-    is_read: read !== void 0
-  };
-}
-function is_launch(span) {
-  return span.background_id !== NO_BACKGROUND;
-}
-function runs(spans) {
-  return spans.filter((span) => is_launch(span)).map((launch) => to_run(spans, launch));
-}
-function is_within(span, run) {
-  const start = started_ms(span);
-  return start >= run.started_ms && start < run.ended_ms;
-}
-function latest_first(all2) {
-  return all2.filter((run) => run.is_read).toSorted((left, right) => right.started_ms - left.started_ms);
-}
-function own_run(span, all2) {
-  return is_launch(span) ? all2.find((run) => run.id === span.background_id) : void 0;
-}
-function placed(span, all2, ordered) {
-  const own = own_run(span, all2);
-  const run = own ?? ordered.find((one) => is_within(span, one));
-  if (run === void 0) return span;
-  const beside = { ...span, background_command: run.josh_command };
-  return own === void 0 ? beside : { ...beside, own_duration_ms: own.ended_ms - own.started_ms };
-}
-function positioned(spans) {
-  const all2 = runs(spans);
-  if (all2.length === 0) return [...spans];
-  const ordered = latest_first(all2);
-  return spans.map((span) => placed(span, all2, ordered));
-}
-function unread_phases(spans) {
-  const names = runs(spans).filter((run) => !run.is_read).map((run) => COMMAND_PHASES.get(run.josh_command));
-  return new Set(names.filter((phase) => phase !== void 0));
-}
-var time_background = {
-  NO_BACKGROUND,
-  NO_FINISH,
-  launch_id,
-  agent_launch_id,
-  finished_id,
-  stopped_id,
-  finished_at,
-  read_id,
-  read_id_of,
-  runs,
-  positioned,
-  unread_phases
-};
-
-// scripts/followup/followup-ci-path.ts
-function new_path() {
-  return { pending: /* @__PURE__ */ new Set(), settled: /* @__PURE__ */ new Set(), check_ms: {} };
-}
-function settle(path, name, elapsed_ms) {
-  if (path.pending.delete(name)) path.check_ms[name] = elapsed_ms;
-  path.settled.add(name);
-}
-function hold(path, name) {
-  if (path.settled.has(name)) path.has_rerun = true;
-  path.pending.add(name);
-}
-function observe(path, snapshot, now_ms) {
-  path.start_ms ??= now_ms;
-  const elapsed_ms = now_ms - path.start_ms;
-  const checks = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  const pending = new Set(
-    checks.filter((check) => check.status === CHECK_STATUS_PENDING).map((check) => check.name)
-  );
-  for (const name of pending) hold(path, name);
-  for (const check of checks) if (!pending.has(check.name)) settle(path, check.name, elapsed_ms);
-}
-function observer_of(path) {
-  const is_first_wait = path.start_ms === void 0;
-  return async function time_checks(snapshot) {
-    if (is_first_wait) observe(path, snapshot, performance.now());
-  };
-}
-function record_of(path) {
-  const [last] = Object.entries(path.check_ms).toSorted((left, right) => right[1] - left[1]);
-  if (last === void 0) return {};
-  return {
-    last_check: last[0],
-    check_ms: { ...path.check_ms },
-    ...path.has_rerun && { has_rerun: path.has_rerun }
-  };
-}
-var followup_ci_path = { new_path, observe, observer_of, record_of };
-
-// scripts/run/event/run-event-checks.ts
-var CODERABBIT_STATES = ["running", "done", "rate-limited", "failed", "none"];
-var CHECKS_PATTERN = /^#\d+ PR (?<pr>\d+) pass (?<pass>\d+) pending (?<pending>\d+) fail (?<fail>\d+) coderabbit (?<coderabbit>\S+)$/u;
-function text_of(issue, checks) {
-  const { pr, pass, pending, fail, coderabbit } = checks;
-  return `${issue_cite.plain_for("program", issue)} PR ${String(pr)} pass ${String(pass)} pending ${String(pending)} fail ${String(fail)} coderabbit ${coderabbit}`;
-}
-var STATE_NAMES = new Set(CODERABBIT_STATES);
-function is_coderabbit_state(value = "") {
-  return STATE_NAMES.has(value);
-}
-function checks_of(text) {
-  const groups = CHECKS_PATTERN.exec(text)?.groups;
-  const coderabbit = groups?.["coderabbit"];
-  if (groups === void 0 || !is_coderabbit_state(coderabbit)) return void 0;
-  return {
-    pr: Number(groups["pr"]),
-    pass: Number(groups["pass"]),
-    pending: Number(groups["pending"]),
-    fail: Number(groups["fail"]),
-    coderabbit
-  };
-}
-var run_event_checks = { checks_of, text_of };
-
-// scripts/followup/followup-checks-event.ts
-var PR_NUMBER_PATTERN = /\/pull\/(?<number>\d+)/u;
-var { PR_CHECKS } = run_event_stream.EVENT_KIND;
-function count_of(checks, status) {
-  return checks.filter((check) => check.status === status).length;
-}
-function coderabbit_state_of(check) {
-  if (check === void 0) return "none";
-  if (check.status === CHECK_STATUS_PENDING) return "running";
-  if (check.status !== CHECK_STATUS_PASS) return "failed";
-  return is_coderabbit_rate_limited(check) ? "rate-limited" : "done";
-}
-function coderabbit_of(snapshot) {
-  return coderabbit_state_of(snapshot.rollup.find((check) => is_coderabbit_check(check.name)));
-}
-function summary_of(snapshot, pr) {
-  const ci = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  return {
-    pr,
-    pass: count_of(ci, CHECK_STATUS_PASS),
-    pending: count_of(ci, CHECK_STATUS_PENDING),
-    fail: count_of(ci, CHECK_STATUS_FAIL),
-    coderabbit: coderabbit_of(snapshot)
-  };
-}
-function pr_number_of(pr_url = "") {
-  const number = PR_NUMBER_PATTERN.exec(pr_url)?.groups?.["number"];
-  return number === void 0 ? void 0 : Number(number);
-}
-async function skip_snapshot() {
-}
-function observer_of2(issue, pr_url) {
-  const pr = pr_number_of(pr_url);
-  if (issue === void 0 || pr === void 0) return skip_snapshot;
-  let last_text = "";
-  return async function report_snapshot(snapshot) {
-    const text = run_event_checks.text_of(issue, summary_of(snapshot, pr));
-    if (text === last_text) return;
-    last_text = text;
-    await run_event_stream_emit.emit(PR_CHECKS, text);
-  };
-}
-var followup_checks_event = { coderabbit_of, observer_of: observer_of2, summary_of };
-
-// scripts/followup/followup-coderabbit-wait.ts
-var NO_TIME = 0;
-var RATE_LIMITED = "rate-limited";
-var WAITING_STATES = /* @__PURE__ */ new Set(["running", RATE_LIMITED]);
-function new_wait() {
-  return { wait_ms: NO_TIME, rate_limited_ms: NO_TIME };
-}
-function charge(wait, last, now_ms) {
-  const elapsed_ms = now_ms - last.at_ms;
-  if (WAITING_STATES.has(last.state)) wait.wait_ms += elapsed_ms;
-  if (last.state === RATE_LIMITED) wait.rate_limited_ms += elapsed_ms;
-}
-function observe2(wait, snapshot, now_ms) {
-  if (wait.last !== void 0) charge(wait, wait.last, now_ms);
-  wait.last = { state: followup_checks_event.coderabbit_of(snapshot), at_ms: now_ms };
-}
-function observer_of3(wait) {
-  delete wait.last;
-  return async function time_snapshot(snapshot) {
-    observe2(wait, snapshot, performance.now());
-  };
-}
-function all(...observers) {
-  return async function observe_all(snapshot) {
-    await Promise.all(
-      observers.map(async (observer) => {
-        await observer(snapshot);
-      })
-    );
-  };
-}
-async function record_part(stage, elapsed_ms) {
-  if (elapsed_ms > NO_TIME) await lane_ledger_write.record_stage({ stage, elapsed_ms });
-}
-async function record(wait) {
-  await record_part(lane_ledger_write.CODERABBIT_WAIT_STAGE, wait.wait_ms);
-  await record_part(lane_ledger_write.CODERABBIT_RATE_LIMIT_STAGE, wait.rate_limited_ms);
-}
-var followup_coderabbit_wait = { all, new_wait, observe: observe2, observer_of: observer_of3, record };
-
-// scripts/followup/git-followup-stages.ts
-var STAGE_LINE_PREFIX = "followup stage: ";
-var STAGE_TOTAL_PREFIX = "followup stages total: ";
-var STAGE_NAME_WIDTH = 26;
-var VALUE_COLUMN = STAGE_LINE_PREFIX.length + STAGE_NAME_WIDTH;
-var NO_DURATION = 0;
-var STAGE = {
-  closes_and_context: "closes-and-context",
-  checks_wait: "checks-wait",
-  // Only on a run that retriggered a rate-limited CodeRabbit: the window and the review after it
-  // (joshuafolkken/kit#5289), kept out of `checks-wait` so the `ci-wait` row is the checks alone.
-  coderabbit_retrigger: "coderabbit-retrigger",
-  coderabbit_comments: "coderabbit-comments",
-  ai_review_comments: "ai-review-comments",
-  // The interval of a run that merged nothing, where the send has nothing to go beside.
-  telegram: "telegram",
-  telegram_and_merge: "telegram-and-merge",
-  completion_and_epic_close: "completion-and-epic-close",
-  // The completion tail `git-followup-finish.ts` prints after this block (#5131): the next-issue list
-  // and the unreleased-merge count. Printed as its own row there, since the block is already out.
-  completion: "completion",
-  // The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
-  // blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
-  // them would leave the measurement blind to exactly the invocations worth measuring.
-  interrupted: "interrupted",
-  // The interrupted lap when the wait failed on a merge conflict, so the
-  // stage block names the cause a resumed session would otherwise look up with `gh pr view`.
-  conflict: "conflict"
-};
-function stopped_lap(error) {
-  return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted;
-}
-function new_log() {
-  return {
-    stages: [],
-    last_ms: performance.now(),
-    coderabbit: followup_coderabbit_wait.new_wait(),
-    ci_path: followup_ci_path.new_path(),
-    reran: []
-  };
-}
-function hold_issue(log, issue_number) {
-  const issue = Number(issue_number);
-  if (Number.isSafeInteger(issue) && issue > 0) log.issue = issue;
-}
-function lap(log, name) {
-  const now_ms = performance.now();
-  log.stages.push({ name, duration_ms: now_ms - log.last_ms });
-  log.last_ms = now_ms;
-}
-function total_ms(stages) {
-  return stages.reduce((sum, stage) => sum + stage.duration_ms, NO_DURATION);
-}
-function format_stage(stage) {
-  const name = stage.name.padEnd(STAGE_NAME_WIDTH);
-  return `${STAGE_LINE_PREFIX}${name}${time_format.format_seconds(stage.duration_ms)}`;
-}
-function format_stages(log) {
-  if (log.stages.length === 0) return [];
-  const rows = log.stages.map((stage) => format_stage(stage));
-  const total = time_format.format_seconds(total_ms(log.stages));
-  return ["", ...rows, `${STAGE_TOTAL_PREFIX.padEnd(VALUE_COLUMN)}${total}`];
-}
-function print_stages(log) {
-  for (const line of format_stages(log)) console.info(line);
-}
-async function record_ci_wait(log) {
-  const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait);
-  if (wait === void 0) return;
-  await lane_ledger_write.record_stage({
-    stage: lane_ledger_write.CI_WAIT_STAGE,
-    elapsed_ms: wait.duration_ms,
-    ...log.issue !== void 0 && { issue: log.issue },
-    ...followup_ci_path.record_of(log.ci_path)
-  });
-}
-async function record_waits(log) {
-  await record_ci_wait(log);
-  await followup_coderabbit_wait.record(log.coderabbit);
-}
-var git_followup_stages = {
-  STAGE,
-  STAGE_LINE_PREFIX,
-  STAGE_TOTAL_PREFIX,
-  new_log,
-  hold_issue,
-  lap,
-  total_ms,
-  format_stage,
-  format_stages,
-  print_stages,
-  record_waits,
-  stopped_lap
-};
-
-// scripts/time-runtime/time-followup-stage.ts
-var LINE_SEPARATOR = "\n";
-var SECONDS_SUFFIX = " s";
-var DIGIT_OR_POINT = /[\d.]/u;
-var NO_STAGES = [];
-function stage_body(line) {
-  const trimmed = line.trimStart();
-  if (!trimmed.startsWith(git_followup_stages.STAGE_LINE_PREFIX)) return void 0;
-  return trimmed.slice(git_followup_stages.STAGE_LINE_PREFIX.length);
-}
-function digits_start(head) {
-  let index = head.length;
-  while (index > 0 && DIGIT_OR_POINT.test(head.charAt(index - 1))) index -= 1;
-  return index;
-}
-function is_duration(digits) {
-  return digits !== "" && Number.isFinite(Number(digits));
-}
-function to_stage(body) {
-  const text = body.trimEnd();
-  if (!text.endsWith(SECONDS_SUFFIX)) return void 0;
-  const head = text.slice(0, -SECONDS_SUFFIX.length);
-  const start = digits_start(head);
-  const name = head.slice(0, start).trim();
-  const digits = head.slice(start);
-  if (name === "" || !is_duration(digits)) return void 0;
-  return { name, duration_ms: Number(digits) * MS_PER_SECOND };
-}
-function read_stages(text) {
-  if (!text.includes(git_followup_stages.STAGE_LINE_PREFIX)) return NO_STAGES;
-  return text.split(LINE_SEPARATOR).map((line) => stage_body(line)).filter((body) => body !== void 0).map((body) => to_stage(body)).filter((stage) => stage !== void 0);
-}
-var time_followup_stage = { NO_STAGES, read_stages };
-
-// scripts/time-runtime/time-reported-failure.ts
-import { z } from "zod";
-var TEXT_BLOCK_SCHEMA = z.object({ text: z.string().nullish() });
-var CONTENT_SCHEMA = z.union([z.string(), z.array(z.unknown())]);
-var LINE_SEPARATOR2 = "\n";
-function block_text(block) {
-  const parsed = TEXT_BLOCK_SCHEMA.safeParse(block);
-  return parsed.success ? parsed.data.text ?? "" : "";
-}
-function result_text(content) {
-  const parsed = CONTENT_SCHEMA.safeParse(content);
-  if (!parsed.success) return "";
-  if (typeof parsed.data === "string") return parsed.data;
-  return parsed.data.map((block) => block_text(block)).join(LINE_SEPARATOR2);
-}
-function is_failure_line(line) {
-  return line.trimStart().startsWith(status_icons.FAIL_ICON);
-}
-function is_failed_verdict(line) {
-  return josh_verdict.read_verdict(line) === josh_verdict.FAILED_VERDICT;
-}
-var GREEN_VERDICTS = /* @__PURE__ */ new Set([
-  josh_verdict.PASSED_VERDICT,
-  josh_verdict.UNVERIFIED_VERDICT
-]);
-function is_green_verdict(line) {
-  return GREEN_VERDICTS.has(josh_verdict.read_verdict(line));
-}
-function new_scan() {
-  return {
-    did_find: false,
-    has_failure_before_region: false,
-    has_failure_in_region: false,
-    is_region_open: false
-  };
-}
-function close_region(scan) {
-  scan.did_find ||= scan.is_region_open && scan.has_failure_before_region;
-  scan.has_failure_before_region = false;
-  scan.has_failure_in_region = false;
-  scan.is_region_open = false;
-}
-function note_failure(scan) {
-  if (scan.is_region_open) {
-    scan.has_failure_in_region = true;
-    return;
-  }
-  scan.has_failure_before_region = true;
-}
-function scan_line(scan, line) {
-  if (is_green_verdict(line)) {
-    close_region(scan);
-    return;
-  }
-  if (is_failure_line(line)) {
-    note_failure(scan);
-    return;
-  }
-  if (josh_verdict.is_gate_opening(line)) scan.is_region_open = true;
-}
-function scan_body(lines) {
-  const scan = new_scan();
-  for (const line of lines) scan_line(scan, line);
-  return scan;
-}
-function did_scan_find(scan) {
-  return scan.did_find || scan.has_failure_before_region || scan.has_failure_in_region;
-}
-function has_failure_line(content) {
-  const lines = result_text(content).split(LINE_SEPARATOR2);
-  if (lines.some((line) => is_failed_verdict(line))) return true;
-  return did_scan_find(scan_body(lines));
-}
-function is_reported_failure(josh_command, did_print_failure) {
-  return josh_command !== "" && did_print_failure;
-}
-var time_reported_failure = { result_text, has_failure_line, is_reported_failure };
-
-// scripts/time-runtime/time-transcript-block.ts
-var ERROR_TEXT_LIMIT = 256;
-var REFUSAL_MARKER = "\u26D4";
-var HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u;
-var TOKEN_LINE = /^[a-z][a-z-]*$/u;
-var TOKEN_LINE_LIMIT = 8;
-function block_names(raw) {
-  return {
-    type: raw.type ?? "",
-    name: raw.name ?? "",
-    id: raw.id ?? "",
-    result_id: raw.tool_use_id ?? ""
-  };
-}
-function refusal_body(text) {
-  return text.trimStart().replace(HOOK_ERROR_LABEL, "");
-}
-function guard_from_refusal(text) {
-  const trimmed = refusal_body(text);
-  if (!trimmed.startsWith(REFUSAL_MARKER)) return "";
-  const headline = trimmed.slice(REFUSAL_MARKER.length).split("\n", 1)[0]?.trimStart() ?? "";
-  const colon = headline.indexOf(":");
-  return (colon === -1 ? headline : headline.slice(0, colon)).trim();
-}
-function token_lines_of(text) {
-  return text.split("\n").map((line) => line.trim()).filter((line) => TOKEN_LINE.test(line)).slice(0, TOKEN_LINE_LIMIT);
-}
-function to_block(raw) {
-  const text = time_reported_failure.result_text(raw.content);
-  const is_error = raw.is_error ?? void 0;
-  return {
-    ...block_names(raw),
-    input: raw.input,
-    is_error,
-    has_failure_line: time_reported_failure.has_failure_line(text),
-    followup_stages: time_followup_stage.read_stages(text),
-    error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : "",
-    refusal_guard: is_error === true ? guard_from_refusal(text) : "",
-    token_lines: is_error === true ? [] : token_lines_of(text),
-    background_id: time_background.launch_id(text),
-    agent_id: time_background.agent_launch_id(text),
-    result_chars: text.length
-  };
-}
-function to_blocks(content) {
-  return typeof content === "string" || content === null || content === void 0 ? [] : content.map((block) => to_block(block));
-}
-var time_transcript_block = {
-  ERROR_TEXT_LIMIT,
-  TOKEN_LINE_LIMIT,
-  guard_from_refusal,
-  refusal_body,
-  to_blocks
-};
-
-// scripts/time-runtime/time-transcript-line.ts
-var UNKNOWN_BRANCH = "";
-var PROMPT_KEY = "prompt";
-var NO_MESSAGE_ID = "";
-var STOP_FEEDBACK_LABEL = /^Stop hook feedback:\s*/u;
-function stop_feedback_of(data) {
-  const content = data.message?.content;
-  if (typeof content !== "string" || !STOP_FEEDBACK_LABEL.test(content)) return "";
-  return content.replace(STOP_FEEDBACK_LABEL, "").trim();
-}
-function message_fields(message) {
-  return {
-    message_id: message?.id ?? NO_MESSAGE_ID,
-    blocks: time_transcript_block.to_blocks(message?.content)
-  };
-}
-function notice_text(data) {
-  const attachment = json_value.is_record(data.attachment) ? data.attachment[PROMPT_KEY] : void 0;
-  const carried = [data.message?.content, data.content, attachment];
-  return carried.find((one) => typeof one === "string") ?? "";
-}
-function stopped_background(content) {
-  if (!Array.isArray(content)) return time_background.NO_BACKGROUND;
-  const ids = content.map(
-    (block) => typeof block.content === "string" ? time_background.stopped_id(block.content) : ""
-  );
-  return ids.find((id) => id !== time_background.NO_BACKGROUND) ?? time_background.NO_BACKGROUND;
-}
-function finished_background(data) {
-  const notice = time_background.finished_id(notice_text(data));
-  return notice === time_background.NO_BACKGROUND ? stopped_background(data.message?.content) : notice;
-}
-function request_fields(data) {
-  return { request_id: data.requestId ?? "", effort: data.effort ?? "" };
-}
-function to_line(data) {
-  const timestamp_ms = time_instant.parse_instant(data.timestamp);
-  if (timestamp_ms === void 0) return void 0;
-  const stop_feedback = stop_feedback_of(data);
-  return {
-    type: data.type ?? "",
-    timestamp_ms,
-    branch: data.gitBranch ?? UNKNOWN_BRANCH,
-    finished_background: finished_background(data),
-    stop_feedback,
-    stop_guard: time_transcript_block.guard_from_refusal(stop_feedback),
-    ...request_fields(data),
-    ...message_fields(data.message)
-  };
-}
-function parse_line(line) {
-  const record2 = transcript_record.parse(line);
-  return record2 === void 0 ? void 0 : to_line(record2);
-}
-function parse_text(text) {
-  return text.split("\n").flatMap((line) => parse_line(line) ?? []);
-}
-var time_transcript_line = {
-  ERROR_TEXT_LIMIT: time_transcript_block.ERROR_TEXT_LIMIT,
-  NO_MESSAGE_ID,
-  TOKEN_LINE_LIMIT: time_transcript_block.TOKEN_LINE_LIMIT,
-  guard_from_refusal: time_transcript_block.guard_from_refusal,
-  parse_line,
-  parse_text,
-  refusal_body: time_transcript_block.refusal_body
-};
-
-export {
-  time_background,
-  followup_ci_path,
-  run_event_checks,
-  followup_checks_event,
-  followup_coderabbit_wait,
-  git_followup_stages,
-  time_followup_stage,
-  time_reported_failure,
-  time_transcript_line
-};