@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-S23MUFND.js

@@ -0,0 +1,122 @@
+import {
+  run_handoff_args
+} from "./chunk-7CX5VYOL.js";
+import {
+  backlogrun_launch
+} from "./chunk-3IXIYDC3.js";
+import {
+  session_model_record
+} from "./chunk-Q3HM2BEH.js";
+import {
+  consultation_handoff
+} from "./chunk-CXVNQ7DS.js";
+import {
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/session-handoff-line.ts
+import { z } from "zod";
+var LINE_PREFIX = "Consultation model: hand";
+var { BACKLOG_KEYWORD } = run_handoff_args;
+var BRIEF_ARGUMENT = " --brief-file <brief>";
+var payload_schema = z.object({
+  prompt: z.string().nullish(),
+  transcript_path: z.string().nullish(),
+  model: z.string().nullish()
+});
+var KEYWORD_SET = new Set(run_handoff_args.KEYWORDS);
+function keyword_of(prompt) {
+  return prompt.toLowerCase().split(/[^a-z]+/u).find((token) => KEYWORD_SET.has(token));
+}
+function tail_of(transcript_path) {
+  if (transcript_path === void 0 || transcript_path === null) return "";
+  try {
+    return transcript_tail.read_tail(transcript_path);
+  } catch {
+    return "";
+  }
+}
+function line_for(keyword) {
+  const brief = keyword === BACKLOG_KEYWORD ? "" : BRIEF_ARGUMENT;
+  return `${LINE_PREFIX} \`${keyword}\` to a child: \`pnpm josh run:handoff ${keyword} \u2026${brief}\`, not \`run:entry\` (${consultation_handoff.HANDOFF_DOC}).`;
+}
+function line_of(payload) {
+  const keyword = keyword_of(payload.prompt ?? "");
+  if (keyword === void 0) return "";
+  const tail = tail_of(payload.transcript_path);
+  const model = payload.model ?? void 0;
+  const recorded = session_model_record.recorded(payload.transcript_path);
+  return consultation_handoff.is_consultation_main(tail, model, recorded) ? line_for(keyword) : "";
+}
+function handoff_line(raw_payload) {
+  if (lane_child_marker.is_child_of(process.cwd())) return "";
+  const payload = json_value.parse_with(raw_payload, payload_schema);
+  return payload === void 0 ? "" : line_of(payload);
+}
+var session_handoff_line = {
+  LINE_PREFIX,
+  handoff_line,
+  read_stdin: session_model_record.read_stdin
+};
+
+// scripts/josh/session-language-cli.ts
+var { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang } = session_language;
+var BOARD_LINE = "Live backlogrun: for progress-only questions, run `pnpm josh run:board --chat`; relay output verbatim in one code block. For cause or improvement questions, investigate state, logs and code; cite evidence and uncertainty, even with quoted board lines. For mixed questions, do both.";
+var LIVE_PORTS = {
+  repository_directory: run_carry.repository_directory,
+  is_running: backlogrun_launch.is_running
+};
+function format_line(resolution) {
+  if (resolution.is_default) return "";
+  return `Session language (${ENV_KEY}): ${resolution.lang}`;
+}
+async function is_run_live(ports = LIVE_PORTS) {
+  try {
+    const git_directory = await ports.repository_directory();
+    return git_directory !== void 0 && ports.is_running(git_directory);
+  } catch {
+    return false;
+  }
+}
+function prompt_lines(resolution, is_live, handoff = "") {
+  return [
+    agent_session_role.scope_line(),
+    format_line(resolution),
+    is_live ? BOARD_LINE : "",
+    handoff
+  ].filter((line) => line !== "");
+}
+async function print_prompt_lines(read_payload = session_handoff_line.read_stdin) {
+  const handoff = session_handoff_line.handoff_line(await read_payload());
+  const lines = prompt_lines(resolve_session_lang(), await is_run_live(), handoff);
+  for (const line of lines) console.info(line);
+}
+var session_language_cli = {
+  BOARD_LINE,
+  DEFAULT_SESSION_LANG,
+  ENV_KEY,
+  format_line,
+  is_run_live,
+  print_prompt_lines,
+  prompt_lines,
+  resolve_session_lang
+};
+
+export {
+  session_language_cli
+};

package/dist/commands/chunk-S3DRNZRT.js

@@ -0,0 +1,74 @@
+import {
+  issue_outcome
+} from "./chunk-F546BPG3.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-comment-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var BODY_FLAG = "--body";
+var BODY_FILE_FLAG = "--body-file";
+var USAGE = `Usage: josh issue:comment <issue-number> ${BODY_FLAG} <text> | ${BODY_FILE_FLAG} <path>`;
+var OPTIONS = {
+  body: { type: "string" },
+  "body-file": { type: "string" },
+  outcome: { type: "string" },
+  "evidence-url": { type: "string" }
+};
+function parse_request(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue_number = issue_number_shape.single_of(parsed.positionals);
+  if (issue_number === void 0) return void 0;
+  const body = cli_body.resolve({
+    inline: parsed.values.body,
+    file_path: parsed.values["body-file"],
+    inline_flag: BODY_FLAG,
+    file_flag: BODY_FILE_FLAG
+  });
+  if (body === void 0 || body.length === 0) return void 0;
+  return {
+    issue_number,
+    body: issue_outcome.body_of({
+      body,
+      summary: parsed.values.outcome,
+      url: parsed.values["evidence-url"]
+    })
+  };
+}
+function resolve_request(argv, usage = USAGE) {
+  try {
+    const request = parse_request(argv);
+    if (request === void 0) console.error(usage);
+    return request;
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return void 0;
+  }
+}
+async function run(argv) {
+  const request = resolve_request(argv);
+  if (request === void 0) return FAILURE_EXIT_CODE;
+  const url = await git_gh_command.issue_comment(request.issue_number, request.body);
+  console.info(url);
+  return SUCCESS_EXIT_CODE;
+}
+var issue_comment_cli = { USAGE, resolve_request, run };
+
+export {
+  issue_comment_cli
+};

package/dist/commands/chunk-SB3R6E3R.js

@@ -0,0 +1,49 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+
+// scripts/issue/plan-consumers-section.ts
+var HEADING = "### \u5F71\u97FF\u3092\u53D7\u3051\u308B\u65E2\u5B58\u306E\u5229\u7528\u8005";
+var ANY_HEADING = /^#{1,6}\s/u;
+var LIST_MARKER = /^(?:[-*+]|\d+\.)\s+/u;
+var NONE_WORD = "\u306A\u3057";
+var NONE_WITH_REASON = /^なし\s*[（(]\s*\S.*[）)]$/u;
+var MISSING = `The plan has no \`${HEADING}\` section: list, for each state, command, label, file or process it adds or changes, the existing places that read or write it and what this issue does with each (\`pnpm josh plan:consumers <identifier...>\` drafts it), or write \`\u306A\u3057\uFF08<reason>\uFF09\`.`;
+var EMPTY = `The plan's \`${HEADING}\` section is empty: list the existing consumers, or write \`\u306A\u3057\uFF08<reason>\uFF09\`.`;
+var BARE_NONE = `The plan's \`${HEADING}\` section says \`\u306A\u3057\` without a reason: write \`\u306A\u3057\uFF08<reason>\uFF09\`.`;
+function section_entries(plan) {
+  if (!markdown_section.has_line(plan, HEADING)) return void 0;
+  const raw = markdown_section.section_lines(plan, HEADING).join("\n");
+  const lines = markdown_section.fence_free_lines(raw);
+  const end = lines.findIndex((line) => ANY_HEADING.test(line.trim()));
+  const body = end === -1 ? lines : lines.slice(0, end);
+  return body.map((line) => line.trim().replace(LIST_MARKER, "")).filter((line) => line !== "");
+}
+function is_bare_none(entries) {
+  const [first = ""] = entries;
+  if (!first.startsWith(NONE_WORD) || NONE_WITH_REASON.test(first)) return false;
+  return !NONE_WITH_REASON.test(entries.join(" "));
+}
+function refusal_of(plan) {
+  const entries = section_entries(plan);
+  if (entries === void 0) return MISSING;
+  if (entries.length === 0) return EMPTY;
+  return is_bare_none(entries) ? BARE_NONE : void 0;
+}
+function section_range(visible) {
+  const start = visible.findIndex((line) => line.trim() === HEADING);
+  if (start === -1) return void 0;
+  const end = visible.slice(start + 1).findIndex((line) => ANY_HEADING.test(line.trim()));
+  return [start, end === -1 ? visible.length : start + 1 + end];
+}
+function without(plan) {
+  const range = section_range(markdown_section.unfenced_lines(plan));
+  if (range === void 0) return plan;
+  const lines = markdown_section.lines_of(plan);
+  return [...lines.slice(0, range[0]), ...lines.slice(range[1])].join("\n");
+}
+var plan_consumers_section = { HEADING, refusal_of, without };
+
+export {
+  plan_consumers_section
+};

package/dist/commands/chunk-SCCUBRDO.js

@@ -0,0 +1,237 @@
+import {
+  issue_park
+} from "./chunk-NHXMWRBI.js";
+import {
+  run_stalled
+} from "./chunk-IBOCPSPK.js";
+import {
+  agent_worker_profile
+} from "./chunk-LL6G34MF.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  RUN_STALLED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  distributed_paths
+} from "./chunk-3MQTOUXT.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+
+// scripts/run/park/run-stalled-park.ts
+var { PARK } = run_event_stream.EVENT_KIND;
+async function apply(issue, comment, cause, fields = {}) {
+  const park_write = await issue_park.apply(issue, RUN_STALLED_LABEL, comment);
+  if (!park_write.is_labelled) return false;
+  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, cause), /* @__PURE__ */ new Date(), fields);
+  return true;
+}
+var run_stalled_park = { apply };
+
+// scripts/run/park/run-park-escalate.ts
+var ESCALATE_FLAG = "--escalate";
+var OPTIONS = { escalate: { type: "string" } };
+var DISABLED_NOTE = `run:park ${ESCALATE_FLAG}: refused \u2014 this repository's package.json does not set josh.worker.escalate to true.`;
+function is_requested(argv) {
+  return argv.some((token) => token === ESCALATE_FLAG || token.startsWith(`${ESCALATE_FLAG}=`));
+}
+function is_enabled(directory) {
+  const result = agent_worker_profile.read(directory);
+  return result.kind === "settings" && result.settings.escalate;
+}
+function reason_of(value) {
+  return value?.trim() ?? "";
+}
+function escalation_of(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue = issue_number_shape.single_of(parsed.positionals);
+  const reason = reason_of(parsed.values.escalate);
+  return issue === void 0 || reason === "" ? void 0 : { issue, reason };
+}
+function refusal_of(escalation, directory, usage) {
+  if (escalation === void 0) return usage;
+  return is_enabled(directory) ? void 0 : DISABLED_NOTE;
+}
+function accepted(argv, directory, usage) {
+  const escalation = escalation_of(argv);
+  const refusal = refusal_of(escalation, directory, usage);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal === void 0 ? escalation : void 0;
+}
+function comment_of(escalation) {
+  const { issue, reason } = escalation;
+  return [
+    `Parked with \`${RUN_STALLED_LABEL}\`: ${run_stalled.ESCALATION_REQUESTED.why}`,
+    `- Reason: ${reason}`,
+    `- Next: the backlogrun drive resumes it one \`worker:<name>\` profile up, or hands it to a person at the top profile; without a drive, give it a stronger profile, ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+}
+async function park(argv, directory, usage) {
+  const escalation = accepted(argv, directory, usage);
+  if (escalation === void 0) return void 0;
+  const { short } = run_stalled.escalation_requested(escalation.reason);
+  const is_parked = await run_stalled_park.apply(escalation.issue, comment_of(escalation), short);
+  console.info(`escalate ${session_cite.issue(escalation.issue)} \u2014 parked: ${String(is_parked)}`);
+  return is_parked ? escalation.issue : void 0;
+}
+var run_park_escalate = { ESCALATE_FLAG, is_enabled, is_requested, park };
+
+// scripts/agent/lane-instructions.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/cost-runtime/cost-tokens.ts
+var ASCII_CHARS_PER_TOKEN = 3;
+var WIDE_TOKENS_PER_CHAR = 1;
+var ASCII_LIMIT = 128;
+function count_chars(text) {
+  let ascii_chars = 0;
+  let wide_chars = 0;
+  for (const char of text) {
+    if ((char.codePointAt(0) ?? 0) < ASCII_LIMIT) ascii_chars += 1;
+    else wide_chars += 1;
+  }
+  return { ascii_chars, wide_chars };
+}
+function estimate(text) {
+  const { ascii_chars, wide_chars } = count_chars(text);
+  return Math.round(ascii_chars / ASCII_CHARS_PER_TOKEN) + wide_chars * WIDE_TOKENS_PER_CHAR;
+}
+function ascii_bytes_to_tokens(bytes) {
+  return Math.round(bytes / ASCII_CHARS_PER_TOKEN);
+}
+var cost_tokens = {
+  ASCII_CHARS_PER_TOKEN,
+  count_chars,
+  estimate,
+  ascii_bytes_to_tokens
+};
+
+// scripts/agent/lane-instructions.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/agent/lane-instructions.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
+var WORKFLOW_ENTRY = "fullrun-lane.md";
+var WORKFLOW_GUIDE = `A headless fullrun lane child runs pnpm josh doc:read ${WORKFLOW_ENTRY} instead of workflow-commands/SKILL.md, fullrun.md or entry-sequence.md. A resumed child follows its resume prompt first. Review sessions do not start a fullrun.`;
+var RULES_FILE = "CLAUDE.md";
+var POINTER_FILE = "AGENTS.md";
+var INCLUDE_PATTERN = /^<!-- include: CLAUDE\.md → "(?<wanted>.+)" -->$/u;
+var PROMPT_FILE_FLAG = "--append-system-prompt-file";
+var SETTINGS_FLAG = "--settings";
+var PROMPT_FILE_PREFIX = "josh-lane-instructions-";
+var PROMPT_FILE_SUFFIX = ".md";
+var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
+var ESCALATION_GUIDE = [
+  "",
+  "## Escalation",
+  "",
+  '- This Issue needs a stronger model than the one you run on \u2192 `pnpm josh run:park <N> --escalate "<reason>"`, then stop. The reason is required and recorded; the lane resumes one profile up, or goes to a person at the top profile.'
+].join("\n");
+function expand_line(line, rules) {
+  const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
+  if (wanted === void 0) return line;
+  return document_section.section(rules, wanted)?.text;
+}
+function compose(lane_markdown, rules) {
+  const expanded = lane_markdown.split("\n").map((line) => expand_line(line, rules));
+  if (expanded.includes(void 0)) return void 0;
+  return [WORKFLOW_GUIDE, ...expanded].join("\n");
+}
+function rules_sources(cwd) {
+  const imported = distributed_paths.CLAUDE_MD_IMPORT_LINE.replace(/^@/u, "");
+  return [path.join(cwd, RULES_FILE), path.join(cwd, imported)];
+}
+function composed_from(lane_markdown, rules_path) {
+  const rules = document_section.read_optional(rules_path);
+  return rules === void 0 ? void 0 : compose(lane_markdown, rules);
+}
+function rules_set(cwd, package_directory) {
+  const lane_markdown = document_section.read_optional(path.join(package_directory, LANE_DOCUMENT));
+  if (lane_markdown === void 0) return void 0;
+  for (const rules_path of rules_sources(cwd)) {
+    const text = composed_from(lane_markdown, rules_path);
+    if (text !== void 0) return { text, rules_path };
+  }
+  return void 0;
+}
+function composed_set(cwd, package_directory, is_worker = false) {
+  const set = rules_set(cwd, package_directory);
+  if (set === void 0 || !is_worker || !run_park_escalate.is_enabled(cwd)) return set;
+  return { ...set, text: `${set.text}${ESCALATION_GUIDE}` };
+}
+function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
+  return composed_set(cwd, package_directory)?.text;
+}
+function written(text) {
+  const file_path = stamp_file.stamp_path(PROMPT_FILE_PREFIX, text, PROMPT_FILE_SUFFIX);
+  if (stamp_file.read_stamp_text(file_path) === text) return file_path;
+  try {
+    return stamp_file.replace_text_stamp(file_path, text);
+  } catch {
+    return void 0;
+  }
+}
+function excluded_settings(rules_path, cwd) {
+  return JSON.stringify({ claudeMdExcludes: [rules_path, path.join(cwd, POINTER_FILE)] });
+}
+function flags_of(set, cwd) {
+  const prompt_file = set === void 0 ? void 0 : written(set.text);
+  if (set === void 0 || prompt_file === void 0) return [];
+  return [PROMPT_FILE_FLAG, prompt_file, SETTINGS_FLAG, excluded_settings(set.rules_path, cwd)];
+}
+function flags(cwd = process.cwd(), is_worker = false) {
+  return flags_of(composed_set(cwd, PACKAGE_DIRECTORY, is_worker), cwd);
+}
+function tokens_of(text) {
+  return cost_tokens.estimate(text).toLocaleString("en-US");
+}
+function rules_tokens(rules_path) {
+  return tokens_of(document_section.read_optional(rules_path) ?? "");
+}
+function resident_line(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const rules = rules_tokens(set?.rules_path ?? path.join(cwd, RULES_FILE));
+  const lane_tokens = set === void 0 ? "not composed" : `${tokens_of(set.text)} tok`;
+  return `  resident: lane instructions ${lane_tokens} in place of ${RULES_FILE} ${rules} tok`;
+}
+var lane_instructions = {
+  WORKFLOW_ENTRY,
+  PROMPT_FILE_FLAG,
+  SETTINGS_FLAG,
+  compose,
+  composed_in,
+  flags,
+  resident_line
+};
+
+export {
+  cost_tokens,
+  run_stalled_park,
+  run_park_escalate,
+  lane_instructions
+};

package/dist/commands/chunk-SIPHEZXP.js

@@ -0,0 +1,72 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-yield.ts
+var YIELD_REASON = "it gave its lane back to an earlier lane holding one of its planned files";
+var YIELD_MARK = " yielded its lane: ";
+var NAMED_ISSUE = /#([1-9]\d*)\b/gu;
+var YIELD_TEXT = {
+  name: "its own lane:plan",
+  cause: "`lane:plan` gave its lane back to an earlier lane holding one of its planned files",
+  closed_head: "Its lane was given back by `pnpm josh lane:plan` after the Issue was closed.",
+  open_head: "Gave its lane back: `pnpm josh lane:plan` found an earlier lane holding one of its planned files.",
+  open_tail: "The lane closed before any implementation edit. The Issue stays in the run: it is offered again once the holding lane ends, keeping its place in line.",
+  stays: "The Issue stays in the run: it is offered again once the holding lane ends."
+};
+var YIELD_AT_MARK = " \xB7 at: ";
+async function record_yield(issue, reason, at) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.NOTE,
+    `${issue_cite.plain_for("program", String(issue))}${YIELD_MARK}${reason}${YIELD_AT_MARK}${at}`
+  );
+}
+function is_yield_note(event) {
+  return event.kind === run_event_stream.EVENT_KIND.NOTE && event.text.includes(YIELD_MARK);
+}
+function is_yield(event) {
+  return event.kind === run_event_stream.EVENT_KIND.WITHDRAW && event.text.includes(` withdrawn by ${YIELD_TEXT.name}:`);
+}
+function is_deciding(event, issue) {
+  if (run_event_scope.issue_named(event) !== issue) return false;
+  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) return true;
+  return is_yield_note(event) || event.kind === run_event_stream.EVENT_KIND.WITHDRAW && !is_yield(event);
+}
+function latest_yield(events, issue) {
+  const newest = events.findLast((event) => is_deciding(event, issue));
+  return newest !== void 0 && is_yield_note(newest) ? newest : void 0;
+}
+function is_yielded(events, issue) {
+  return latest_yield(events, issue) !== void 0;
+}
+function holder_of(note) {
+  const yielder = Number(run_event_scope.issue_named(note));
+  return [...note.text.matchAll(NAMED_ISSUE)].map((match) => Number(match[1])).findLast((issue) => issue !== yielder);
+}
+function withdraw_reason(events, issue) {
+  const note = latest_yield(events, issue);
+  const holder = note === void 0 ? void 0 : holder_of(note);
+  const holding_issue = issue_cite.plain_for("program", holder ?? "");
+  return holder === void 0 ? YIELD_REASON : `yielded to ${holding_issue}, which held one of its planned files; re-queues after ${holding_issue} merges`;
+}
+var lane_yield = {
+  YIELD_REASON,
+  YIELD_TEXT,
+  holder_of,
+  is_yield,
+  is_yield_note,
+  is_yielded,
+  record_yield,
+  withdraw_reason
+};
+
+export {
+  lane_yield
+};

package/dist/commands/chunk-SK3GDQOI.js

@@ -0,0 +1,20 @@
+import {
+  MAX_SCANNED
+} from "./chunk-ZB25RO3U.js";
+
+// scripts/git/listing-cutoff.ts
+function cutoff_of(row_count, limit, is_capped) {
+  if (row_count >= limit) return "row_limit";
+  return is_capped ? "page_ceiling" : "none";
+}
+var PAGE_CEILING_CAUSE = `stopped at the ${String(MAX_SCANNED)}-issue page ceiling`;
+function cutoff_cause(cutoff, row_limit_cause) {
+  if (cutoff === "row_limit") return row_limit_cause;
+  return cutoff === "page_ceiling" ? PAGE_CEILING_CAUSE : void 0;
+}
+
+export {
+  cutoff_of,
+  PAGE_CEILING_CAUSE,
+  cutoff_cause
+};