@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-QTQAI2M2.js

@@ -0,0 +1,179 @@
+import {
+  agent_argv
+} from "./chunk-L7MDU6D7.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  run_headless
+} from "./chunk-Q4ULMZAS.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  durable_state,
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/backlog/backlogrun-launch.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var LAUNCH_PREFIX = durable_state.PREFIX.BACKLOGRUN_LAUNCH;
+var LOG_PREFIX = durable_state.PREFIX.BACKLOGRUN_LOG;
+var LOG_SUFFIX = ".log";
+var launch_schema = z.object({
+  pid: z.number(),
+  start: z.string().optional(),
+  session: z.string().optional(),
+  // What the parent was started to run and when, so `run:board` has a run to draw and a clock to count
+  // before the parent claims the carry record. Absent on a record an earlier version wrote.
+  invocation: z.string().optional(),
+  started_at: z.string().optional(),
+  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional()
+});
+function launch_path(git_directory) {
+  return durable_state.path(LAUNCH_PREFIX, git_directory);
+}
+function log_path(git_directory) {
+  return durable_state.path(LOG_PREFIX, git_directory, LOG_SUFFIX);
+}
+function read_launch(target) {
+  return json_value.parse_with(stamp_file.read_stamp_text(target) ?? "", launch_schema);
+}
+function is_launch_live(record) {
+  if (record === void 0) return false;
+  return process_identity.is_same_process(record.pid, record.start) !== false;
+}
+function is_carry_live(read) {
+  return read.kind === "carried" && run_carry.is_owner_live(read.carry);
+}
+function is_running(git_directory) {
+  if (is_carry_live(run_carry.read_carry(run_carry.carry_path(git_directory)))) return true;
+  return is_launch_live(read_launch(launch_path(git_directory)));
+}
+function chosen_environment(provider, environment = process.env) {
+  return {
+    ...environment,
+    ...agent_session_environment.removed_environment(environment),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+}
+function session_for(provider) {
+  return provider === "anthropic" ? randomUUID() : void 0;
+}
+function argv_of(invocation, provider, worktree, session) {
+  const environment = chosen_environment(provider);
+  const resolved = agent_role_profile.resolve(agent_role_profile.SCHEDULER, environment);
+  if (resolved.kind === "rejected") return resolved;
+  return agent_argv.with_profile_in(invocation, resolved.profile, worktree, session);
+}
+function note_to_stderr(note) {
+  console.error(`backlogrun: ${note}`);
+}
+function record_launch(git_directory, launch) {
+  const now = /* @__PURE__ */ new Date();
+  const identity = process_identity.read_start(launch.pid);
+  const record = { ...launch, start: identity, started_at: now.toISOString() };
+  stamp_file.replace_stamp(launch_path(git_directory), record);
+  run_event_setup.emit_in(git_directory, run_event_setup.STAGE.STARTING, now);
+}
+function live_launch(git_directory) {
+  const record = read_launch(launch_path(git_directory));
+  return is_launch_live(record) ? record : void 0;
+}
+function pending_launch(git_directory) {
+  const { invocation, started_at, scheduler_provider } = live_launch(git_directory) ?? {};
+  if (invocation === void 0 || started_at === void 0) return void 0;
+  return { invocation, started_at, ...scheduler_provider && { scheduler_provider } };
+}
+function started_for(git_directory, owner_pid) {
+  const record = live_launch(git_directory);
+  if (record?.started_at === void 0 || record.pid !== owner_pid) return void 0;
+  const started_ms = Date.parse(record.started_at);
+  return Number.isNaN(started_ms) ? void 0 : new Date(started_ms);
+}
+function signal_parent(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    note_to_stderr(`process ${String(pid)} could not be signalled; its launch record is removed.`);
+  }
+}
+function running_parent(git_directory) {
+  return live_launch(git_directory)?.pid;
+}
+function stop_parent(git_directory) {
+  const record = live_launch(git_directory);
+  stamp_file.remove_stamp(launch_path(git_directory));
+  if (record === void 0) return void 0;
+  signal_parent(record.pid);
+  return record.pid;
+}
+function spawn_parent(argv, provider, target) {
+  const environment = {
+    ...run_headless.environment(),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+  const log = log_path(target.git_directory);
+  return detached_launch.launch(
+    {
+      argv: argv.argv,
+      cwd: target.worktree,
+      env: environment,
+      log_path: log,
+      profile: argv.profile
+    },
+    note_to_stderr
+  );
+}
+function start(invocation, provider, target) {
+  const session = session_for(provider);
+  const built = argv_of(invocation, provider, target.worktree, session);
+  if (built.kind === "rejected") return { kind: "failed", note: built.note };
+  const result = spawn_parent(built, provider, target);
+  if (result.kind === "failed") return result;
+  record_launch(target.git_directory, {
+    pid: result.pid,
+    session,
+    invocation,
+    scheduler_provider: built.profile.provider
+  });
+  const launched = { pid: result.pid, session, log_path: log_path(target.git_directory) };
+  return { kind: "launched", launched };
+}
+var backlogrun_launch = {
+  argv_of,
+  chosen_environment,
+  is_running,
+  launch_path,
+  log_path,
+  pending_launch,
+  running_parent,
+  start,
+  started_for,
+  stop_parent
+};
+
+export {
+  backlogrun_launch
+};

package/dist/commands/chunk-QTVVFV4Q.js

@@ -0,0 +1,127 @@
+import {
+  git_prompt
+} from "./chunk-EWXXEGXL.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  SEPARATOR_LINE
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/git/git-issue.ts
+var ISSUE_NUMBER_PATTERN = /#(\d+)$/u;
+function extract_issue_number(input) {
+  const match = ISSUE_NUMBER_PATTERN.exec(input);
+  if (match === null) {
+    throw new Error('Invalid format: Issue number not found (e.g., "title #52")');
+  }
+  return match[1] ?? "";
+}
+function extract_issue_title(input) {
+  const title = input.replace(/#\d+$/u, "").trim();
+  if (title.length === 0) {
+    throw new Error("Invalid format: Issue title is required");
+  }
+  return title;
+}
+function normalize_title_for_branch(title) {
+  const replaced = title.toLowerCase().normalize("NFKD").replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/(^-)|(-$)/gu, "");
+  return replaced.length === 0 ? "update" : replaced;
+}
+function create_branch_name(issue_number, title) {
+  return `${issue_number}-${normalize_title_for_branch(title)}`;
+}
+function parse_issue_input(input) {
+  const trimmed_input = input.trim();
+  const issue_number = extract_issue_number(trimmed_input);
+  const title = extract_issue_title(trimmed_input);
+  const branch_name = create_branch_name(issue_number, title);
+  const commit_message = `${title} ${issue_cite.plain_for("github", issue_number)}`;
+  return {
+    title,
+    number: issue_number,
+    branch_name,
+    commit_message
+  };
+}
+var BRANCH_NUMBER_PATTERN = /^(\d+)-(.+)$/u;
+function is_lane_branch(branch_name, issue_number) {
+  return branch_name === lane_paths.lane_branch(issue_number);
+}
+var EXAMPLE_ISSUE_NUMBER = "42";
+function argument_hint(issue_number) {
+  return `Provide an issue argument like "title ${issue_cite.plain_for("github", issue_number)}".`;
+}
+async function lane_issue_title(branch_name, issue_number) {
+  const title = await git_gh_issue_read.issue_get_title(issue_number);
+  if (title === void 0) {
+    throw new Error(
+      `Cannot read the title of issue ${session_cite.issue(issue_number)} for lane branch "${branch_name}". ${argument_hint(issue_number)}`
+    );
+  }
+  return title;
+}
+function branch_derivation_error(branch_name) {
+  return `Cannot derive issue info from branch "${branch_name}" in non-interactive mode. ${argument_hint(EXAMPLE_ISSUE_NUMBER)}`;
+}
+function branch_number(branch_name) {
+  return BRANCH_NUMBER_PATTERN.exec(branch_name)?.[1];
+}
+async function derive_issue_input_from_branch(branch_name) {
+  const match = BRANCH_NUMBER_PATTERN.exec(branch_name);
+  if (match === null) throw new Error(branch_derivation_error(branch_name));
+  const [, number = "", slug = ""] = match;
+  const title = is_lane_branch(branch_name, number) ? await lane_issue_title(branch_name, number) : slug.replaceAll("-", " ").trim();
+  return `${title} ${issue_cite.plain_for("github", number)}`;
+}
+async function derive_from_branch(branch_name) {
+  const parsed = parse_issue_input(await derive_issue_input_from_branch(branch_name));
+  return { ...parsed, branch_name };
+}
+function display_issue_info(issue_info) {
+  console.info("");
+  console.info("\u{1F4CB} Issue Information");
+  console.info(SEPARATOR_LINE);
+  console.info(`  Issue Title: ${issue_info.title}`);
+  console.info(`  Issue Number: ${issue_info.number}`);
+  console.info(`  Branch Name: ${issue_info.branch_name}`);
+  console.info(`  Commit Message: ${issue_info.commit_message}`);
+  console.info(SEPARATOR_LINE);
+}
+async function get_and_display(cli_input) {
+  const input = cli_input ?? await git_prompt.get_issue_info();
+  const issue_info = parse_issue_input(input);
+  display_issue_info(issue_info);
+  return issue_info;
+}
+async function resolve_and_display(input) {
+  if (input.cli_input !== void 0) return await get_and_display(input.cli_input);
+  if (input.is_non_interactive) {
+    const issue_info = await derive_from_branch(input.current_branch);
+    display_issue_info(issue_info);
+    return issue_info;
+  }
+  return await get_and_display();
+}
+var git_issue = {
+  get_and_display,
+  resolve_and_display,
+  derive_from_branch,
+  // The pure halves of the two resolutions above, read by `git-preflight.ts` before anything changes.
+  parse: parse_issue_input,
+  branch_number,
+  branch_derivation_error
+};
+
+export {
+  git_issue
+};

package/dist/commands/chunk-QX2EMUXV.js

@@ -0,0 +1,102 @@
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/git/changed-file-scope.ts
+import path from "node:path";
+var UNREADABLE_REASON = "the changed files could not be read";
+var LISTED_FILE_LIMIT = 10;
+async function repository_root_or_cwd() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return process.cwd();
+  }
+}
+async function read_changed_files(root) {
+  try {
+    const relative_paths = await changed_paths.read_changed_paths(false);
+    return relative_paths.map((relative) => path.join(root, relative));
+  } catch {
+    return void 0;
+  }
+}
+function select_files(paths, inputs) {
+  return paths.filter(
+    (file_path) => inputs.is_selectable(file_path) && inputs.is_present(file_path)
+  );
+}
+function all_scope(reason) {
+  return { mode: "all", files: [], reason };
+}
+function resolve_scope(paths, inputs) {
+  if (paths === void 0) return all_scope(UNREADABLE_REASON);
+  const files = select_files(paths, inputs);
+  if (files.length === 0) return all_scope(inputs.nothing_reason);
+  return { mode: "related", files, reason: `${String(files.length)} changed file(s)` };
+}
+function format_file_list(files, root) {
+  const listed = files.slice(0, LISTED_FILE_LIMIT).map((file) => `  - ${path.relative(root, file)}`);
+  const hidden = files.length - listed.length;
+  if (hidden > 0) listed.push(`  \u2026 and ${String(hidden)} more`);
+  return listed.join("\n");
+}
+function describe_scope(scope, root, vocabulary) {
+  if (scope.mode === "all") {
+    return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.fallback_suffix}.`;
+  }
+  return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.narrowed_suffix}.
+${format_file_list(scope.files, root)}`;
+}
+var ARGV_START = 2;
+var FLAG_PREFIX = "-";
+function is_flag(argument) {
+  return argument.startsWith(FLAG_PREFIX);
+}
+function explicit_files_of(command_arguments) {
+  return command_arguments.filter((argument) => !is_flag(argument));
+}
+function flags_of(command_arguments) {
+  return command_arguments.filter((argument) => is_flag(argument));
+}
+async function resolve_command_scope(request) {
+  const explicit_files = explicit_files_of(request.command_arguments);
+  if (explicit_files.length === 0) {
+    return resolve_scope(await read_changed_files(request.root), request.inputs);
+  }
+  return resolve_scope(
+    explicit_files.map((file) => path.resolve(file)),
+    request.inputs
+  );
+}
+function report_unusable_arguments(command_arguments, scope, label) {
+  const narrowed = new Set(scope.files);
+  const unusable = explicit_files_of(command_arguments).filter(
+    (file) => !narrowed.has(path.resolve(file))
+  );
+  if (unusable.length === 0) return;
+  process.stdout.write(`${label}: ignored \u2014 not a file this check reads: ${unusable.join(" ")}
+`);
+}
+var changed_file_scope = {
+  ARGV_START,
+  LISTED_FILE_LIMIT,
+  UNREADABLE_REASON,
+  describe_scope,
+  flags_of,
+  format_file_list,
+  is_flag,
+  read_changed_files,
+  report_unusable_arguments,
+  repository_root_or_cwd,
+  resolve_command_scope,
+  resolve_scope,
+  select_files
+};
+
+export {
+  changed_file_scope
+};

