@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-JUQN3OXG.js

@@ -0,0 +1,351 @@
+import {
+  issue_read
+} from "./chunk-TR6NTNWR.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-plan-approval.ts
+import { z } from "zod";
+var evidence_schema = z.object({
+  issue: z.number().int().positive(),
+  paths: z.array(z.string().min(1)).min(1),
+  source: z.url(),
+  rationale: z.string().trim().min(1)
+});
+var lines_axis = {
+  declared_lines: z.number().int().positive(),
+  max_lines: z.number().int().positive()
+};
+var files_axis = {
+  declared_files: z.number().int().positive(),
+  max_files: z.number().int().positive()
+};
+var scope_schema = z.union([
+  evidence_schema.extend({ ...lines_axis, ...files_axis }),
+  evidence_schema.extend(lines_axis),
+  evidence_schema.extend(files_axis)
+]);
+var approval_schema = z.intersection(
+  scope_schema,
+  z.object({ author: z.string(), body: z.string() })
+);
+var FLAG = "--size-approval";
+var FLAG_WIDTH = 2;
+function split(argv) {
+  const at = argv.indexOf(FLAG);
+  if (at === -1) return { tokens: argv };
+  return {
+    tokens: [...argv.slice(0, at), ...argv.slice(at + FLAG_WIDTH)],
+    file: argv[at + 1] ?? ""
+  };
+}
+function is_source(row, source) {
+  return row.html_url === source && row.is_trusted === true;
+}
+function scope_of(file) {
+  const text = file_reader.read_if_readable(file) ?? "";
+  return json_value.parse_with(text, scope_schema);
+}
+async function read(file, issue) {
+  const scope = scope_of(file);
+  if (scope?.issue !== issue) return void 0;
+  const raw = await git_gh_issue_read.issue_list_comments(String(issue));
+  const comments = await issue_read.parse_comments(raw);
+  const comment = comments?.find((row) => is_source(row, scope.source));
+  if (comment === void 0) return void 0;
+  return { ...scope, author: comment.author, body: comment.body };
+}
+async function attach(plan, file) {
+  if (file === void 0) return plan;
+  const approval = await read(file, plan.issue);
+  return approval === void 0 ? void 0 : { ...plan, size_approval: approval };
+}
+function bounds(approval, reason) {
+  if (reason === "lines" && "declared_lines" in approval) {
+    return { declared: approval.declared_lines, max: approval.max_lines };
+  }
+  if (reason === "files" && "declared_files" in approval) {
+    return { declared: approval.declared_files, max: approval.max_files };
+  }
+  return void 0;
+}
+function allows(approval, plan, over) {
+  const bound = bounds(approval, over.reason);
+  if (bound === void 0) return false;
+  return approval.issue === plan.issue && plan.paths.every((file) => approval.paths.includes(file)) && over.declared === bound.declared && over.measured <= bound.max;
+}
+var lane_plan_approval = { allows, approval_schema, attach, read, split };
+
+// scripts/backlog/backlog-overlap.ts
+var CODE_SPAN = /`([^`\s]+)`/gu;
+var LINE_SUFFIX = /:\d+(?:[-:]\d+)?$/u;
+var FILE_EXTENSION = /\.[a-z]\w*$/iu;
+var ROOT_FILE_EXTENSION = /\.(?:[cm]?[jt]sx?|svelte|jsonc?|md|ya?ml|css|html|sh|toml|txt|properties)$/u;
+var GLOB = "*";
+var ISSUE_MARK = "#";
+var SEPARATOR = "/";
+var MIN_DIRECTORY_DEPTH = 2;
+var DOCS_DIRECTORY = "docs/";
+var MARKDOWN = ".md";
+function without_glob(path) {
+  const glob = path.indexOf(GLOB);
+  return glob === -1 ? path : path.slice(0, path.lastIndexOf(SEPARATOR, glob) + 1);
+}
+function is_narrow(directory) {
+  return directory.split(SEPARATOR).filter(Boolean).length >= MIN_DIRECTORY_DEPTH;
+}
+function is_file(path) {
+  return (path.includes(SEPARATOR) ? FILE_EXTENSION : ROOT_FILE_EXTENSION).test(path);
+}
+function claim_of(path) {
+  if (path.endsWith(SEPARATOR)) return is_narrow(path) ? path : void 0;
+  return is_file(path) ? path : void 0;
+}
+function path_claims(tokens) {
+  const paths = tokens.filter((token) => !token.includes(ISSUE_MARK)).map((token) => claim_of(without_glob(token.replace(LINE_SUFFIX, ""))));
+  return new Set(paths.filter((path) => path !== void 0));
+}
+function declared_paths(body) {
+  return path_claims([...body.matchAll(CODE_SPAN)].map((match) => match[1] ?? ""));
+}
+function declared_of(issues) {
+  return new Map(issues.map((issue) => [issue.number, declared_paths(issue.body ?? "")]));
+}
+function contains(outer, inner) {
+  return outer.endsWith(SEPARATOR) ? inner.startsWith(outer) : outer === inner;
+}
+function is_shared_document(path) {
+  return path.startsWith(DOCS_DIRECTORY) && (path.endsWith(SEPARATOR) || path.endsWith(MARKDOWN));
+}
+function overlaps(left, right) {
+  if (is_shared_document(left) || is_shared_document(right)) return false;
+  return contains(left, right) || contains(right, left);
+}
+function claims_of(declared, holders) {
+  const pairs = holders.flatMap(
+    (number) => [...declared.get(number) ?? []].map((path) => [path, number])
+  );
+  return new Map(pairs);
+}
+function running_numbers(read3) {
+  return read3.kind === "busy" ? read3.issues.map((issue) => issue.number) : [];
+}
+function running_claims(declared, read3) {
+  return claims_of(declared, running_numbers(read3));
+}
+function paths_of(child, declared, repo) {
+  if (child.repo !== repo) return /* @__PURE__ */ new Set();
+  return declared.get(child.number) ?? /* @__PURE__ */ new Set();
+}
+function clash_of(claims, paths) {
+  const clashes = [...paths].flatMap(
+    (path) => [...claims].filter(([claimed]) => overlaps(claimed, path)).map(([claimed, holder]) => ({ path, claimed, holder }))
+  );
+  return clashes[0];
+}
+function path_clash(paths, declared, holders) {
+  return clash_of(claims_of(declared, holders), paths);
+}
+function running_clash(child, declared, holding) {
+  return path_clash(paths_of(child, declared, holding.repo), declared, holding.holders);
+}
+function holds(declared, holder, waiting) {
+  return clash_of(claims_of(declared, [holder]), declared.get(waiting) ?? /* @__PURE__ */ new Set()) !== void 0;
+}
+function paused_tail(clash, lanes) {
+  const note = lane_state.paused_note(lanes.get(String(clash.holder)));
+  return note === void 0 ? "" : ` \u2014 ${note}`;
+}
+function clash_note(child, clash, lanes) {
+  const waiting = session_cite.issue(child.number, void 0, child.repo);
+  const holder = session_cite.issue(clash.holder, void 0, child.repo);
+  return `${waiting} waits: its \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares${paused_tail(clash, lanes)}.`;
+}
+function visit(walk, child, paths) {
+  const clash = clash_of(walk.claims, paths);
+  if (clash === void 0) {
+    walk.offered.push(child);
+    for (const path of paths) walk.claims.set(path, child.number);
+    return;
+  }
+  walk.withheld.push(child);
+  walk.notes.push(clash_note(child, clash, walk.lanes));
+}
+function merged_notice(notice, notes) {
+  const parts = notice === void 0 ? notes : [notice, ...notes];
+  return parts.length === 0 ? void 0 : parts.join("\n");
+}
+function separate(selection, declared, context) {
+  const walk = {
+    claims: running_claims(declared, context.read),
+    lanes: context.lanes ?? /* @__PURE__ */ new Map(),
+    offered: [],
+    withheld: [],
+    notes: []
+  };
+  for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo));
+  const notice = merged_notice(selection.notice, walk.notes);
+  const withheld = [...walk.withheld, ...selection.withheld];
+  return { offered: walk.offered, withheld, ...notice !== void 0 && { notice } };
+}
+var backlog_overlap = {
+  declared_of,
+  declared_paths,
+  holds,
+  path_claims,
+  path_clash,
+  running_clash,
+  running_numbers,
+  separate
+};
+
+// scripts/lane/lane-plan.ts
+import fs from "node:fs";
+import { z as z2 } from "zod";
+var lane_plan_schema = z2.object({
+  issue: z2.number(),
+  paths: z2.array(z2.string()),
+  planned_at: z2.string(),
+  estimated_size: z2.object({ files: z2.number(), lines: z2.number() }).optional(),
+  size_approval: lane_plan_approval.approval_schema.optional(),
+  // `--single`: the plan is one deliverable with no separately-mergeable part, so a files-axis overrun
+  // is noted for the pre-gate `run:cut` to verify rather than refused (joshuafolkken/kit#6647).
+  single: z2.boolean().optional(),
+  cleared: z2.boolean().optional(),
+  // The plan met the size bar (`lane-plan-size.ts`), whatever the overlap check answered after it.
+  sized: z2.boolean().optional(),
+  // The lane gave its lane back on this plan (`lane-yield.ts`), so the plan outlives the lane.
+  yielded: z2.boolean().optional(),
+  // When the lane's bounded wait on a later-dispatched holder ends (`lane-plan-wait.ts`), ISO time.
+  waits_until: z2.string().optional(),
+  // Every path an earlier cleared plan of this lane held (joshuafolkken/kit#5672), so a re-plan that
+  // narrows `paths` keeps the files the lane already cleared and edited planned for the hunks axis.
+  cleared_paths: z2.array(z2.string()).optional()
+});
+function plan_path(repository, issue) {
+  return durable_state.path(durable_state.PREFIX.LANE_PLAN, repository, `-${String(issue)}.json`);
+}
+function read2(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  const text = repository === void 0 ? void 0 : stamp_file.read_stamp_text(plan_path(repository, issue));
+  return text === void 0 ? void 0 : json_value.parse_with(text, lane_plan_schema);
+}
+function cleared_history(prior) {
+  const latest = prior?.cleared === true ? prior.paths : [];
+  return [.../* @__PURE__ */ new Set([...prior?.cleared_paths ?? [], ...latest])];
+}
+function with_history(plan, prior) {
+  const cleared_paths = cleared_history(prior);
+  return cleared_paths.length === 0 ? plan : { ...plan, cleared_paths };
+}
+function record(plan, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  const recorded = with_history(plan, read2(plan.issue, directory));
+  stamp_file.replace_stamp(plan_path(repository, plan.issue), recorded);
+  return true;
+}
+function remove(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository !== void 0) stamp_file.remove_stamp(plan_path(repository, issue));
+}
+function is_uncleared(issue, directory) {
+  return git_common_directory.repository(directory) !== void 0 && read2(issue, directory)?.cleared !== true;
+}
+function is_sized(plan) {
+  return plan?.sized === true || plan?.cleared === true;
+}
+function release(issue, directory) {
+  if (read2(issue, directory)?.yielded !== true) remove(issue, directory);
+}
+function recorded_ms(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  const stats = repository === void 0 ? void 0 : fs.statSync(plan_path(repository, issue), { throwIfNoEntry: false });
+  return stats?.mtimeMs ?? NaN;
+}
+function is_after(commented_at, recorded) {
+  return commented_at !== void 0 && Date.parse(commented_at) > recorded;
+}
+function plan_or(issue, paths, commented_at, directory) {
+  const recorded = read2(issue, directory);
+  if (recorded === void 0 || is_after(commented_at, recorded_ms(issue, directory))) return paths;
+  return new Set(recorded.paths);
+}
+function with_plans(declared, directory, commented = /* @__PURE__ */ new Map()) {
+  const replaced = [...declared].map(([issue, paths]) => [
+    issue,
+    plan_or(issue, paths, commented.get(issue), directory)
+  ]);
+  return new Map(replaced);
+}
+function with_holder_plans(declared, holders, directory) {
+  const added = holders.filter((issue) => !declared.has(issue)).flatMap((issue) => {
+    const recorded = read2(issue, directory);
+    return recorded === void 0 ? [] : [[issue, new Set(recorded.paths)]];
+  });
+  return new Map([...declared, ...added]);
+}
+function goes_before(other, plan) {
+  return other.cleared === true || other.planned_at < plan.planned_at;
+}
+function earlier_holders(plan, holders, directory) {
+  return holders.filter((holder) => {
+    const other = holder === plan.issue ? void 0 : read2(holder, directory);
+    return other !== void 0 && goes_before(other, plan);
+  });
+}
+function clash_of2(plan, declared, directory) {
+  const holders = earlier_holders(plan, [...declared.keys()], directory);
+  return backlog_overlap.path_clash(new Set(plan.paths), declared, holders);
+}
+function is_yielded(issue, directory) {
+  return read2(issue, directory)?.yielded === true;
+}
+function is_yield_held(issue, declared, directory, scope) {
+  const plan = read2(issue, directory);
+  if (plan?.yielded !== true) return false;
+  const held = scope === void 0 ? plan : { ...plan, paths: [...scope] };
+  return clash_of2(held, declared, directory) !== void 0;
+}
+var lane_plan = {
+  clash_of: clash_of2,
+  earlier_holders,
+  is_sized,
+  is_uncleared,
+  is_yield_held,
+  is_yielded,
+  read: read2,
+  record,
+  release,
+  remove,
+  with_holder_plans,
+  with_plans
+};
+
+export {
+  backlog_overlap,
+  lane_plan_approval,
+  lane_plan
+};

package/dist/commands/chunk-JUXKVN77.js

@@ -0,0 +1,100 @@
+import {
+  issue_observation_gate
+} from "./chunk-TKRUZZXG.js";
+import {
+  issue_sample_gate
+} from "./chunk-GY6O2WYG.js";
+import {
+  measure_declaration
+} from "./chunk-2GJ3WJVT.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/issue-not-before.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var PREFIX = issue_body_keys.prefix("not_before");
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u;
+var ISO_TAIL = ":00.000Z";
+var EXAMPLE = `${PREFIX} 2099-01-01T09:00Z`;
+var MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
+${EXAMPLE}`;
+var MAX_WAIT_DAYS = 7;
+var DAY_MS = 864e5;
+var MAX_WAIT_MS = MAX_WAIT_DAYS * DAY_MS;
+var MINUTES_LENGTH = 16;
+var TOO_LATE = `\`${PREFIX}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
+var BOTH = `a measurement follow-up declares one of \`${PREFIX}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
+var HEADING_MARKS = /^#{1,6}\s+/u;
+var STRAY_HEADINGS = [
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX} YYYY-MM-DDTHH:MMZ` },
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", declaration: issue_sample_gate.DECLARATION }
+];
+function declared_value(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  const line = markdown_section.unfenced_lines(background).map((text) => text.trim()).find((text) => text.startsWith(PREFIX));
+  return line?.slice(PREFIX.length).trim();
+}
+function is_valid(value) {
+  if (!DATE_PATTERN.test(value)) return false;
+  const time = Date.parse(value);
+  return !Number.isNaN(time) && new Date(time).toISOString() === `${value.slice(0, -1)}${ISO_TAIL}`;
+}
+function date_of(body = "") {
+  const value = declared_value(body);
+  return value !== void 0 && is_valid(value) ? value : void 0;
+}
+function is_date_due(body, now) {
+  const date = date_of(body);
+  return date === void 0 || Date.parse(date) <= now;
+}
+function is_due(body, now = Date.now()) {
+  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0 && issue_observation_gate.wait_of(body) === void 0;
+}
+function waiting_ms(body, now = Date.now()) {
+  if (is_date_due(body, now)) return void 0;
+  return Date.parse(String(date_of(body)));
+}
+function waiting_date(body, now = Date.now()) {
+  return is_date_due(body, now) ? void 0 : date_of(body);
+}
+function waiting_reason(body, now = Date.now()) {
+  const date = waiting_date(body, now);
+  if (date !== void 0) return `not before ${date}`;
+  const wait = issue_sample_gate.wait_of(body);
+  return wait === void 0 ? issue_observation_gate.wait_of(body)?.reason : issue_sample_gate.reason_of(wait);
+}
+function stray_heading_problems(body) {
+  const headings = markdown_section.unfenced_lines(body).map((line) => line.trim()).filter((line) => HEADING_MARKS.test(line)).map((line) => line.replace(HEADING_MARKS, ""));
+  return STRAY_HEADINGS.filter(({ name }) => headings.some((text) => text.startsWith(name))).map(
+    ({ name, declaration }) => `heading \`${name}\` is not read \u2014 declare it under \`${BACKGROUND_HEADING}\` as \`${declaration}\``
+  );
+}
+function latest_date(now) {
+  return `${new Date(now + MAX_WAIT_MS).toISOString().slice(0, MINUTES_LENGTH)}Z`;
+}
+function measurement_wait_problems(body, now) {
+  const date = date_of(body);
+  if (date === void 0 || !measure_declaration.is_stated(body)) return [];
+  if (issue_sample_gate.cited_number(body) !== void 0) return [BOTH];
+  return Date.parse(date) > now + MAX_WAIT_MS ? [`${TOO_LATE}
+${PREFIX} ${latest_date(now)}`] : [];
+}
+function problems(body, now = Date.now()) {
+  const value = declared_value(body);
+  const date_problems = value === void 0 || is_valid(value) ? [] : [MALFORMED];
+  return [
+    ...stray_heading_problems(body),
+    ...date_problems,
+    ...measurement_wait_problems(body, now),
+    ...issue_sample_gate.problems(body)
+  ];
+}
+var issue_not_before = { is_due, problems, waiting_date, waiting_ms, waiting_reason };
+
+export {
+  issue_not_before
+};

