@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-V37AWEYE.js

@@ -0,0 +1,62 @@
+import {
+  git_gh_command,
+  git_pr_checks
+} from "./chunk-VJNE7W7O.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+
+// scripts/gh/git-pr-merge-checked.ts
+var MAX_HEAD_MOVES = 3;
+var NO_CHECKED_HEAD_MESSAGE = "The merge gate answered without the head commit it checked, so there is no commit to bind the merge to";
+var HEAD_MOVED_NOTE = "The pull request head moved after its checks passed \u2014 waiting on the new head";
+var HEAD_KEPT_MOVING_MESSAGE = `The pull request head moved after its checks passed ${String(MAX_HEAD_MOVES)} times, so it was not merged`;
+function checked_head(snapshot) {
+  if (snapshot.head_sha === void 0) throw new Error(NO_CHECKED_HEAD_MESSAGE);
+  return snapshot.head_sha;
+}
+async function try_merge(input, snapshot) {
+  const head_sha = checked_head(snapshot);
+  await input.before_merge?.(head_sha);
+  try {
+    await git_gh_command.pr_merge(input.branch_name, head_sha);
+    return true;
+  } catch (error) {
+    if (!git_gh_command.is_head_moved(error)) throw error;
+    return false;
+  }
+}
+async function merge_checked(input) {
+  const progress = { snapshot: input.checked ?? await input.wait_for_green() };
+  const is_merged = await poll.poll_until(
+    async () => {
+      if (await try_merge(input, progress.snapshot)) return true;
+      console.info(HEAD_MOVED_NOTE);
+      Object.assign(progress, { snapshot: await input.wait_for_green() });
+      return false;
+    },
+    {
+      attempts: MAX_HEAD_MOVES,
+      interval_ms: 0,
+      sleeper: async () => {
+        await Promise.resolve();
+      }
+    }
+  );
+  if (is_merged) return;
+  throw new Error(HEAD_KEPT_MOVING_MESSAGE);
+}
+async function merge_when_green(branch_name) {
+  async function wait_for_green() {
+    return await git_pr_checks.wait_for_pr_success(branch_name);
+  }
+  await merge_checked({ branch_name, wait_for_green });
+}
+var git_pr_merge_checked = {
+  merge_checked,
+  merge_when_green
+};
+
+export {
+  git_pr_merge_checked
+};

package/dist/commands/chunk-V4D4YV4B.js

@@ -0,0 +1,110 @@
+import {
+  security_audit,
+  security_audit_logic,
+  security_audit_provision_logic
+} from "./chunk-FITTCICF.js";
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+
+// scripts/security/security-audit-provision.ts
+var EXECUTABLE_MODE = 493;
+var FAILURE_STAMP_PREFIX = "josh-audit-provision-";
+var FORCE_FLAG = "--force";
+var PATH_LOCATION = "on PATH";
+var { RETRY_INTERVAL_MS } = security_audit_provision_logic;
+async function download(url, timeout_ms) {
+  try {
+    const response = await timed_fetch(url, {}, timeout_ms);
+    if (!response.ok) return { reason: `HTTP ${String(response.status)}` };
+    return { content: Buffer.from(await response.arrayBuffer()), reason: "" };
+  } catch (error) {
+    return { reason: error_text.message_of(error) };
+  }
+}
+function install(target_path, content) {
+  atomic_write.replace_file(target_path, content, { mode: EXECUTABLE_MODE });
+}
+function failure_stamp_path(target_path) {
+  return stamp_file.stamp_path(FAILURE_STAMP_PREFIX, target_path);
+}
+function is_in_backoff(target_path) {
+  const recorded = Number(stamp_file.read_stamp_text(failure_stamp_path(target_path)));
+  return Number.isFinite(recorded) && Date.now() - recorded < RETRY_INTERVAL_MS;
+}
+function record_failure(target_path, message) {
+  stamp_file.write_stamp(failure_stamp_path(target_path), Date.now());
+  return message;
+}
+async function provision(target_path, asset, timeout_ms) {
+  const { format_checksum_mismatch, format_download_failure, format_installed } = security_audit_provision_logic;
+  const outcome = await download(asset.url, timeout_ms);
+  if (outcome.content === void 0) {
+    return { is_installed: false, message: format_download_failure(asset.url, outcome.reason) };
+  }
+  const actual = stamp_file.digest(outcome.content);
+  if (actual !== asset.sha256) {
+    return {
+      is_installed: false,
+      message: format_checksum_mismatch(asset.name, asset.sha256, actual)
+    };
+  }
+  install(target_path, outcome.content);
+  return { is_installed: true, message: format_installed(target_path) };
+}
+async function attempt(target_path, asset, timeout_ms) {
+  try {
+    const outcome = await provision(target_path, asset, timeout_ms);
+    if (!outcome.is_installed) return record_failure(target_path, outcome.message);
+    stamp_file.remove_stamp(failure_stamp_path(target_path));
+    return outcome.message;
+  } catch (error) {
+    return record_failure(
+      target_path,
+      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
+    );
+  }
+}
+function existing_scanner(target_path) {
+  const { BINARY_NAME } = security_audit_logic;
+  if (security_audit.meets_floor(BINARY_NAME)) return PATH_LOCATION;
+  const is_managed_usable = security_audit.is_executable_file(target_path) && security_audit.meets_floor(target_path);
+  return is_managed_usable ? target_path : void 0;
+}
+async function report(project_root, platform, architecture, is_forced) {
+  const logic = security_audit_provision_logic;
+  const target_path = security_audit.managed_binary_path(project_root, platform);
+  const existing = existing_scanner(target_path);
+  if (existing !== void 0) return logic.format_already_present(existing);
+  const asset = logic.resolve_asset(platform, architecture);
+  if (asset === void 0) return logic.format_unsupported_platform(platform, architecture);
+  if (!is_forced && is_in_backoff(target_path)) return logic.format_recent_failure();
+  return await attempt(target_path, asset, logic.build_download_timeout(is_forced));
+}
+async function run(argv) {
+  const is_forced = argv.includes(FORCE_FLAG);
+  try {
+    console.info(await report(PROJECT_ROOT, process.platform, process.arch, is_forced));
+  } catch (error) {
+    console.warn(
+      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
+    );
+  }
+}
+var security_audit_provision = { attempt, provision, report, run };
+
+export {
+  security_audit_provision
+};

