@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-ZLRUHSOP.js

@@ -1,48 +0,0 @@
-import {
-  run_step
-} from "./chunk-YM77CF4D.js";
-
-// scripts/run/run-next.ts
-var ALREADY_DONE_STEP = "Issue is CLOSED \u2014 nothing to run. Verify it against merged code before starting.";
-var KEEP_WORK_STEP = 'Issue is CLOSED but this lane holds uncommitted work \u2014 stash it with `pnpm josh stash:push "<N>: uncommitted work at already-done"` before ending.';
-var LATEST_STEP = "Update dependencies first (latest: required), load the dependency-update skill, then implement.";
-var HUMAN_REVIEW_STEP = "Implement and run the verification gate, then STOP before the commit (needs-human-review).";
-var IMPLEMENT_STEP = "Implement, then run the verification gate (refactor, gate, /code-review).";
-var UNKNOWN_STEP = "State could not be read \u2014 resolve the failure in run:prep before deciding the next step.";
-var STEP_OF = {
-  "already-done": ALREADY_DONE_STEP,
-  "human-review": HUMAN_REVIEW_STEP,
-  implement: IMPLEMENT_STEP,
-  "keep-work": KEEP_WORK_STEP,
-  unknown: UNKNOWN_STEP,
-  "update-deps": LATEST_STEP
-};
-function to_input(parts) {
-  return {
-    state: parts.state?.state,
-    is_human_review: parts.state?.is_human_review ?? false,
-    latest_scope: parts.latest_scope,
-    has_changes: parts.has_changes
-  };
-}
-function next_step(input) {
-  return STEP_OF[run_step.pre_verdict(input)];
-}
-function format_report(parts) {
-  return next_step(to_input(parts));
-}
-var run_next = {
-  ALREADY_DONE_STEP,
-  HUMAN_REVIEW_STEP,
-  IMPLEMENT_STEP,
-  KEEP_WORK_STEP,
-  LATEST_STEP,
-  UNKNOWN_STEP,
-  format_report,
-  next_step,
-  to_input
-};
-
-export {
-  run_next
-};

package/dist/commands/chunk-ZNR75OXP.js

