@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-XDWCF4XH.js

@@ -0,0 +1,347 @@
+import {
+  lane_session_action
+} from "./chunk-FZNYKSQS.js";
+import {
+  ts_entry_loader
+} from "./chunk-VHRNXWVP.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-session-broker.ts
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, rmSync, unlinkSync } from "node:fs";
+import path from "node:path";
+import { z as z3 } from "zod";
+
+// scripts/lane/lane-broker-server.ts
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+var SERVER_SUFFIX = ".server";
+var server_schema = z.object({
+  session: z.uuid(),
+  pid: z.number().int().positive(),
+  process_start: z.string().optional()
+}).strict();
+function server_path(response) {
+  return `${response}${SERVER_SUFFIX}`;
+}
+function write(response, session) {
+  stamp_file.replace_stamp(server_path(response), { session, ...process_identity.own_fields() });
+}
+function remove(response) {
+  stamp_file.remove_stamp(server_path(response));
+}
+function read(response, session) {
+  try {
+    const server = json_value.parse_with(readFileSync(server_path(response), "utf8"), server_schema);
+    return server?.session === session ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_serving_process(server) {
+  return process_identity.is_present_process(server.pid, server.process_start) !== false;
+}
+function is_running(server) {
+  return process_identity.is_present_pid(server.pid);
+}
+var lane_broker_server = { is_running, is_serving_process, read, remove, server_path, write };
+
+// scripts/lane/lane-session-reread.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { fileURLToPath } from "node:url";
+import { execa } from "execa";
+import { z as z2 } from "zod";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lane/lane-session-reread.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 ENTRY = fileURLToPath(new URL("lane-session-reread-main.ts", __josh_source_url));
+var answer_schema = z2.discriminatedUnion("is_success", [
+  z2.object({ is_success: z2.literal(true) }).strict(),
+  z2.object({ is_success: z2.literal(false), reason: z2.string() }).strict()
+]);
+async function answer_text(issue, text) {
+  const request2 = json_value.parse_with(text, lane_session_action.request_schema);
+  if (request2 === void 0) return void 0;
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return void 0;
+  return await lane_session_action.answer(lane, request2.action);
+}
+function last_line(text) {
+  return text.trimEnd().split("\n").at(-1) ?? "";
+}
+async function reread(issue, received) {
+  const result = await execa(
+    process.execPath,
+    [...ts_entry_loader.loader_argv(process.execArgv), ENTRY, issue, JSON.stringify(received)],
+    { reject: false, stderr: "inherit" }
+  );
+  if (result.exitCode !== 0) return void 0;
+  return json_value.parse_with(last_line(result.stdout), answer_schema);
+}
+var lane_session_reread = { answer_text, reread };
+
+// scripts/lane/lane-session-broker.ts
+var REQUEST_PREFIX = ".josh-review-request-";
+var RESPONSE_PREFIX = ".josh-review-response-";
+var CACHE_DIRECTORY = ["node_modules", ".cache"];
+var POLL_MS = 100;
+var LEGACY_HEARTBEAT_MS = 500;
+var LEGACY_HEARTBEAT_LIMIT_MS = 3e3;
+var MINUTE_MS = 6e4;
+var REQUEST_LIMIT_MINUTES = {
+  review: 30,
+  relaunch: 2
+};
+var { request_schema } = lane_session_action;
+var envelope_schema = z3.looseObject({ session: z3.uuid(), nonce: z3.uuid() });
+var UNREADABLE_REASON = "the broker could not read the request";
+var VERSION_NOTE = "the broker's code differs from the ship's; a run:wake supervisor re-checks its code at its next pass";
+var refusal = { is_pending: false };
+var response_schema = z3.object({
+  session: z3.uuid(),
+  nonce: z3.string(),
+  is_success: z3.boolean(),
+  heartbeat_at: z3.number().int().positive()
+}).strict();
+var reason_schema = z3.object({ nonce: z3.string(), reason: z3.string() }).strict();
+var { failure } = lane_session_action;
+function request_path(directory, issue) {
+  return path.join(directory, ...CACHE_DIRECTORY, `${REQUEST_PREFIX}${issue}.json`);
+}
+function response_path(directory, issue) {
+  const common = git_common_directory.resolve(directory);
+  if (common === void 0 || path.basename(common) !== ".git") return void 0;
+  return path.join(path.dirname(common), ...CACHE_DIRECTORY, `${RESPONSE_PREFIX}${issue}.json`);
+}
+function reason_path(response) {
+  return `${response}.reason`;
+}
+function read_record(target, schema) {
+  try {
+    return json_value.parse_with(readFileSync2(target, "utf8"), schema);
+  } catch {
+    return void 0;
+  }
+}
+function write_record(target, body) {
+  atomic_write.replace_file(target, JSON.stringify(body));
+}
+function refused_field(issue) {
+  const at = issue.path.map(String);
+  if (issue.code !== "unrecognized_keys") return [`${at.join(".")}: ${issue.message}`];
+  return issue.keys.map((key) => `unrecognized key: ${[...at, key].join(".")}`);
+}
+function unreadable(error) {
+  const fields = error.issues.flatMap((issue) => refused_field(issue));
+  return failure(`${UNREADABLE_REASON} \u2014 ${VERSION_NOTE} \u2014 ${fields.join("; ")}`);
+}
+function is_unreadable(answer) {
+  return !answer.is_success && answer.reason.includes(UNREADABLE_REASON);
+}
+async function answer_request(lane, received) {
+  const parsed = request_schema.safeParse(received);
+  if (parsed.success) return await lane_session_action.answer(lane, parsed.data.action);
+  refusal.is_pending = true;
+  return await lane_session_reread.reread(lane.issue, received) ?? unreadable(parsed.error);
+}
+function take_refusal() {
+  const { is_pending } = refusal;
+  refusal.is_pending = false;
+  return is_pending;
+}
+var answering = { count: 0 };
+function is_answering() {
+  return answering.count > 0;
+}
+async function answer_counted(lane, received) {
+  answering.count += 1;
+  try {
+    return await answer_request(lane, received);
+  } finally {
+    answering.count -= 1;
+  }
+}
+async function process_request(lane, response, received, state) {
+  const answer = await answer_counted(lane, received);
+  const { session, nonce } = received;
+  if (!answer.is_success) write_record(reason_path(response), { nonce, reason: answer.reason });
+  state.current = { session, nonce, is_success: answer.is_success, heartbeat_at: Date.now() };
+  write_record(response, state.current);
+}
+async function serve(lane, session, response, state) {
+  const served = { nonce: "" };
+  const target = request_path(lane.directory, lane.issue);
+  async function serve_pass() {
+    if (!state.is_running) return true;
+    const received = read_record(target, envelope_schema);
+    if (received?.session === session && received.nonce !== served.nonce) {
+      served.nonce = received.nonce;
+      await process_request(lane, response, received, state);
+    }
+    return void 0;
+  }
+  await poll.wait_for(serve_pass, { interval_ms: POLL_MS });
+}
+function prepare(lane) {
+  const response = response_path(lane.directory, lane.issue);
+  if (response === void 0) throw new Error("review broker has no trusted response location");
+  const session = randomUUID();
+  mkdirSync(path.dirname(response), { recursive: true });
+  mkdirSync(path.dirname(request_path(lane.directory, lane.issue)), { recursive: true });
+  lane_broker_server.write(response, session);
+  const current = {
+    session,
+    nonce: "",
+    is_success: false,
+    heartbeat_at: Date.now()
+  };
+  write_record(response, current);
+  return { response, current };
+}
+function start_heartbeat(state, response) {
+  const heartbeat = setInterval(() => {
+    state.current = { ...state.current, heartbeat_at: Date.now() };
+    write_record(response, state.current);
+  }, LEGACY_HEARTBEAT_MS);
+  heartbeat.unref();
+  return heartbeat;
+}
+async function stop_server(state, heartbeat, serving, response) {
+  state.is_running = false;
+  await serving;
+  clearInterval(heartbeat);
+  unlinkSync(response);
+  rmSync(reason_path(response), { force: true });
+  lane_broker_server.remove(response);
+}
+async function with_server(lane, run) {
+  const { response, current } = prepare(lane);
+  const state = { is_running: true, current };
+  const heartbeat = start_heartbeat(state, response);
+  const serving = serve(lane, current.session, response, state);
+  try {
+    return await run();
+  } finally {
+    await stop_server(state, heartbeat, serving, response);
+  }
+}
+function is_fresh_heartbeat(heartbeat_at) {
+  const now = Date.now();
+  return heartbeat_at <= now && heartbeat_at >= now - LEGACY_HEARTBEAT_LIMIT_MS;
+}
+function is_live_response(target, response, is_live) {
+  if (response === void 0) return false;
+  const server = lane_broker_server.read(target, response.session);
+  return server === void 0 ? is_fresh_heartbeat(response.heartbeat_at) : is_live(server);
+}
+function session_response(target, session) {
+  const response = read_record(target, response_schema);
+  return response?.session === session ? response : void 0;
+}
+function answer_of(target, response) {
+  if (response.is_success) return lane_session_action.SUCCESS;
+  const record = read_record(reason_path(target), reason_schema);
+  const reason = record?.nonce === response.nonce ? record.reason : "it gave no reason";
+  return failure(`the broker answered a failure: ${reason}`);
+}
+function response_verdict(target, session, nonce) {
+  const response = session_response(target, session);
+  if (!is_live_response(target, response, lane_broker_server.is_running)) {
+    return failure("the broker stopped serving before it answered");
+  }
+  return response.nonce === nonce ? answer_of(target, response) : void 0;
+}
+async function wait_response(target, session, nonce, kind) {
+  const limit_minutes = REQUEST_LIMIT_MINUTES[kind];
+  const deadline = Date.now() + limit_minutes * MINUTE_MS;
+  function verdict_by_deadline() {
+    if (Date.now() >= deadline) {
+      return failure(`the broker gave no answer within ${String(limit_minutes)} minutes`);
+    }
+    return response_verdict(target, session, nonce);
+  }
+  return await poll.wait_for(verdict_by_deadline, { interval_ms: POLL_MS });
+}
+function live_response(target) {
+  const response = read_record(target, response_schema);
+  return is_live_response(target, response, lane_broker_server.is_serving_process) ? response : void 0;
+}
+function serving_session(directory, issue) {
+  const target = response_path(directory, issue);
+  return target === void 0 ? void 0 : live_response(target)?.session;
+}
+function is_serving(directory, issue) {
+  return serving_session(directory, issue) !== void 0;
+}
+function withdraw(pending, nonce) {
+  if (read_record(pending, request_schema)?.nonce === nonce) stamp_file.remove_stamp(pending);
+}
+async function record_failure(issue, answer) {
+  if (answer.is_success) return;
+  const text = `${issue_cite.plain_for("program", issue)} lane broker: ${answer.reason}`;
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.NOTE, text);
+}
+async function send(directory, issue, action) {
+  const target = response_path(directory, issue);
+  const response = target === void 0 ? void 0 : live_response(target);
+  if (target === void 0 || response === void 0) return failure("no broker serves this lane");
+  const nonce = randomUUID();
+  const body = { session: response.session, nonce, action };
+  const pending = request_path(directory, issue);
+  stamp_file.replace_stamp(pending, body);
+  const answer = await wait_response(target, response.session, nonce, action.kind);
+  withdraw(pending, nonce);
+  return answer;
+}
+async function request(directory, issue, action) {
+  const answer = await send(directory, issue, action);
+  await record_failure(issue, answer);
+  return answer;
+}
+var lane_session_broker = {
+  is_answering,
+  is_serving,
+  is_unreadable,
+  request,
+  request_path,
+  response_path,
+  review_paths: lane_session_action.review_paths,
+  serving_session,
+  take_refusal,
+  with_server
+};
+
+export {
+  lane_session_broker
+};

package/dist/commands/chunk-XHLSJPV7.js

@@ -0,0 +1,69 @@
+import {
+  moved_paths
+} from "./chunk-NR4BD5DD.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  verification_inputs
+} from "./chunk-HQ5U6OZR.js";
+
+// scripts/gate/since-green.ts
+var SINCE_GREEN = "since its last green run on this checkout";
+var UNMOVED_REASON = `nothing moved ${SINCE_GREEN}`;
+function describe(label, moved) {
+  return `${label}: reading only the ${String(moved.length)} file(s) changed ${SINCE_GREEN}.`;
+}
+function is_narrowed(out) {
+  return out.includes(SINCE_GREEN);
+}
+var FALLBACK = {
+  NO_RECORD: "no-record",
+  INPUT_MISMATCH: "input-mismatch",
+  NO_BASE: "no-base",
+  CONFIG_FILE: "config-file",
+  AFTER_RED: "after-red",
+  NO_READ_MAP: "no-read-map",
+  HUB: "hub"
+};
+var FALLBACK_MARK = "whole branch \u2014 since-green fell back:";
+var FALLBACK_PATTERN = new RegExp(`${FALLBACK_MARK} ([a-z-]+)`, "u");
+function fallback_line(label, reason) {
+  return `${label}: ${FALLBACK_MARK} ${reason}.`;
+}
+function fallbacks_of(out) {
+  const reasons = out.split("\n").map((line) => FALLBACK_PATTERN.exec(line)?.[1]);
+  return [...new Set(reasons.filter((reason) => reason !== void 0))];
+}
+function narrowed_verdict(label, parts) {
+  if (parts === void 0) return { fallback: FALLBACK.NO_BASE };
+  if (verification_inputs.configures(label, moved_paths.union_of(parts))) {
+    return { fallback: FALLBACK.CONFIG_FILE };
+  }
+  return { parts };
+}
+async function read_verdict(stamp, label, source, tree) {
+  const record = stamp.read(source);
+  if (record === void 0) return { fallback: FALLBACK.NO_RECORD };
+  if (!stamp.describes_inputs(record)) return { fallback: FALLBACK.INPUT_MISMATCH };
+  const parts = await moved_paths.moved_parts(record, tree ?? await gate_tree.read_gate_tree());
+  return narrowed_verdict(label, parts);
+}
+async function read_moved_parts(stamp, label, source, tree) {
+  const verdict = await read_verdict(stamp, label, source, tree);
+  return "parts" in verdict ? verdict.parts : void 0;
+}
+var since_green = {
+  FALLBACK,
+  UNMOVED_REASON,
+  describe,
+  fallback_line,
+  fallbacks_of,
+  is_narrowed,
+  read_moved_parts,
+  read_verdict
+};
+
+export {
+  since_green
+};