package/dist/commands/chunk-V56NLG7I.js

@@ -0,0 +1,217 @@
+import {
+  durable_state,
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  STARTUP: "startup",
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  CHAIN: "chain",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  OFFER: "offer",
+  CORE_WAIT: "core-wait",
+  CORE_ADMISSION: "core-admission",
+  UNIT_FILES: "unit-files",
+  TEST_RELATED: "test-related",
+  TEST_PINNED: "test-pinned",
+  SPLIT_NOTICE: "split-notice",
+  SPLIT_FILED: "split-filed",
+  UNPLANNED_NOTICE: "unplanned-notice",
+  LANE_STATE: "lane-state",
+  PUSH_MISS: "push-miss",
+  EARLY_PUSH: "early-push",
+  SHIP_LAP: "ship-lap",
+  SIZE: "size",
+  LIMIT: "limit"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lane/lane-ledger-write.ts
+var LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
+var LEDGER_SUFFIX = ".jsonl";
+var LINE_SEPARATOR = "\n";
+var CI_WAIT_STAGE = "ci-wait";
+var CODERABBIT_WAIT_STAGE = "coderabbit-wait";
+var CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
+var CODERABBIT_RETRIGGER_STAGE = "coderabbit-retriggered";
+var PRE_DETACH_STAGE = "pre-detach";
+var ROUND_ONE_REUSED = "reused";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND2 } = lane_ledger_kind;
+function target_of(repository) {
+  return durable_state.path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? void 0 : target_of(repository);
+  } catch {
+    return void 0;
+  }
+}
+function append(path, entry) {
+  const descriptor = openSync(path, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (!stamp_file.is_own_regular_file(path)) {
+      throw new Error("Ledger is not an owned regular file");
+    }
+    writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry, path) {
+  try {
+    const destination = path ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
+}
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function record_gate(path, gate) {
+  await record({ kind: KIND2.GATE, at: now_iso(), ...gate }, path);
+}
+async function record_merge(issue, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND2.MERGE, at: at.toISOString(), issue });
+}
+async function record_dispatch(issue, path) {
+  await record({ kind: KIND2.DISPATCH, at: now_iso(), issue }, path);
+}
+async function record_stage(stage, path) {
+  await record({ kind: KIND2.STAGE, at: now_iso(), ...stage }, path);
+}
+async function record_stop(stop, path) {
+  await record({ kind: KIND2.STOP, at: now_iso(), ...stop }, path);
+}
+async function record_chain(chain, path) {
+  await record({ kind: KIND2.CHAIN, at: now_iso(), ...chain }, path);
+}
+async function record_overlap(overlap, path) {
+  await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path);
+}
+async function record_held(held, path) {
+  const waiting = held.waiting ?? [];
+  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path);
+}
+async function record_released(path) {
+  await record({ kind: KIND2.RELEASED, at: now_iso() }, path);
+}
+async function record_lane_state(change, path) {
+  await record({ kind: KIND2.LANE_STATE, at: now_iso(), ...change }, path);
+}
+async function record_offerable(is_offerable, path) {
+  await record({ kind: KIND2.OFFERABLE, at: now_iso(), is_offerable }, path);
+}
+async function record_offer(offer, path) {
+  await record({ kind: KIND2.OFFER, at: now_iso(), ...offer }, path);
+}
+async function record_round_one(round_one, path) {
+  await record({ kind: KIND2.ROUND_ONE, at: now_iso(), ...round_one }, path);
+}
+async function record_round_two(round_two, path) {
+  await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path);
+}
+async function record_core_wait(wait, path) {
+  const is_immediate = wait.admission_reason !== void 0 && wait.wait_reason === void 0;
+  const kind = is_immediate ? KIND2.CORE_ADMISSION : KIND2.CORE_WAIT;
+  await record({ kind, at: now_iso(), ...wait }, path);
+}
+async function record_unit_files(files, path) {
+  await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path);
+}
+async function record_test_related(run, path) {
+  await record({ kind: KIND2.TEST_RELATED, at: now_iso(), ...run }, path);
+}
+async function record_test_pinned(run, path) {
+  await record({ kind: KIND2.TEST_PINNED, at: now_iso(), ...run }, path);
+}
+async function record_split_notice(notice, path) {
+  await record({ kind: KIND2.SPLIT_NOTICE, at: now_iso(), ...notice }, path);
+}
+async function record_split_filed(filed, path) {
+  const destination = path ?? await target();
+  if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
+  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
+}
+async function record_push_miss(miss, path) {
+  await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path);
+}
+async function record_early_push(push, path) {
+  await record({ kind: KIND2.EARLY_PUSH, at: now_iso(), ...push }, path);
+}
+async function record_ship_lap(lap, path) {
+  await record({ kind: KIND2.SHIP_LAP, at: now_iso(), ...lap }, path);
+}
+async function record_size(size, path) {
+  await record({ kind: KIND2.SIZE, at: now_iso(), ...size }, path);
+}
+async function record_unplanned_notice(notice, path) {
+  await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND2,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_chain,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offer,
+  record_offerable,
+  record_push_miss,
+  record_early_push,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  record_size,
+  record_split_filed,
+  record_split_notice,
+  record_stage,
+  record_stop,
+  record_test_pinned,
+  record_test_related,
+  record_unit_files,
+  record_unplanned_notice,
+  target,
+  target_of
+};
+
+export {
+  lane_ledger_kind,
+  lane_ledger_write
+};