package/dist/commands/chunk-JZZURWZH.js

@@ -0,0 +1,33 @@
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/gh/gh-spawn.ts
+var NO_BUDGET = 0;
+function fetch_repo_name(timeout_ms) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: git_gh_api_path.repo_api_path(),
+    jq_filter: ".full_name",
+    cwd: PROJECT_ROOT,
+    timeout_ms: timeout_ms ?? NO_BUDGET
+  });
+  const name = stdout?.trim();
+  return name === "" ? void 0 : name;
+}
+function get_repo_name_with_owner() {
+  return fetch_repo_name(void 0);
+}
+function get_repo_name_with_owner_within(timeout_ms) {
+  return fetch_repo_name(timeout_ms);
+}
+var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
+
+export {
+  gh_spawn
+};

package/dist/commands/chunk-K2FXMBIU.js

@@ -0,0 +1,95 @@
+import {
+  stash_args
+} from "./chunk-R7IT5VOL.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.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-K2VIKG5M.js

@@ -0,0 +1,34 @@
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-UJFEMO6X.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+
+// scripts/lane/lane-implement-rate-read.ts
+var PERIOD_DAYS = 3;
+async function read_ledger(context) {
+  const path = context.ledger_path ?? await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function implement_rate(context = {}, now_ms = Date.now()) {
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return lane_implement_rate.rate(await read_ledger(context), window);
+}
+async function measurements(context = {}, now_ms = Date.now()) {
+  const entries = await read_ledger(context);
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return {
+    implement_rate: lane_implement_rate.rate(entries, window),
+    growth: lane_size_stats.ratios(entries, window)
+  };
+}
+var lane_implement_rate_read = { PERIOD_DAYS, implement_rate, measurements, read_ledger };
+
+export {
+  lane_implement_rate_read
+};