package/dist/commands/chunk-XHR7O2DE.js

@@ -0,0 +1,52 @@
+import {
+  lane_capacity,
+  lane_limit_override
+} from "./chunk-6HJ5CJSJ.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger_kind,
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+
+// scripts/lane/lane-limit-history.ts
+var { KIND } = lane_ledger_kind;
+var CHANGE_SEPARATOR = "\u2192";
+async function record(choice, path) {
+  if (choice.kind !== "limit") return;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  await lane_ledger_write.record({ kind: KIND.LIMIT, at, limit: choice.limit }, path);
+}
+async function record_current(path) {
+  await record(await lane_capacity.lane_limit(), path);
+}
+async function record_launch(path) {
+  const choice = lane_capacity.environment_limit();
+  if (choice.kind === "limit") await lane_limit_override.write_launch(choice.limit);
+  await record(choice, path);
+}
+function is_limit(entry) {
+  return entry.kind === KIND.LIMIT;
+}
+function limits_in(entries, window) {
+  const limits = entries.filter((entry) => is_limit(entry));
+  const opening = limits.findLast((entry) => Date.parse(entry.at) < window.since_ms);
+  const inside = lane_stats.in_window(limits, window);
+  const held = [...opening === void 0 ? [] : [opening], ...inside].map((entry) => entry.limit);
+  return held.filter((limit, index) => index === 0 || limit !== held[index - 1]);
+}
+async function current_label() {
+  const choice = await lane_capacity.lane_limit();
+  return choice.kind === "limit" ? String(choice.limit) : lane_stats.MISSING;
+}
+async function label(given, entries, window) {
+  if (given !== void 0) return given;
+  const limits = limits_in(entries, window);
+  return limits.length === 0 ? await current_label() : limits.map(String).join(CHANGE_SEPARATOR);
+}
+var lane_limit_history = { label, record_current, record_launch };
+
+export {
+  lane_limit_history
+};