package/dist/commands/chunk-V6WHDQAZ.js

@@ -0,0 +1,74 @@
+import {
+  scoped_green
+} from "./chunk-77R6JEET.js";
+import {
+  verification_inputs
+} from "./chunk-HQ5U6OZR.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gate/tree-verdict.ts
+import { z } from "zod";
+var verdict_schema = z.object({
+  tree: z.string(),
+  exit_code: z.number(),
+  tail: z.string(),
+  at: z.string()
+});
+var SHORT_HASH_LENGTH = 12;
+var REUSED_PREFIX = "reused: tree ";
+function record_path(name) {
+  return stamp_file.stamp_path(`josh-tree-verdict-${name}-`, PROJECT_ROOT);
+}
+function tree_hash(tree) {
+  const files = Object.entries(tree.files).map(([file, digest]) => `${file}	${digest}`);
+  const inputs = verification_inputs.fingerprint(verification_inputs.DECLARED_LABELS);
+  return input_fingerprint.of_entries([...files, `base	${tree.base ?? ""}`, `inputs	${inputs}`]);
+}
+function read_record(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, verdict_schema);
+}
+function read(tree, target) {
+  if (tree?.base === void 0) return void 0;
+  const verdict = read_record(target);
+  return verdict?.tree === tree_hash(tree) ? verdict : void 0;
+}
+function reused_line(verdict, target) {
+  const is_green = verdict.exit_code === 0;
+  const state = is_green ? "green" : "red";
+  const line = `${REUSED_PREFIX}${verdict.tree.slice(0, SHORT_HASH_LENGTH)} ${state} at ${verdict.at}`;
+  return is_green ? line : `${line} \u2014 remove ${target} to run it again`;
+}
+function is_replay(out) {
+  return out.includes(REUSED_PREFIX);
+}
+function replay(verdict, target, live = []) {
+  const notices = live.map((notice) => notice === void 0 ? "" : `
+${notice}
+`).join("");
+  process.stdout.write(`${reused_line(verdict, target)}
+${notices}${verdict.tail}`);
+  return verdict.exit_code;
+}
+async function record(entry, read_after, target) {
+  const { before, exit_code, tail } = entry;
+  if (before?.base === void 0 || !scoped_green.is_unmoved(before, await read_after())) return;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  stamp_file.replace_stamp(target, { tree: tree_hash(before), exit_code, tail, at });
+}
+var tree_verdict = { is_replay, read, record, record_path, replay, reused_line };
+
+export {
+  tree_verdict
+};