@@ -1,444 +0,0 @@
-import {
-  lane_ledger_pinned_origin
-} from "./chunk-Y2RNUX4W.js";
-import {
-  lane_ledger_kind,
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lane/lane-ledger-tail.ts
-import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
-
-// scripts/lane/lane-ledger-schema.ts
-import { z as z4 } from "zod";
-
-// scripts/lane/lane-ledger-schema-load.ts
-import { z } from "zod";
-var { KIND } = lane_ledger_kind;
-var process_kind_schema = z.object({
-  kind: z.string(),
-  cpu_percent: z.number(),
-  rss_mb: z.number(),
-  footprint_mb: z.number().optional(),
-  count: z.number()
-});
-var load_schema = z.object({
-  kind: z.literal(KIND.LOAD),
-  at: z.string(),
-  load: z.number(),
-  available_mb: z.number().optional(),
-  swapped_mb: z.number().optional(),
-  lanes: z.number().optional(),
-  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
-  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
-  processes: z.array(process_kind_schema).optional(),
-  // The resident apps' summed size (`lane_process_load.RESIDENT_APPS`, joshuafolkken/kit#5658).
-  resident_mb: z.number().optional(),
-  // The host's sleep since boot (`lane-load.ts`, joshuafolkken/kit#7026).
-  slept_ms: z.number().optional(),
-  // The boot and last-wake instants, epoch ms (`kern.boottime`, `kern.waketime`).
-  booted_ms: z.number().optional(),
-  woke_ms: z.number().optional()
-});
-var lane_ledger_schema_load = { load_schema };
-
-// scripts/lane/lane-ledger-schema-offer.ts
-import { z as z2 } from "zod";
-var { KIND: KIND2 } = lane_ledger_kind;
-var exclusion_schema = z2.object({ issue: z2.number(), reason: z2.string() });
-var offer_schema = z2.object({
-  kind: z2.literal(KIND2.OFFER),
-  at: z2.string(),
-  verdict: z2.string(),
-  seen: z2.array(z2.number()),
-  started: z2.array(z2.number()),
-  excluded: z2.array(exclusion_schema),
-  is_unchanged: z2.boolean()
-});
-var lane_ledger_schema_offer = { offer_schema };
-
-// scripts/lane/lane-ledger-schema-ship.ts
-import { z as z3 } from "zod";
-var { KIND: KIND3 } = lane_ledger_kind;
-var early_push_schema = z3.object({
-  kind: z3.literal(KIND3.EARLY_PUSH),
-  at: z3.string(),
-  issue: z3.number().optional(),
-  source: z3.enum(["review", "ship"]),
-  result: z3.string()
-});
-var stop_schema = z3.object({
-  kind: z3.literal(KIND3.STOP),
-  at: z3.string(),
-  issue: z3.number(),
-  reason: z3.string(),
-  cause: z3.string().optional(),
-  preconditions: z3.array(z3.string()).optional(),
-  findings: z3.array(z3.string()).optional(),
-  base: z3.string().optional(),
-  checks: z3.array(z3.string()).optional()
-});
-var chain_schema = z3.object({
-  kind: z3.literal(KIND3.CHAIN),
-  at: z3.string(),
-  issue: z3.number(),
-  elapsed_ms: z3.number(),
-  join: z3.boolean(),
-  stage: z3.string().optional(),
-  reason: z3.enum(["exit", "hold"]).optional()
-});
-var unplanned_notice_schema = z3.object({
-  kind: z3.literal(KIND3.UNPLANNED_NOTICE),
-  at: z3.string(),
-  issue: z3.number(),
-  files: z3.array(z3.string())
-});
-var ship_lap_schema = z3.object({
-  kind: z3.literal(KIND3.SHIP_LAP),
-  at: z3.string(),
-  issue: z3.number(),
-  stage: z3.string(),
-  step: z3.string(),
-  elapsed_ms: z3.number(),
-  fallback: z3.string().optional(),
-  runs: z3.number().optional(),
-  rerun: z3.string().optional(),
-  reused_tree: z3.string().optional(),
-  is_reused: z3.boolean().optional(),
-  named: z3.number().optional(),
-  unsplit: z3.string().optional()
-});
-var counts_schema = z3.object({ files: z3.number(), lines: z3.number() });
-var size_schema = z3.object({
-  kind: z3.literal(KIND3.SIZE),
-  at: z3.string(),
-  issue: z3.number(),
-  declared: counts_schema,
-  actual: counts_schema,
-  missed: z3.boolean().optional()
-});
-var lane_ledger_schema_ship = {
-  chain_schema,
-  early_push_schema,
-  ship_lap_schema,
-  size_schema,
-  stop_schema,
-  unplanned_notice_schema
-};
-
-// scripts/lane/lane-ledger-schema.ts
-var { KIND: KIND4 } = lane_ledger_kind;
-var { early_push_schema: early_push_schema2, ship_lap_schema: ship_lap_schema2, size_schema: size_schema2, stop_schema: stop_schema2, unplanned_notice_schema: unplanned_notice_schema2 } = lane_ledger_schema_ship;
-var { pinned_origin_schema } = lane_ledger_pinned_origin;
-var { load_schema: load_schema2 } = lane_ledger_schema_load;
-var merge_schema = z4.object({ kind: z4.literal(KIND4.MERGE), at: z4.string(), issue: z4.number() });
-var check_schema = z4.object({
-  label: z4.string(),
-  elapsed_ms: z4.number(),
-  is_passed: z4.boolean(),
-  is_reused: z4.boolean().optional(),
-  // The CPU milliseconds the check's process tree spent, so a core weight can be re-measured from
-  // the ledger (joshuafolkken/kit#4362). Absent where the gate could not read it (off macOS).
-  cpu_ms: z4.number().optional(),
-  // Why the unit leg ran the whole suite instead of the related tests — a stable kind, never the
-  // file it names (joshuafolkken/kit#4397). Absent when it narrowed, and on every other check.
-  fallback: z4.string().optional(),
-  // The unit leg's since-green no-op: nothing moved, so it ran no test (joshuafolkken/kit#4457).
-  is_unmoved: z4.boolean().optional(),
-  // The width the check asked the core budget for, the width it ran at and how long it waited, so a
-  // unit claim's wait for room is read per run (joshuafolkken/kit#4451). Absent on a check that
-  // claimed none — a reused one, or one inside another gate's claim.
-  claim: z4.object({ requested: z4.number(), granted: z4.number(), waited_ms: z4.number() }).optional()
-});
-var gate_schema = z4.object({
-  kind: z4.literal(KIND4.GATE),
-  at: z4.string(),
-  elapsed_ms: z4.number(),
-  is_passed: z4.boolean(),
-  // The unit suite's own duration, present when this gate ran it — the one
-  // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
-  unit_ms: z4.number().optional(),
-  // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
-  // whichever was higher. Absent when the machine could not be read.
-  external_cores: z4.number().optional(),
-  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
-  // on. A reused check started no process: its row says so, and its zero is no timing.
-  checks: z4.array(check_schema).optional(),
-  // A gate that reused a green record for this tree and base and started no check: counted, never
-  // timed (joshuafolkken/kit#4397).
-  is_reused: z4.boolean().optional(),
-  // The lane the gate ran in, so `josh lane:breakdown` puts its checks under the lane's ship gate;
-  // absent outside a lane and on a row written before it (joshuafolkken/kit#5319).
-  issue: z4.number().optional()
-});
-var dispatch_schema = z4.object({
-  kind: z4.literal(KIND4.DISPATCH),
-  at: z4.string(),
-  issue: z4.number()
-});
-var stage_schema = z4.object({
-  kind: z4.literal(KIND4.STAGE),
-  at: z4.string(),
-  stage: z4.string(),
-  elapsed_ms: z4.number(),
-  issue: z4.number().optional(),
-  last_check: z4.string().optional(),
-  check_ms: z4.record(z4.string(), z4.number()).optional(),
-  has_rerun: z4.literal(true).optional()
-});
-var overlap_schema = z4.object({
-  kind: z4.literal(KIND4.OVERLAP),
-  at: z4.string(),
-  issue: z4.number(),
-  lanes: z4.array(z4.number()),
-  paths: z4.array(z4.string()),
-  waited_ms: z4.number(),
-  is_cleared: z4.boolean()
-});
-var held_schema = z4.object({
-  kind: z4.literal(KIND4.HELD),
-  at: z4.string(),
-  reason: z4.string(),
-  waiting: z4.array(z4.number()).optional()
-});
-var released_schema = z4.object({ kind: z4.literal(KIND4.RELEASED), at: z4.string() });
-var lane_state_schema = z4.object({
-  kind: z4.literal(KIND4.LANE_STATE),
-  at: z4.string(),
-  issue: z4.number(),
-  state: z4.enum(["paused", "running"])
-});
-var round_one_schema = z4.object({
-  kind: z4.literal(KIND4.ROUND_ONE),
-  at: z4.string(),
-  issue: z4.number(),
-  verdict: z4.string()
-});
-var round_two_schema = z4.object({
-  kind: z4.literal(KIND4.ROUND_TWO),
-  at: z4.string(),
-  issue: z4.number(),
-  verdict: z4.string(),
-  code: z4.string()
-});
-var offerable_schema = z4.object({
-  kind: z4.literal(KIND4.OFFERABLE),
-  at: z4.string(),
-  is_offerable: z4.boolean()
-});
-var core_wait_schema = z4.object({
-  kind: z4.literal(KIND4.CORE_WAIT),
-  at: z4.string(),
-  command: z4.string(),
-  waited_ms: z4.number(),
-  issue: z4.number().optional()
-});
-var unit_file_schema = z4.object({ file: z4.string(), elapsed_ms: z4.number() });
-var unit_files_schema = z4.object({
-  kind: z4.literal(KIND4.UNIT_FILES),
-  at: z4.string(),
-  files: z4.array(unit_file_schema)
-});
-var test_related_schema = z4.object({
-  reused: z4.number().optional(),
-  reuse_missed: z4.number().optional(),
-  reuse_reason: z4.string().optional(),
-  reuse_elapsed_ms: z4.number().optional(),
-  select_elapsed_ms: z4.number().optional(),
-  kind: z4.literal(KIND4.TEST_RELATED),
-  at: z4.string(),
-  issue: z4.number().optional(),
-  scope: z4.string(),
-  changed: z4.number(),
-  synced: z4.number(),
-  since_map: z4.number(),
-  readers: z4.number(),
-  test_files: z4.number().optional(),
-  trigger_files: z4.array(z4.string()).optional(),
-  // The changed files past the reach cap, run by their direct importers alone (joshuafolkken/kit#5532).
-  over_cap: z4.number().optional(),
-  // The widest of them in the run's own change, the hub that put the run past the cap
-  // (joshuafolkken/kit#5699); absent when main or the map's tree brought them all (joshuafolkken/kit#5756).
-  over_cap_hub: z4.string().optional(),
-  // The branch change read beside the run, by half and by base (joshuafolkken/kit#6982).
-  branch_tracked: z4.number().optional(),
-  branch_untracked: z4.number().optional(),
-  branch_base: z4.enum(["merge_base", "fallback"]).optional(),
-  // `changed` split by whether that branch change holds the file (joshuafolkken/kit#7066).
-  changed_in_branch: z4.number().optional(),
-  changed_off_branch: z4.number().optional(),
-  elapsed_ms: z4.number()
-});
-var test_pinned_probe_schema = z4.object({
-  file: z4.string(),
-  tests: z4.number().optional(),
-  elapsed_ms: z4.number(),
-  pinned_by: z4.literal("type-check").optional()
-});
-var test_pinned_schema = z4.object({
-  kind: z4.literal(KIND4.TEST_PINNED),
-  at: z4.string(),
-  issue: z4.number().optional(),
-  held: z4.number(),
-  rewired: z4.number().optional(),
-  over_cap: z4.number().optional(),
-  probes: z4.array(test_pinned_probe_schema),
-  elapsed_ms: z4.number(),
-  origin: pinned_origin_schema.optional(),
-  discarded: z4.boolean().optional()
-});
-var split_notice_schema = z4.object({
-  kind: z4.literal(KIND4.SPLIT_NOTICE),
-  at: z4.string(),
-  issue: z4.number(),
-  files: z4.number(),
-  lines: z4.number(),
-  reason: z4.enum(["files", "hunks", "lines", "hub", "budget"]).optional()
-});
-var split_filed_schema = z4.object({
-  kind: z4.literal(KIND4.SPLIT_FILED),
-  at: z4.string(),
-  issue: z4.number(),
-  child: z4.string()
-});
-var push_miss_schema = z4.object({
-  kind: z4.literal(KIND4.PUSH_MISS),
-  at: z4.string(),
-  scope: z4.enum(["whole", "related"]),
-  reason: z4.string()
-});
-var limit_schema = z4.object({ kind: z4.literal(KIND4.LIMIT), at: z4.string(), limit: z4.number() });
-var entry_schema = z4.discriminatedUnion("kind", [
-  early_push_schema2,
-  merge_schema,
-  gate_schema,
-  load_schema2,
-  dispatch_schema,
-  stage_schema,
-  stop_schema2,
-  lane_ledger_schema_ship.chain_schema,
-  overlap_schema,
-  held_schema,
-  released_schema,
-  round_one_schema,
-  round_two_schema,
-  offerable_schema,
-  lane_ledger_schema_offer.offer_schema,
-  core_wait_schema,
-  unit_files_schema,
-  test_related_schema,
-  test_pinned_schema,
-  split_notice_schema,
-  split_filed_schema,
-  unplanned_notice_schema2,
-  lane_state_schema,
-  push_miss_schema,
-  ship_lap_schema2,
-  size_schema2,
-  limit_schema
-]);
-var lane_ledger_schema = { entry_schema };
-
-// scripts/lane/lane-ledger-tail.ts
-var { entry_schema: entry_schema2 } = lane_ledger_schema;
-var { LINE_SEPARATOR } = lane_ledger_write;
-var EMPTY = [];
-var { O_NOFOLLOW, O_RDONLY } = constants;
-var READ_FLAGS = O_RDONLY | O_NOFOLLOW;
-function parse_line(line) {
-  return entry_schema2.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function is_present(entry) {
-  return entry !== void 0;
-}
-function parse_text(text) {
-  return text.split(LINE_SEPARATOR).map((line) => parse_line(line.trim())).filter(is_present);
-}
-function snapshot_of(stat) {
-  return { ino: stat.ino, size: stat.size, mtime_ms: stat.mtimeMs };
-}
-function is_unchanged(previous, snapshot) {
-  const { ino, size, mtime_ms } = snapshot;
-  return previous.ino === ino && previous.size === size && previous.mtime_ms === mtime_ms;
-}
-function base_of(previous, snapshot) {
-  if (previous === void 0) return void 0;
-  return previous.ino === snapshot.ino && previous.size < snapshot.size ? previous : void 0;
-}
-function grow(base, snapshot, from, bytes) {
-  const end = bytes.lastIndexOf(LINE_SEPARATOR) + 1;
-  const lines = [...base?.lines ?? EMPTY, ...parse_text(bytes.toString("utf8", 0, end))];
-  const fragment = parse_text(bytes.toString("utf8", end));
-  const entries = fragment.length === 0 ? lines : [...lines, ...fragment];
-  return { ...snapshot, size: from + bytes.length, offset: from + end, lines, entries };
-}
-function next_tail(descriptor, snapshot, previous) {
-  if (previous !== void 0 && is_unchanged(previous, snapshot)) return previous;
-  const base = base_of(previous, snapshot);
-  const from = base?.offset ?? 0;
-  const bytes = Buffer.alloc(snapshot.size - from);
-  const length = readSync(descriptor, bytes, 0, bytes.length, from);
-  return grow(base, snapshot, from, bytes.subarray(0, length));
-}
-function read_tail(path, previous) {
-  try {
-    if (!stamp_file.is_own_regular_file(path)) return void 0;
-    const descriptor = openSync(path, READ_FLAGS);
-    try {
-      return next_tail(descriptor, snapshot_of(fstatSync(descriptor)), previous);
-    } finally {
-      closeSync(descriptor);
-    }
-  } catch {
-    return void 0;
-  }
-}
-var tails = /* @__PURE__ */ new Map();
-function read(path) {
-  const tail = read_tail(path, tails.get(path));
-  if (tail === void 0) {
-    tails.delete(path);
-    return EMPTY;
-  }
-  tails.set(path, tail);
-  return tail.entries;
-}
-var lane_ledger_tail = { read };
-
-// scripts/lane/lane-ledger.ts
-function read_entries(path) {
-  return lane_ledger_tail.read(path);
-}
-var {
-  CI_WAIT_STAGE,
-  CODERABBIT_RATE_LIMIT_STAGE,
-  CODERABBIT_RETRIGGER_STAGE,
-  CODERABBIT_WAIT_STAGE,
-  KIND: KIND5,
-  PRE_DETACH_STAGE,
-  ROUND_ONE_REUSED,
-  target,
-  target_of
-} = lane_ledger_write;
-var lane_ledger = {
-  CI_WAIT_STAGE,
-  CODERABBIT_RATE_LIMIT_STAGE,
-  CODERABBIT_RETRIGGER_STAGE,
-  CODERABBIT_WAIT_STAGE,
-  KIND: KIND5,
-  PRE_DETACH_STAGE,
-  ROUND_ONE_REUSED,
-  read_entries,
-  target,
-  target_of
-};
-
-export {
-  lane_ledger
-};

package/dist/commands/chunk-ZSOR4ISJ.js

@@ -1,75 +0,0 @@
-import {
-  capped_output
-} from "./chunk-2CXT6MBR.js";
-import {
-  entry_read_set
-} from "./chunk-SZG5HDNP.js";
-import {
-  document_section
-} from "./chunk-NDWZTWXV.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-
-// scripts/document/document-section-cli.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/document/document-section-cli.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 FAILURE_EXIT_CODE = 1;
-var FILE_ARGUMENT = 0;
-var HEADING_ARGUMENT = 1;
-var NO_CANDIDATE = 0;
-var USAGE = 'Usage: josh doc:section <file.md> "<heading>"';
-var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
-function candidates_under(directory, name) {
-  return [path.resolve(directory, name), entry_read_set.document_path(directory, name)];
-}
-function resolve_document(name, root = process.cwd(), package_directory = PACKAGE_DIRECTORY) {
-  const named = path.resolve(root, name);
-  const candidates = [...candidates_under(root, name), ...candidates_under(package_directory, name)];
-  return candidates.find((candidate) => existsSync(candidate)) ?? named;
-}
-function report_missing(markdown, heading) {
-  const near = document_section.candidates(markdown, heading);
-  const listed = near.length > NO_CANDIDATE ? near : document_section.titles(markdown);
-  console.error(`No single section matches ${JSON.stringify(heading)}. Headings it could mean:`);
-  for (const title of listed) console.error(`  ${title}`);
-  return FAILURE_EXIT_CODE;
-}
-function print_section(markdown, heading, root) {
-  const found = document_section.section(markdown, heading);
-  if (found === void 0) return report_missing(markdown, heading);
-  capped_output.capped_print(found.text, heading, root);
-  return 0;
-}
-function read_named(name, root) {
-  const file_path = resolve_document(name, root);
-  const markdown = document_section.read_optional(file_path);
-  if (markdown === void 0) console.error(`Cannot read ${file_path}`);
-  return markdown;
-}
-function section_text(name, heading, root = process.cwd()) {
-  const markdown = document_section.read_optional(resolve_document(name, root));
-  return markdown === void 0 ? void 0 : document_section.section(markdown, heading)?.text;
-}
-function run(argv, root = process.cwd()) {
-  const name = argv[FILE_ARGUMENT];
-  const heading = argv[HEADING_ARGUMENT];
-  if (name === void 0 || heading === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  const markdown = read_named(name, root);
-  return markdown === void 0 ? FAILURE_EXIT_CODE : print_section(markdown, heading, root);
-}
-var document_section_cli = { FAILURE_EXIT_CODE, USAGE, resolve_document, run, section_text };
-
-export {
-  document_section_cli
-};

package/dist/commands/chunk-ZVAIIHBE.js

@@ -1,63 +0,0 @@
-import {
-  durable_state
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  agent_provider
-} from "./chunk-JQXPLMCO.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/carry/run-carry-ended.ts
-import path from "node:path";
-import { z } from "zod";
-var ENDED_PREFIX = durable_state.PREFIX.ENDED;
-var TRANSCRIPT_SUFFIX = ".jsonl";
-var ended_run_schema = z.object({
-  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional(),
-  invocation: z.string(),
-  started_at: z.string(),
-  ended_at: z.string(),
-  stopped: z.string().optional(),
-  session: z.string().optional()
-});
-function ended_path(git_directory) {
-  return durable_state.path(ENDED_PREFIX, git_directory);
-}
-function session_of(transcript) {
-  return transcript === void 0 ? void 0 : path.basename(transcript, TRANSCRIPT_SUFFIX);
-}
-function stop_of(transcript, stopped) {
-  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
-}
-function record_ended(target, read, now = /* @__PURE__ */ new Date(), stopped) {
-  if (read.kind !== "carried") return;
-  const { invocation, started_at, owner_transcript } = read.carry;
-  const ended_at = now.toISOString();
-  stamp_file.replace_stamp(target, {
-    ...read.carry.scheduler_provider && { scheduler_provider: read.carry.scheduler_provider },
-    invocation,
-    started_at,
-    ended_at,
-    ...stop_of(owner_transcript, stopped)
-  });
-}
-function parse_ended(raw) {
-  return json_value.parse_with(raw, ended_run_schema);
-}
-function read_ended(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  return raw === void 0 ? void 0 : parse_ended(raw);
-}
-function has_ended(target, started_at) {
-  const ended = read_ended(target);
-  return ended !== void 0 && ended.started_at === started_at;
-}
-var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
-
-export {
-  run_carry_ended
-};

package/dist/commands/chunk-ZYFHYQA7.js

@@ -1,51 +0,0 @@
-import {
-  observation_ledger_home,
-  observation_ledger_line
-} from "./chunk-WWVYEHQT.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
-};