package/dist/commands/chunk-XIV3UDHV.js

@@ -0,0 +1,119 @@
+import {
+  package_with_version_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/release/release-plan.ts
+import semver from "semver";
+var PENDING_ICON = "\u{1F69A}";
+var SHORT_SHA_LENGTH = 7;
+function previous_version_of(commits, index, oldest_parent_version) {
+  const previous = commits[index + 1];
+  return previous === void 0 ? oldest_parent_version : previous.version;
+}
+function find_version_base(commits, oldest_parent_version) {
+  const found = commits.find((commit, index) => {
+    const previous = previous_version_of(commits, index, oldest_parent_version);
+    return commit.version !== void 0 && previous !== void 0 && commit.version !== previous;
+  });
+  return found?.sha;
+}
+function next_version(current, pending) {
+  const parsed = semver.parse(current);
+  if (parsed === null) throw new Error(`Invalid version format: ${current}`);
+  if (pending === 0) return parsed.version;
+  return `${String(parsed.major)}.${String(parsed.minor + pending)}.0`;
+}
+function short_sha(sha) {
+  return sha.slice(0, SHORT_SHA_LENGTH);
+}
+function format_pending_line(pending) {
+  return `${PENDING_ICON} unreleased merges on main: ${String(pending)}`;
+}
+function format_nothing_to_release(base) {
+  return [
+    format_pending_line(0),
+    `  Nothing to release \u2014 no merge has landed on main since ${short_sha(base)}, the commit that last changed the version.`
+  ].join("\n");
+}
+function format_plan(plan) {
+  return [
+    format_pending_line(plan.pending),
+    `  base ${short_sha(plan.base)} \xB7 ${plan.current_version} \u2192 ${plan.next_version}`
+  ].join("\n");
+}
+var release_plan = {
+  find_version_base,
+  previous_version_of,
+  format_nothing_to_release,
+  format_pending_line,
+  format_plan,
+  next_version,
+  short_sha
+};
+
+// scripts/release/release-history.ts
+var BASE_SEARCH_LIMIT = 30;
+var DEFAULT_TIP = "HEAD";
+var git_reader = {
+  log_first_parent: git_command.log_first_parent,
+  show_file: git_command.show_file,
+  count_merges: git_command.count_merges
+};
+function parse_version(content) {
+  if (content === void 0) return void 0;
+  return json_value.parse_with(content, package_with_version_schema)?.version;
+}
+async function read_version_at(reader, reference) {
+  try {
+    return parse_version(await reader.show_file(`${reference}:./${PACKAGE_JSON}`));
+  } catch {
+    return void 0;
+  }
+}
+async function read_versioned_commits(reader, tip) {
+  const shas = await reader.log_first_parent(BASE_SEARCH_LIMIT, PACKAGE_JSON, tip);
+  return await Promise.all(
+    shas.map(async (sha) => ({ sha, version: await read_version_at(reader, sha) }))
+  );
+}
+async function read_base(reader = git_reader, tip = DEFAULT_TIP) {
+  const commits = await read_versioned_commits(reader, tip);
+  const oldest = commits.at(-1);
+  const oldest_parent_version = oldest === void 0 ? void 0 : await read_version_at(reader, `${oldest.sha}^`);
+  return release_plan.find_version_base(commits, oldest_parent_version);
+}
+async function read_current_version(tip = DEFAULT_TIP, reader = git_reader) {
+  return await read_version_at(reader, tip);
+}
+async function read_release_plan(current_version, reader = git_reader, tip = DEFAULT_TIP) {
+  const base = await read_base(reader, tip);
+  if (base === void 0) return void 0;
+  const pending = await reader.count_merges(`${base}..${tip}`);
+  return {
+    base,
+    pending,
+    current_version,
+    next_version: release_plan.next_version(current_version, pending)
+  };
+}
+var release_history = {
+  parse_version,
+  read_base,
+  read_current_version,
+  read_release_plan,
+  BASE_SEARCH_LIMIT
+};
+
+export {
+  release_plan,
+  release_history
+};