@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-YSLGWRQN.js

@@ -0,0 +1,646 @@
+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
+};