package/dist/commands/chunk-V6WWW6HX.js

@@ -0,0 +1,140 @@
+import {
+  shared_cache
+} from "./chunk-RW7OILP7.js";
+import {
+  gh_call_kind,
+  gh_failure,
+  gh_request_tally,
+  gh_retry,
+  git_gh_exec,
+  has_stdout_field,
+  parse_json_array_or_undefined
+} from "./chunk-NAZ753DE.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/gh/git-gh-conditional.ts
+var NOT_MODIFIED_STATUS = 304;
+var OK_STATUS = 200;
+var INCLUDE_FLAG = "--include";
+var HEADER_FLAG = "-H";
+var IF_NONE_MATCH = "If-None-Match: ";
+var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
+var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
+var UNCHANGED = { kind: "unchanged" };
+var UNREADABLE = { kind: "unreadable" };
+function to_args(path, etag) {
+  const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
+  return ["api", INCLUDE_FLAG, ...header, path];
+}
+function to_changed(output) {
+  const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
+  const etag = ETAG_HEADER.exec(headers)?.groups?.["etag"];
+  return { kind: "changed", etag, body: rest.join("\n\n") };
+}
+function to_read(output) {
+  return git_gh_exec.parse_status_line(output) === OK_STATUS ? to_changed(output) : UNREADABLE;
+}
+function failure_status(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
+}
+function not_modified(path) {
+  gh_request_tally.count_not_modified(gh_call_kind.of_api(path));
+  return UNCHANGED;
+}
+function rethrow_failure(error, path) {
+  const status = failure_status(error);
+  if (status === NOT_MODIFIED_STATUS) return not_modified(path);
+  if (status !== void 0 && error instanceof Error) gh_failure.attach(error, { status });
+  throw error;
+}
+async function request_conditional(path, etag, timeout_ms) {
+  try {
+    return to_read(await git_gh_exec.exec_gh_command(to_args(path, etag), timeout_ms));
+  } catch (error) {
+    return rethrow_failure(error, path);
+  }
+}
+async function read_conditional(path, etag, timeout_ms) {
+  const retry = timeout_ms === void 0 ? gh_retry.with_read_retry : gh_retry.with_retry;
+  try {
+    return await retry(async () => await request_conditional(path, etag, timeout_ms));
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+var git_gh_conditional = { read_conditional, to_args };
+
+// scripts/gh/git-gh-etag-read.ts
+import { z } from "zod";
+var SLOT_PREFIX = "josh-gh-etag-";
+var PATH_DIGEST_LENGTH = 16;
+var HOURS_KEPT = 24;
+var MS_PER_HOUR = 36e5;
+var UNREADABLE_MESSAGE = "gh api could not read";
+var kept_schema = z.object({ etag: z.string(), body: z.string() });
+function settle(previous, answer) {
+  if (previous !== void 0 && answer.kind === "unchanged") return { body: previous.body };
+  if (answer.kind !== "changed") return void 0;
+  if (answer.etag === void 0) return { body: answer.body };
+  return { body: answer.body, kept: { etag: answer.etag, body: answer.body } };
+}
+function slot_of(path) {
+  const name = stamp_file.digest(path).slice(0, PATH_DIGEST_LENGTH);
+  return { prefix: `${SLOT_PREFIX}${name}-`, ttl_ms: HOURS_KEPT * MS_PER_HOUR };
+}
+function unreadable(path, answer) {
+  const cause = answer.kind === "unreadable" ? answer.cause : void 0;
+  return cause ?? new Error(`${UNREADABLE_MESSAGE}: ${path}`);
+}
+async function read_detail(path, timeout_ms) {
+  const slot = slot_of(path);
+  const previous = shared_cache.read(slot, path, kept_schema, Date.now());
+  const answer = await git_gh_conditional.read_conditional(path, previous?.etag, timeout_ms);
+  const settled = settle(previous, answer);
+  if (settled === void 0) throw unreadable(path, answer);
+  if (settled.kept !== void 0) shared_cache.write(slot, path, settled.kept, Date.now());
+  return { body: settled.body, is_unchanged: answer.kind === "unchanged" };
+}
+async function read(path, timeout_ms) {
+  const { body } = await read_detail(path, timeout_ms);
+  return body;
+}
+async function read_listing(path, per_page, read_page = read) {
+  const first = await read_page(path);
+  const rows = parse_json_array_or_undefined(first, z.unknown());
+  if (rows === void 0 || rows.length < per_page) return first;
+  return await git_gh_exec.exec_gh_api({ path, should_paginate: true });
+}
+var git_gh_etag_read = { read, read_detail, read_listing, settle, slot_of };
+
+// scripts/gh/git-gh-issue-memo.ts
+var FRESH_MS = 1e4;
+var read_by_path = /* @__PURE__ */ new Map();
+function fresh_entry(path, now_ms) {
+  const entry = read_by_path.get(path);
+  return entry !== void 0 && now_ms - entry.at_ms < FRESH_MS ? entry : void 0;
+}
+async function read2(path) {
+  const now_ms = Date.now();
+  const entry = fresh_entry(path, now_ms) ?? { read: git_gh_etag_read.read(path), at_ms: now_ms };
+  read_by_path.set(path, entry);
+  try {
+    return await entry.read;
+  } catch (error) {
+    if (read_by_path.get(path) === entry) read_by_path.delete(path);
+    throw error;
+  }
+}
+function forget() {
+  read_by_path.clear();
+}
+var git_gh_issue_memo = { read: read2, forget, FRESH_MS };
+
+export {
+  git_gh_conditional,
+  git_gh_etag_read,
+  git_gh_issue_memo
+};

package/dist/commands/chunk-V7QOC5NV.js

@@ -0,0 +1,51 @@
+import {
+  observation_ledger_home,
+  observation_ledger_line
+} from "./chunk-N5FT5LYP.js";
+
+// scripts/observations/observation-record.ts
+var FILE_VERDICT = "file";
+var LEDGER_VERDICT = "ledger";
+var REFUSED_VERDICT = "refused";
+var RESERVED_SLUG = "example";
+var RESERVED_REASON = "`k:example` is reserved for the sample in observation-ledger.md";
+var PROMOTING_COUNT = 1;
+function collapsed(field) {
+  return field.replaceAll(/\s+/gu, " ").trim();
+}
+function entry_line(entry, date) {
+  return `- k:${entry.slug} | ${entry.depth} | ${date} | ${collapsed(entry.where)} | ${collapsed(entry.what)}`;
+}
+function refusal_of(entry, line) {
+  if (entry.slug === RESERVED_SLUG) return RESERVED_REASON;
+  return observation_ledger_line.line_reason(line);
+}
+function sightings(ledger, slug) {
+  const prefix = `- k:${slug} |`;
+  return (ledger ?? "").split("\n").filter((line) => line.startsWith(prefix));
+}
+async function assess(request) {
+  const date = observation_ledger_home.ledger_date(request.now);
+  const line = entry_line(request.entry, date);
+  const reason = refusal_of(request.entry, line);
+  if (reason !== void 0) return { verdict: REFUSED_VERDICT, reason };
+  const earlier = sightings(
+    await observation_ledger_home.read(request.checkout),
+    request.entry.slug
+  );
+  const verdict = earlier.length === PROMOTING_COUNT ? FILE_VERDICT : LEDGER_VERDICT;
+  return { verdict, earlier, line };
+}
+async function record(request) {
+  const assessment = await assess(request);
+  if (assessment.verdict === REFUSED_VERDICT) return assessment;
+  const target = await observation_ledger_home.writer_path(request.now, request.checkout);
+  await observation_ledger_home.append(target, [assessment.line]);
+  return { ...assessment, target };
+}
+var observation_record = { assess, record };
+
+export {
+  REFUSED_VERDICT,
+  observation_record
+};