package/dist/commands/chunk-QXBOECGL.js

@@ -0,0 +1,272 @@
+import {
+  LEDGER_FILE_EXTENSION,
+  LEGACY_LEDGER_FILE,
+  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
+  LEGACY_OBSERVATION_LEDGER_PATHS,
+  MIGRATION_CLAIM_SUFFIX,
+  OBSERVATION_LEDGER_DIRECTORY,
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/observations/observation-ledger-line.ts
+var KEY_PREFIX = "- k:";
+var FIELD_SEPARATOR = " | ";
+var FIELD_COUNT = 5;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var DEPTH_PATTERN = /^d[1-9]\d*$/u;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+var SLUG_REASON = "the slug must be lowercase words joined by `-`";
+var DEPTH_REASON = "the depth must be `d1` or higher (never `d0`)";
+var DATE_REASON = "the date must be `YYYY-MM-DD`";
+var WHERE_REASON = "the `where` field is empty";
+var WHAT_REASON = "the `what` field is empty";
+function is_ledger_entry_line(line) {
+  return line.trimStart().startsWith(KEY_PREFIX);
+}
+function slug_of(first_field) {
+  return first_field.trimStart().slice(KEY_PREFIX.length);
+}
+function is_present(field = "") {
+  return field.trim().length > 0;
+}
+function matches(pattern, field = "") {
+  return pattern.test(field);
+}
+function slug_ok(key_field = "") {
+  return SLUG_PATTERN.test(slug_of(key_field));
+}
+function field_reason(fields) {
+  const [key_field, depth, date, where, what] = fields;
+  const checks = [
+    [slug_ok(key_field), SLUG_REASON],
+    [matches(DEPTH_PATTERN, depth), DEPTH_REASON],
+    [matches(DATE_PATTERN, date), DATE_REASON],
+    [is_present(where), WHERE_REASON],
+    [is_present(what), WHAT_REASON]
+  ];
+  return checks.find(([is_valid]) => !is_valid)?.[1];
+}
+function line_reason(line) {
+  const fields = line.split(FIELD_SEPARATOR);
+  if (fields.length !== FIELD_COUNT) {
+    return `expected ${String(FIELD_COUNT)} fields separated by " | " (a \`|\` in the last field is not allowed)`;
+  }
+  return field_reason(fields);
+}
+function broken_ledger_lines(content) {
+  return content.split("\n").filter((line) => is_ledger_entry_line(line)).map((line) => ({ line, reason: line_reason(line) })).filter((entry) => entry.reason !== void 0);
+}
+function missing_lines(candidates, ledger) {
+  const present = new Set(ledger.split("\n"));
+  return candidates.filter((line) => !present.has(line));
+}
+var observation_ledger_line = {
+  broken_ledger_lines,
+  is_ledger_entry_line,
+  line_reason,
+  missing_lines
+};
+
+// scripts/observations/observation-ledger-home.ts
+import { appendFile, mkdir, readdir, readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/observations/observation-ledger-migrate.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmdirSync,
+  rmSync
+} from "node:fs";
+import path from "node:path";
+var NEWLINE = "\n";
+function claim_path(legacy) {
+  return `${legacy}.${String(process.pid)}${MIGRATION_CLAIM_SUFFIX}`;
+}
+function claim(from, to) {
+  try {
+    renameSync(from, to);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function is_stale_claim(name, legacy_name) {
+  const prefix = `${legacy_name}.`;
+  if (!name.startsWith(prefix) || !name.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
+  const pid = Number(name.slice(prefix.length, -MIGRATION_CLAIM_SUFFIX.length));
+  return Number.isSafeInteger(pid) && !process_identity.is_present_pid(pid);
+}
+function stale_claims(legacy) {
+  const directory = path.dirname(legacy);
+  try {
+    return readdirSync(directory).filter((name) => is_stale_claim(name, path.basename(legacy))).map((name) => path.join(directory, name));
+  } catch {
+    return [];
+  }
+}
+function terminated(content) {
+  return content.length === 0 || content.endsWith(NEWLINE) ? content : `${content}${NEWLINE}`;
+}
+function carried(content, ledger) {
+  if (ledger === void 0) return terminated(content);
+  const lines = content.split(NEWLINE).filter((line) => line.length > 0);
+  const missing = observation_ledger_line.missing_lines(lines, ledger);
+  return missing.length === 0 ? "" : `${missing.join(NEWLINE)}${NEWLINE}`;
+}
+function absorb(claimed, target) {
+  mkdirSync(path.dirname(target), { recursive: true });
+  appendFileSync(
+    target,
+    carried(readFileSync(claimed, "utf8"), file_reader.read_if_readable(target)),
+    "utf8"
+  );
+  rmSync(claimed);
+}
+function absorb_stale(legacy, target) {
+  let count = 0;
+  for (const stale of stale_claims(legacy)) {
+    const claimed = claim_path(legacy);
+    if (!claim(stale, claimed)) continue;
+    absorb(claimed, target);
+    count += 1;
+  }
+  return count;
+}
+function migrate_one(legacy, target) {
+  const recovered = absorb_stale(legacy, target);
+  const claimed = claim_path(legacy);
+  if (!claim(legacy, claimed)) return recovered > 0;
+  absorb(claimed, target);
+  return true;
+}
+function source_name(name) {
+  const end = name.indexOf(LEDGER_FILE_EXTENSION);
+  return end === -1 ? void 0 : name.slice(0, end + LEDGER_FILE_EXTENSION.length);
+}
+function legacy_directory_names(directory) {
+  try {
+    const names = readdirSync(directory).map((name) => source_name(name));
+    return [...new Set(names.filter((name) => name !== void 0))];
+  } catch {
+    return [];
+  }
+}
+function migrate_directory(root) {
+  const legacy_directory = path.join(root, LEGACY_OBSERVATION_LEDGER_DIRECTORY);
+  const did_move = legacy_directory_names(legacy_directory).map(
+    (name) => migrate_one(
+      path.join(legacy_directory, name),
+      path.join(root, OBSERVATION_LEDGER_DIRECTORY, name)
+    )
+  ).some(Boolean);
+  try {
+    rmdirSync(legacy_directory);
+  } catch {
+  }
+  return did_move;
+}
+function migrate(root) {
+  const target = path.join(root, OBSERVATION_LEDGER_DIRECTORY, LEGACY_LEDGER_FILE);
+  const moved_files = LEGACY_OBSERVATION_LEDGER_PATHS.map(
+    (legacy) => migrate_one(path.join(root, legacy), target)
+  );
+  return [...moved_files, migrate_directory(root)].some(Boolean);
+}
+var observation_ledger_migrate = { migrate };
+
+// scripts/observations/observation-ledger-home.ts
+var DATE_END = 10;
+function ledger_root(cwd = process.cwd()) {
+  return cwd;
+}
+function ledger_directory(cwd = process.cwd()) {
+  const root = ledger_root(cwd);
+  observation_ledger_migrate.migrate(root);
+  return path2.join(root, OBSERVATION_LEDGER_DIRECTORY);
+}
+function file_path(name, cwd) {
+  ledger_directory(cwd);
+  return path2.join(ledger_root(cwd), observation_ledger.ledger_file(name));
+}
+function issue_path(issue, cwd = process.cwd()) {
+  return file_path(issue, cwd);
+}
+async function current_branch(cwd) {
+  try {
+    return await git_spawn.read(["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+  } catch {
+    return "";
+  }
+}
+function ledger_date(now) {
+  return now.toISOString().slice(0, DATE_END);
+}
+async function writer_path(now, cwd = process.cwd()) {
+  const issue = git_branch.issue_from_branch(await current_branch(cwd));
+  return file_path(issue ?? ledger_date(now), cwd);
+}
+async function read_file(target, is_strict) {
+  try {
+    const content = await readFile(target, "utf8");
+    return content.length === 0 || content.endsWith("\n") ? content : `${content}
+`;
+  } catch (error) {
+    if (is_strict) throw error;
+    return "";
+  }
+}
+async function ledger_files(directory, is_strict) {
+  try {
+    const names = await readdir(directory);
+    return names.filter((name) => observation_ledger.is_ledger_file_name(name)).toSorted((left, right) => left.localeCompare(right));
+  } catch (error) {
+    if (is_strict) throw error;
+    return void 0;
+  }
+}
+async function read(cwd = process.cwd(), is_strict = false) {
+  const directory = ledger_directory(cwd);
+  const files = await ledger_files(directory, is_strict);
+  if (files === void 0) return void 0;
+  const contents = await Promise.all(
+    files.map(async (name) => await read_file(path2.join(directory, name), is_strict))
+  );
+  return contents.join("");
+}
+async function append(target, lines) {
+  if (lines.length === 0) return;
+  await mkdir(path2.dirname(target), { recursive: true });
+  await appendFile(target, `${lines.join("\n")}
+`, "utf8");
+}
+var observation_ledger_home = {
+  append,
+  file_path,
+  issue_path,
+  ledger_date,
+  ledger_root,
+  read,
+  read_file,
+  writer_path
+};
+
+export {
+  observation_ledger_line,
+  observation_ledger_home
+};