@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-4DVM57T7.js

@@ -1,86 +0,0 @@
-import {
-  import_graph
-} from "./chunk-FROACLVU.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-
-// scripts/lint/eslint-cache-dependencies.ts
-import { rmSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { parse, stringify } from "flatted";
-function is_record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function is_entry(item) {
-  if (!is_record(item)) return false;
-  const { key, value } = item;
-  return typeof key === "string" && is_record(value);
-}
-function is_entries(value) {
-  return Array.isArray(value) && value.every((item) => is_entry(item));
-}
-function parsed_or_undefined(content) {
-  try {
-    return parse(content);
-  } catch {
-    return void 0;
-  }
-}
-function read_entries(cache_file) {
-  const content = file_reader.read_optional(cache_file);
-  if (content === void 0) return void 0;
-  const parsed = parsed_or_undefined(content);
-  return is_entries(parsed) ? parsed : void 0;
-}
-function read_or_discard(cache_file) {
-  const entries = read_entries(cache_file);
-  if (entries === void 0) rmSync(cache_file, { force: true });
-  return entries ?? [];
-}
-function write_entries(cache_file, entries) {
-  writeFileSync(cache_file, stringify(entries));
-}
-function recorded_hash(entry) {
-  const { data } = entry.value;
-  if (!is_record(data)) return void 0;
-  const { dependencies } = data;
-  return typeof dependencies === "string" ? dependencies : void 0;
-}
-function drop_stale(cache_file, graph) {
-  const entries = read_or_discard(cache_file);
-  const hashes = new Map(entries.map((entry) => [entry.key, graph.closure_hash(entry.key)]));
-  const kept = entries.filter((entry) => recorded_hash(entry) === hashes.get(entry.key));
-  if (kept.length !== entries.length) write_entries(cache_file, kept);
-  return { hashes, drop: { dropped: entries.length - kept.length, total: entries.length } };
-}
-function record_entry(entry, hashes, graph) {
-  const { data } = entry.value;
-  if (!is_record(data) || "dependencies" in data) return false;
-  Object.assign(data, { dependencies: hashes.get(entry.key) ?? graph.closure_hash(entry.key) });
-  return true;
-}
-function record(cache_file, hashes, graph) {
-  const entries = read_entries(cache_file);
-  if (entries === void 0) return;
-  const recorded = entries.filter((entry) => record_entry(entry, hashes, graph));
-  if (recorded.length > 0) write_entries(cache_file, entries);
-}
-async function guard_counted(cache_file, run, root = process.cwd()) {
-  const graph = await import_graph.create(root);
-  if (graph === void 0) return { result: await run() };
-  const location = path.resolve(root, cache_file);
-  const { hashes, drop } = drop_stale(location, graph);
-  const result = await run();
-  record(location, hashes, graph);
-  return { result, drop };
-}
-async function guard(cache_file, run, root = process.cwd()) {
-  const { result } = await guard_counted(cache_file, run, root);
-  return result;
-}
-var eslint_cache_dependencies = { guard, guard_counted };
-
-export {
-  eslint_cache_dependencies
-};

package/dist/commands/chunk-4EADHJVC.js

@@ -1,247 +0,0 @@
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/security/security-audit-logic.ts
-import path from "node:path";
-var BINARY_NAME = "osv-scanner";
-var LOCKFILE_PATH = "pnpm-lock.yaml";
-var MANAGED_TOOL_SEGMENTS = ["node_modules", ".cache", "josh-tools"];
-var WINDOWS_PLATFORM = "win32";
-var WINDOWS_BINARY_SUFFIX = ".exe";
-var INSTALL_INSTRUCTIONS = [
-  "",
-  "Install options:",
-  "  Managed: pnpm josh audit:provision",
-  "  macOS:  brew install osv-scanner",
-  "  Go:     go install github.com/google/osv-scanner/v2/cmd/osv-scanner@latest",
-  '  Docker: docker run --rm -v "$PWD:/src" ghcr.io/google/osv-scanner --lockfile=/src/pnpm-lock.yaml',
-  "",
-  "Docs: https://google.github.io/osv-scanner/"
-].join("\n");
-function build_scanner_arguments(lockfile_path) {
-  return [`--lockfile=${lockfile_path}`];
-}
-function build_managed_binary_path(project_root, platform) {
-  const suffix = platform === WINDOWS_PLATFORM ? WINDOWS_BINARY_SUFFIX : "";
-  return path.join(project_root, ...MANAGED_TOOL_SEGMENTS, `${BINARY_NAME}${suffix}`);
-}
-function format_missing_binary_error(binary_name) {
-  return `${binary_name} is not installed.
-${INSTALL_INSTRUCTIONS}`;
-}
-var security_audit_logic = {
-  BINARY_NAME,
-  LOCKFILE_PATH,
-  build_managed_binary_path,
-  build_scanner_arguments,
-  format_missing_binary_error
-};
-
-// scripts/security/security-audit-provision-logic.ts
-var SCANNER_VERSION = "2.6.0";
-var MINIMUM_SCANNER_VERSION = SCANNER_VERSION;
-var RELEASE_BASE_URL = "https://github.com/google/osv-scanner/releases/download";
-var WINDOWS_PLATFORM2 = "win32";
-var WINDOWS_ASSET_SUFFIX = ".exe";
-var SESSION_DOWNLOAD_TIMEOUT_MS = 6e4;
-var FORCED_DOWNLOAD_TIMEOUT_MS = 6e5;
-function build_download_timeout(is_forced) {
-  return is_forced ? FORCED_DOWNLOAD_TIMEOUT_MS : SESSION_DOWNLOAD_TIMEOUT_MS;
-}
-var MS_PER_HOUR = 36e5;
-var HOURS_BEFORE_RETRY = 6;
-var RETRY_INTERVAL_MS = HOURS_BEFORE_RETRY * MS_PER_HOUR;
-var PLATFORM_NAMES = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows"
-};
-var ARCHITECTURE_NAMES = {
-  arm64: "arm64",
-  x64: "amd64"
-};
-var ASSET_CHECKSUMS = {
-  "osv-scanner_darwin_amd64": "60c5296637e977b28eeda5c7f13573e447659a632922737f94d11fa7e30ad6ca",
-  "osv-scanner_darwin_arm64": "98c460dcd37de25819babd757d04542045b6243113e209edcd4d89fedb0256b4",
-  "osv-scanner_linux_amd64": "ca69b3d3cd08f889a49dc0a383122f71cc528b83803671df5fd874d97485b108",
-  "osv-scanner_linux_arm64": "2c71403eb443d05891c4f268c3ad771cf4f16e5443463fd7851ef8f454d3c7e4",
-  "osv-scanner_windows_amd64.exe": "e0ed7644118b717b028c249ee9d3515024e55e8510747ca08906eb96765354d6",
-  "osv-scanner_windows_arm64.exe": "ca1379da0e408279ef2c85cde0846a903495738a91c7b065a208048437c1686c"
-};
-function build_asset_name(platform, architecture) {
-  const platform_name = PLATFORM_NAMES[platform];
-  const architecture_name = ARCHITECTURE_NAMES[architecture];
-  if (platform_name === void 0 || architecture_name === void 0) return void 0;
-  const suffix = platform === WINDOWS_PLATFORM2 ? WINDOWS_ASSET_SUFFIX : "";
-  return `${security_audit_logic.BINARY_NAME}_${platform_name}_${architecture_name}${suffix}`;
-}
-function build_download_url(asset_name) {
-  return `${RELEASE_BASE_URL}/v${SCANNER_VERSION}/${asset_name}`;
-}
-function resolve_asset(platform, architecture) {
-  const name = build_asset_name(platform, architecture);
-  if (name === void 0) return void 0;
-  const sha256 = ASSET_CHECKSUMS[name];
-  if (sha256 === void 0) return void 0;
-  return { name, sha256, url: build_download_url(name) };
-}
-function format_already_present(location) {
-  return `osv-scanner is already available (${location}); nothing to provision.`;
-}
-function format_unsupported_platform(platform, architecture) {
-  return `No pinned osv-scanner build for ${platform}/${architecture}; install it manually to run the pre-push audit.`;
-}
-function format_download_failure(url, reason) {
-  return `Could not fetch osv-scanner from ${url}: ${reason}. Run \`pnpm josh audit:provision --force\` to retry with a longer timeout; until then the pre-push audit will report the missing binary.`;
-}
-function format_checksum_mismatch(asset_name, expected, actual) {
-  return `Checksum mismatch for ${asset_name}: expected ${expected}, got ${actual}. Nothing was installed.`;
-}
-function format_installed(target_path) {
-  return `Installed osv-scanner v${SCANNER_VERSION} at ${target_path}.`;
-}
-function format_recent_failure() {
-  return `A previous attempt to provision osv-scanner failed less than ${String(HOURS_BEFORE_RETRY)} hours ago; not retrying at session start. Run \`pnpm josh audit:provision --force\` to try again now.`;
-}
-function format_provision_error(reason) {
-  return `Could not provision osv-scanner: ${reason}. The pre-push audit will report the missing binary.`;
-}
-var SCANNER_VERSION_PATTERN = /osv-scanner version:\s*(\d+\.\d+\.\d+)/u;
-function parse_scanner_version(version_output) {
-  return SCANNER_VERSION_PATTERN.exec(version_output)?.[1];
-}
-function to_version_parts(version) {
-  return version.split(".").map(Number);
-}
-function compare_versions(left, right) {
-  const left_parts = to_version_parts(left);
-  const right_parts = to_version_parts(right);
-  const length = Math.max(left_parts.length, right_parts.length);
-  for (let index = 0; index < length; index += 1) {
-    const difference = (left_parts[index] ?? 0) - (right_parts[index] ?? 0);
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
-function meets_version_floor(version) {
-  return compare_versions(version, MINIMUM_SCANNER_VERSION) >= 0;
-}
-function format_below_floor(version) {
-  return `osv-scanner ${version} is below the required v${MINIMUM_SCANNER_VERSION}; older builds parse only part of pnpm-lock.yaml, so a clean result here is not proof the lockfile is clean. Run \`pnpm josh audit:provision --force\` to install v${SCANNER_VERSION}.`;
-}
-var security_audit_provision_logic = {
-  RETRY_INTERVAL_MS,
-  SESSION_DOWNLOAD_TIMEOUT_MS,
-  SCANNER_VERSION,
-  MINIMUM_SCANNER_VERSION,
-  build_asset_name,
-  build_download_timeout,
-  build_download_url,
-  format_already_present,
-  format_below_floor,
-  format_checksum_mismatch,
-  format_download_failure,
-  format_installed,
-  format_provision_error,
-  format_recent_failure,
-  format_unsupported_platform,
-  meets_version_floor,
-  parse_scanner_version,
-  resolve_asset
-};
-
-// scripts/security/security-audit.ts
-import { accessSync, constants, statSync } from "node:fs";
-import path2 from "node:path";
-import { execaSync } from "execa";
-var FAILURE_EXIT_CODE = 1;
-var GIT_DIRECTORY_NAME = ".git";
-var UNKNOWN_VERSION = "unknown";
-function is_binary_available(binary_name) {
-  const result = execaSync(binary_name, ["--version"], { stdio: "ignore", reject: false });
-  return result.exitCode !== void 0;
-}
-function scanner_version(binary_or_path) {
-  const result = execaSync(binary_or_path, ["--version"], { reject: false });
-  if (result.exitCode === void 0) return void 0;
-  return security_audit_provision_logic.parse_scanner_version(result.stdout);
-}
-function meets_floor(binary_or_path) {
-  const version = scanner_version(binary_or_path);
-  return version !== void 0 && security_audit_provision_logic.meets_version_floor(version);
-}
-function is_executable_file(candidate_path) {
-  try {
-    accessSync(candidate_path, constants.X_OK);
-    const stats = statSync(candidate_path);
-    return stats.isFile() && stats.size > 0;
-  } catch {
-    return false;
-  }
-}
-function managed_root(project_root) {
-  const common = git_common_directory.repository(project_root);
-  if (common === void 0 || path2.basename(common) !== GIT_DIRECTORY_NAME) return project_root;
-  return path2.dirname(common);
-}
-function managed_binary_path(project_root, platform) {
-  return security_audit_logic.build_managed_binary_path(managed_root(project_root), platform);
-}
-function managed_scanner(project_root, platform) {
-  const managed_path = managed_binary_path(project_root, platform);
-  return is_executable_file(managed_path) && meets_floor(managed_path) ? managed_path : void 0;
-}
-function resolve_scanner(project_root, platform) {
-  const { BINARY_NAME: BINARY_NAME2 } = security_audit_logic;
-  const has_path_binary = is_binary_available(BINARY_NAME2);
-  if (has_path_binary && meets_floor(BINARY_NAME2)) {
-    return { path: BINARY_NAME2, is_below_floor: false };
-  }
-  const managed = managed_scanner(project_root, platform);
-  if (managed !== void 0) return { path: managed, is_below_floor: false };
-  return has_path_binary ? { path: BINARY_NAME2, is_below_floor: true } : void 0;
-}
-var FORWARDED_OUTPUT = ["inherit", "pipe"];
-function run_scanner(scanner_path) {
-  const { LOCKFILE_PATH: LOCKFILE_PATH2, build_scanner_arguments: build_scanner_arguments2 } = security_audit_logic;
-  const result = execaSync(scanner_path, [...build_scanner_arguments2(LOCKFILE_PATH2)], {
-    stdin: "inherit",
-    stdout: FORWARDED_OUTPUT,
-    stderr: FORWARDED_OUTPUT,
-    reject: false
-  });
-  return result.exitCode ?? FAILURE_EXIT_CODE;
-}
-function warn_below_floor(scanner_path) {
-  const version = scanner_version(scanner_path) ?? UNKNOWN_VERSION;
-  console.warn(security_audit_provision_logic.format_below_floor(version));
-}
-function run() {
-  const { BINARY_NAME: BINARY_NAME2, format_missing_binary_error: format_missing_binary_error2 } = security_audit_logic;
-  const choice = resolve_scanner(PROJECT_ROOT, process.platform);
-  if (choice === void 0) {
-    console.error(format_missing_binary_error2(BINARY_NAME2));
-    return FAILURE_EXIT_CODE;
-  }
-  if (choice.is_below_floor) warn_below_floor(choice.path);
-  return run_scanner(choice.path);
-}
-var security_audit = {
-  is_binary_available,
-  is_executable_file,
-  managed_binary_path,
-  meets_floor,
-  resolve_scanner,
-  run,
-  run_scanner
-};
-
-export {
-  security_audit_logic,
-  security_audit_provision_logic,
-  security_audit
-};

package/dist/commands/chunk-4HERA2GY.js

@@ -1,95 +0,0 @@
-import {
-  stash_args
-} from "./chunk-R7IT5VOL.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/git/stash/stash-pop-cli.ts
-var COMMAND = "stash:pop";
-var POPPED_VERDICT = "popped";
-var CONFLICTED_VERDICT = "conflicted";
-var NO_MATCH_VERDICT = "no-match";
-var AMBIGUOUS_VERDICT = "ambiguous";
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-function report(verdict, detail, code) {
-  console.info(verdict);
-  console.error(detail);
-  return code;
-}
-function refuse() {
-  console.error(stash_args.usage(COMMAND));
-  return FAILURE_EXIT_CODE;
-}
-async function pop_selected(selector, directory) {
-  try {
-    await git_stash.pop(selector, directory);
-  } catch (error) {
-    if (await git_stash.has_conflict(directory)) {
-      const detail = `Popped ${selector} with conflicts \u2014 resolve them.`;
-      return report(CONFLICTED_VERDICT, detail, SUCCESS_EXIT_CODE);
-    }
-    throw error;
-  }
-  return report(POPPED_VERDICT, `Popped ${selector}.`, SUCCESS_EXIT_CODE);
-}
-var HASH_ARGUMENT = /^[\da-f]{7,40}$/u;
-async function ambiguous(request) {
-  const entries = await git_stash.list_by_hash(request.dir);
-  const hashes = entries.filter((entry) => git_stash.matches(entry.subject, request.message));
-  const named = hashes.map((entry) => entry.selector).join(", ");
-  const detail = `More than one stash matches "${request.message}" \u2014 pop one by its hash: ${named}.`;
-  return report(AMBIGUOUS_VERDICT, detail, FAILURE_EXIT_CODE);
-}
-async function position_of_hash(hash, directory) {
-  const entries = await git_stash.list_by_hash(directory);
-  const [only, ...rest] = entries.filter((entry) => entry.selector.startsWith(hash));
-  if (only === void 0 || rest.length > 0) return void 0;
-  return await git_stash.position_of(only.selector, directory);
-}
-async function pop_hash(hash, directory) {
-  const position = await position_of_hash(hash, directory);
-  if (position === void 0) {
-    return report(NO_MATCH_VERDICT, `No single stash has the hash ${hash}.`, FAILURE_EXIT_CODE);
-  }
-  return await pop_selected(position, directory);
-}
-async function answer(request) {
-  if (HASH_ARGUMENT.test(request.message)) return await pop_hash(request.message, request.dir);
-  const selection = git_stash.select(await git_stash.list(request.dir), request.message);
-  if (selection.kind === "none") {
-    return report(NO_MATCH_VERDICT, `No stash matches "${request.message}".`, FAILURE_EXIT_CODE);
-  }
-  if (selection.kind === "ambiguous") return await ambiguous(request);
-  return await pop_selected(selection.selector, request.dir);
-}
-function report_unknown(error) {
-  console.error(error_text.message_of(error));
-  return FAILURE_EXIT_CODE;
-}
-async function run(argv) {
-  const parsed = stash_args.read_arguments(argv);
-  if (parsed === void 0) return refuse();
-  const request = stash_args.to_request(parsed);
-  if (request === void 0) return refuse();
-  try {
-    return await answer(request);
-  } catch (error) {
-    return report_unknown(error);
-  }
-}
-var stash_pop_cli = {
-  AMBIGUOUS_VERDICT,
-  CONFLICTED_VERDICT,
-  NO_MATCH_VERDICT,
-  POPPED_VERDICT,
-  run
-};
-
-export {
-  stash_pop_cli
-};

package/dist/commands/chunk-4JI35CVO.js

@@ -1,70 +0,0 @@
-import {
-  run_merge_token
-} from "./chunk-FHFWNNUC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/merge/run-merge-driver.ts
-import { z } from "zod";
-
-// scripts/run/merge/run-merge-outcome.ts
-var CHILD_OUTCOMES = [
-  "merged",
-  "withdrawn",
-  "yielded",
-  "human-review",
-  "parked",
-  "split",
-  "cut",
-  "outage",
-  "unauthenticated",
-  "usage-limit",
-  "failed",
-  "unresolved",
-  "shipping"
-];
-var run_merge_outcome = { CHILD_OUTCOMES };
-
-// scripts/run/merge/run-merge-driver.ts
-var COMMAND = "run:merge";
-var DRIVER_FLAG = "--driver";
-var JSON_KEY = "merge";
-var LINE_BREAK = "\n";
-var DEFERRED_OFFER = "deferred";
-var control_schema = z.object({
-  token: z.enum(Object.values(run_merge_token.MERGE_TOKEN)),
-  code: z.number(),
-  is_offer: z.literal(false),
-  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
-  is_parked: z.boolean().optional()
-});
-var offer_schema = z.object({
-  token: z.string(),
-  code: z.number(),
-  is_offer: z.literal(true),
-  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
-  is_parked: z.boolean().optional()
-});
-var printed_schema = z.object({
-  [JSON_KEY]: z.discriminatedUnion("is_offer", [control_schema, offer_schema])
-});
-function argv_of(merge) {
-  const output = merge.output === void 0 ? [] : ["--output", merge.output];
-  return [COMMAND, merge.child, "--owner", merge.owner, DRIVER_FLAG, ...output];
-}
-function print(result) {
-  return JSON.stringify({ [JSON_KEY]: result });
-}
-function printed(argv, result) {
-  return argv.includes(DRIVER_FLAG) ? print(result) : result.token;
-}
-function read(out) {
-  const last = out.trimEnd().split(LINE_BREAK).at(-1) ?? "";
-  return json_value.parse_with(last, printed_schema)?.[JSON_KEY];
-}
-var run_merge_driver = { DEFERRED_OFFER, DRIVER_FLAG, argv_of, print, printed, read };
-
-export {
-  run_merge_driver
-};

package/dist/commands/chunk-4L4LNWZ7.js

@@ -1,143 +0,0 @@
-import {
-  backlogrun_parent_read_set,
-  lane_child_read_set
-} from "./chunk-6GQX752S.js";
-import {
-  document_byte_budget
-} from "./chunk-M3ZDYCUF.js";
-import {
-  entry_read_set
-} from "./chunk-SZG5HDNP.js";
-import {
-  PACKAGE_DIR
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/document/entry-read-budget.ts
-import { statSync } from "node:fs";
-import path from "node:path";
-
-// scripts/document/document-reachability.ts
-var RESIDENT_BASE = ["CLAUDE.md"];
-var WORKFLOW_DIRECTORY = ".claude/skills/workflow-commands";
-function workflow_path(name) {
-  return `${WORKFLOW_DIRECTORY}/${name}`;
-}
-function names_of(set) {
-  return [...set.files, ...set.sections.map((reference) => reference.file)];
-}
-function entry_read_names(root) {
-  const names = [...entry_read_set.entries(root), lane_child_read_set.LANE_CHILD].flatMap(
-    (entry) => names_of(entry_read_set.read_set(root, entry))
-  );
-  return new Set(names);
-}
-function resident_documents(root) {
-  return /* @__PURE__ */ new Set([
-    ...RESIDENT_BASE,
-    ...[...entry_read_names(root)].map((name) => workflow_path(name))
-  ]);
-}
-function point_of_use_documents() {
-  const per_entry = [...entry_read_set.POINT_OF_USE_BY_ENTRY.values()].flatMap((files) => [
-    ...files
-  ]);
-  return new Set(
-    [...entry_read_set.POINT_OF_USE_FILES, ...per_entry].map((name) => workflow_path(name))
-  );
-}
-function label_of(relative_path, resident, point_of_use) {
-  if (resident.has(relative_path)) return "resident";
-  return point_of_use.has(relative_path) ? "point-of-use" : "unreached";
-}
-function classify(corpus, root = process.cwd()) {
-  const resident = resident_documents(root);
-  const point_of_use = point_of_use_documents();
-  return new Map(corpus.map((one) => [one, label_of(one, resident, point_of_use)]));
-}
-function documents_labelled(label, corpus, root = process.cwd()) {
-  return [...classify(corpus, root)].filter(([, value]) => value === label).map(([one]) => one).toSorted((left, right) => left.localeCompare(right));
-}
-function covered_documents(root = process.cwd()) {
-  return [.../* @__PURE__ */ new Set([...resident_documents(root), ...point_of_use_documents()])].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-}
-function unreached_documents(corpus, root = process.cwd()) {
-  return documents_labelled("unreached", corpus, root);
-}
-var document_reachability = {
-  RESIDENT_BASE,
-  classify,
-  covered_documents,
-  documents_labelled,
-  unreached_documents
-};
-
-// scripts/document/entry-read-budget.ts
-var { block_ceiling } = document_byte_budget;
-var { LANE_CHILD } = lane_child_read_set;
-var { BACKLOGRUN } = backlogrun_parent_read_set;
-var NOTHING = 0;
-var RECHECK_COMMAND = "pnpm josh bytes";
-var ENTRY_READ_BUDGET = [
-  { entry: "kickoff", bytes: 36864 },
-  // joshuafolkken/kit#6094 trimmed restated prose from SKILL.md and entry-sequence.md, lowering
-  // `fullrun`, `halfrun`, `prrun` and `backlogrun` by a block each.
-  { entry: "fullrun", bytes: 49152 },
-  { entry: "halfrun", bytes: 45056 },
-  { entry: "prrun", bytes: 49152 },
-  // joshuafolkken/kit#5843 removed the duplicated backlogrun procedures, lowering the read by a block;
-  // joshuafolkken/kit#5920 moved the loop's section pointers into the driver hand-off, by another;
-  // joshuafolkken/kit#5946 moved the lane child's step 0 out of the chain section, by another
-  // (and lowered `prrun` and the lane child by one block each).
-  { entry: "backlogrun", bytes: 69632 },
-  // joshuafolkken/kit#5953 charged pre-gate-cut.md at the two sections run:cut prints, not whole;
-  // joshuafolkken/kit#5958 dropped the seam's pointer to the cut, lowering it by a block.
-  { entry: LANE_CHILD, bytes: 24576 }
-];
-function byte_size(root, relative_path) {
-  return statSync(path.join(root, relative_path)).size;
-}
-function entry_cost(root, entry) {
-  if (entry === LANE_CHILD) return lane_child_read_set.costed(root);
-  if (entry === BACKLOGRUN) return backlogrun_parent_read_set.costed(root);
-  return entry_read_set.costed(root, entry);
-}
-function total_read_bytes(cost) {
-  return entry_read_set.total([cost.scoped, ...cost.point_of_use.map((one) => one.cost)]).bytes;
-}
-function resident_base_bytes() {
-  return document_reachability.RESIDENT_BASE.reduce(
-    (sum, one) => sum + byte_size(PACKAGE_DIR, one),
-    NOTHING
-  );
-}
-function entry_total_bytes(root, entry) {
-  return total_read_bytes(entry_cost(root, entry)) + resident_base_bytes();
-}
-function recorded_bytes_for(entry) {
-  return ENTRY_READ_BUDGET.find((one) => one.entry === entry)?.bytes;
-}
-function over_budget_message(entry, current_bytes, recorded_bytes) {
-  const next = block_ceiling(current_bytes).toString();
-  const raise_hint = `raise its recorded size to ${next} in scripts/document/entry-read-budget.ts so the reason shows in the PR diff`;
-  return `entry ${entry} reads ${current_bytes.toString()} bytes, over its ${recorded_bytes.toString()}-byte ceiling. Trim what it reads, or ${raise_hint}. Recheck with \`${RECHECK_COMMAND}\`.`;
-}
-function stale_budget_message(entry, recorded_bytes, current_bytes) {
-  const next = block_ceiling(current_bytes).toString();
-  const lower_hint = `lower its recorded size to ${next} in scripts/document/entry-read-budget.ts so the ratchet holds the reduction`;
-  return `entry ${entry} records ${recorded_bytes.toString()} bytes but reads ${current_bytes.toString()}, more than a block above actual. ${lower_hint}.`;
-}
-var entry_read_budget = {
-  ENTRY_READ_BUDGET,
-  RECHECK_COMMAND,
-  entry_total_bytes,
-  over_budget_message,
-  recorded_bytes_for,
-  stale_budget_message
-};
-
-export {
-  document_reachability,
-  entry_read_budget
-};