@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-L7DAL54N.js

@@ -1,347 +0,0 @@
-import {
-  lane_session_action
-} from "./chunk-NHIW7JE6.js";
-import {
-  ts_entry_loader
-} from "./chunk-VHRNXWVP.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.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-LAR76BFA.js

@@ -1,114 +0,0 @@
-import {
-  whole_suite_files
-} from "./chunk-CFHRNTE5.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/test/direct-importers.ts
-import { readFileSync } from "node:fs";
-import path from "node:path";
-var PACKAGE_FILE = "package.json";
-var WILDCARD = "*";
-var CURRENT_DIRECTORY_PREFIX = "./";
-var NUL = "\0";
-var SPECIFIER_PATTERN = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+|\bmock\(\s*)["']([^"']+)["']/gu;
-function module_key(file) {
-  const posix = file.split(path.sep).join(path.posix.sep);
-  return posix.slice(0, posix.length - path.posix.extname(posix).length);
-}
-function specifiers_of(source) {
-  return [...source.matchAll(SPECIFIER_PATTERN)].flatMap((match) => match.slice(1));
-}
-function alias_target(specifier, imports) {
-  const exact = imports[specifier];
-  if (exact !== void 0) return exact;
-  const key = Object.keys(imports).find(
-    (pattern) => pattern.endsWith(WILDCARD) && specifier.startsWith(pattern.slice(0, -1))
-  );
-  if (key === void 0) return void 0;
-  return imports[key]?.split(WILDCARD).join(specifier.slice(key.length - 1));
-}
-function relative_target(specifier, from) {
-  return path.posix.join(path.posix.dirname(from), specifier);
-}
-function resolve_specifier(specifier, from, imports) {
-  if (specifier.startsWith(".")) return module_key(relative_target(specifier, from));
-  const target = alias_target(specifier, imports);
-  if (target === void 0) return void 0;
-  return module_key(path.posix.normalize(target.replace(CURRENT_DIRECTORY_PREFIX, "")));
-}
-function names_any(source, from, scoped, imports) {
-  return specifiers_of(source).some((specifier) => {
-    const resolved = resolve_specifier(specifier, from, imports);
-    return resolved !== void 0 && scoped.has(resolved);
-  });
-}
-function read_imports(root) {
-  try {
-    const parsed = JSON.parse(readFileSync(path.join(root, PACKAGE_FILE), "utf8"));
-    const imports = Reflect.get(new Object(parsed), "imports");
-    if (typeof imports !== "object" || imports === null) return {};
-    return Object.fromEntries(
-      Object.entries(imports).filter(
-        (entry) => typeof entry[1] === "string"
-      )
-    );
-  } catch {
-    return {};
-  }
-}
-function read_source_at(root, file) {
-  try {
-    return readFileSync(path.join(root, file), "utf8");
-  } catch {
-    return void 0;
-  }
-}
-function source_reader(root) {
-  return { imports: read_imports(root), read_source: (file) => read_source_at(root, file) };
-}
-async function test_files(root) {
-  const listed = await git_spawn.read(["-C", root, "ls-files", "-coz", "--exclude-standard"]);
-  return listed.split(NUL).filter((file) => test_declared_logic.is_test_file(file));
-}
-function importers_among(file, tests, reader) {
-  const scoped = /* @__PURE__ */ new Set([module_key(file)]);
-  return tests.filter((test) => {
-    const source = reader.read_source(test);
-    return source !== void 0 && names_any(source, test, scoped, reader.imports);
-  });
-}
-function every_test_imports_of(files) {
-  return files.filter((file) => whole_suite_files.EVERY_TEST_IMPORTS.has(path.normalize(file)));
-}
-function is_every_test_import(root, argument) {
-  return whole_suite_files.EVERY_TEST_IMPORTS.has(path.relative(root, path.resolve(argument)));
-}
-async function importers_of(root, files) {
-  if (files.length === 0) return /* @__PURE__ */ new Map();
-  const tests = await test_files(root);
-  const reader = source_reader(root);
-  return new Map(files.map((file) => [file, importers_among(file, tests, reader)]));
-}
-async function every_test_importers(root, files) {
-  return await importers_of(root, every_test_imports_of(files));
-}
-var direct_importers = {
-  every_test_importers,
-  every_test_imports_of,
-  importers_of,
-  is_every_test_import,
-  module_key,
-  names_any,
-  resolve_specifier,
-  source_reader,
-  specifiers_of
-};
-
-export {
-  direct_importers
-};

package/dist/commands/chunk-LB557AHJ.js

@@ -1,192 +0,0 @@
-import {
-  lane_vacant
-} from "./chunk-VV4TQYGD.js";
-import {
-  josh_command
-} from "./chunk-2VRITY55.js";
-import {
-  run_event_setup
-} from "./chunk-I2KCGKJI.js";
-import {
-  core_budget,
-  core_wait
-} from "./chunk-TCBUX52E.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  INSTALL_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-launch-cli.ts
-import { execa } from "execa";
-
-// scripts/lane/lane-launch-admission.ts
-var LANE_MEMORY_MB = 470;
-function checkout_of(issue) {
-  const cwd = process.cwd();
-  const root = core_wait.where_of(cwd).lanes_root ?? lane_paths.lane_root(cwd);
-  return lane_paths.lane_directory(root, issue);
-}
-function options_of(issue) {
-  return {
-    memory_mb: LANE_MEMORY_MB,
-    is_strict_admission: true,
-    is_memory_pending: true,
-    command: "lane:launch",
-    checkout: checkout_of(issue)
-  };
-}
-async function run_reserved(context, run2, handle) {
-  let is_retained = false;
-  try {
-    const outcome = await run2(context);
-    if (outcome.kind === "launched") {
-      core_budget.transfer(handle, Number(outcome.pid));
-      is_retained = true;
-    }
-    return outcome;
-  } finally {
-    if (!is_retained) core_budget.release(handle);
-  }
-}
-async function launch(context, run2) {
-  const handle = await core_budget.reserve(0, options_of(context.issue));
-  return await run_reserved(context, run2, handle);
-}
-var lane_launch_admission = { launch, options_of, run_reserved };
-
-// scripts/lane/lane-launch-pending.ts
-var pending = /* @__PURE__ */ new Map();
-function keep(issues) {
-  for (const [issue, claim] of pending) {
-    if (issues.includes(issue)) continue;
-    core_budget.release(claim);
-    pending.delete(issue);
-  }
-}
-function claim_for(issue) {
-  const claim = pending.get(issue) ?? core_budget.claim(0, lane_launch_admission.options_of(issue));
-  pending.set(issue, claim);
-  return claim;
-}
-async function launch2(context, run2) {
-  const handle = await core_budget.poll_claim(claim_for(context.issue));
-  if (handle === void 0) return { kind: "waiting" };
-  pending.delete(context.issue);
-  return await lane_launch_admission.run_reserved(context, run2, handle);
-}
-var lane_launch_pending = { keep, launch: launch2 };
-
-// scripts/lane/lane-launch-cli.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var should_forward_stderr = true;
-var PNPM = "pnpm";
-var USAGE = "Usage: josh lane:launch <issue-number> [--stash <message>]";
-var OPTIONS = { stash: { type: "string" } };
-var PREPARED = { code: SUCCESS_EXIT_CODE, out: "" };
-function read_context(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  if (parsed === void 0) return void 0;
-  const [issue, ...rest] = parsed.positionals;
-  if (issue === void 0 || rest.length > 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
-    return void 0;
-  }
-  return { issue, stash: parsed.values.stash };
-}
-function failure_detail(result) {
-  const detail = (result.err ?? "").trim() || result.out.trim();
-  return detail === "" ? void 0 : detail;
-}
-function refused(kind, result) {
-  const detail = failure_detail(result);
-  return detail === void 0 ? { kind } : { kind, detail };
-}
-async function install(directory) {
-  const result = await execa(PNPM, ["--dir", directory, "install", "--frozen-lockfile"], {
-    reject: false,
-    timeout: INSTALL_TIMEOUT_MS
-  });
-  const installed = {
-    code: result.exitCode ?? FAILURE_EXIT_CODE,
-    out: result.stdout,
-    err: result.stderr
-  };
-  if (installed.code !== SUCCESS_EXIT_CODE) console.error(failure_detail(installed) ?? "");
-  return installed;
-}
-async function prepare(context, directory) {
-  const { issue, stash } = context;
-  if (stash === void 0) return PREPARED;
-  const popped = await josh_command.josh_run(
-    ["stash:pop", stash, "--dir", directory],
-    should_forward_stderr
-  );
-  if (popped.code !== SUCCESS_EXIT_CODE) return popped;
-  await run_event_setup.emit(run_event_setup.installing(issue));
-  return await install(directory);
-}
-async function close_if_vacant(lane) {
-  if (lane === void 0 || !await lane_vacant.is_vacant(lane)) return;
-  await josh_command.josh_run(["lane:close", lane.issue], should_forward_stderr);
-}
-async function lane_directory(issue) {
-  const kept = await lane_registry.find_open_lane(issue);
-  if (kept?.output !== void 0) return { code: SUCCESS_EXIT_CODE, out: kept.directory };
-  await close_if_vacant(kept);
-  return await josh_command.josh_run(["lane:open", issue], should_forward_stderr);
-}
-async function launch_admitted(context) {
-  const opened = await lane_directory(context.issue);
-  if (opened.code !== SUCCESS_EXIT_CODE) return refused("unopened", opened);
-  const prepared = await prepare(context, opened.out);
-  if (prepared.code !== SUCCESS_EXIT_CODE) return refused("failed", prepared);
-  await run_event_setup.emit(run_event_setup.dispatching(context.issue));
-  const dispatched = await josh_command.josh_run(
-    ["lane:dispatch", context.issue],
-    should_forward_stderr
-  );
-  if (dispatched.code !== SUCCESS_EXIT_CODE) return refused("failed", dispatched);
-  return { kind: "launched", pid: dispatched.out };
-}
-async function launch_lane(context) {
-  return await lane_launch_admission.launch(context, launch_admitted);
-}
-async function launch_ready_lane(context) {
-  return await lane_launch_pending.launch(context, launch_admitted);
-}
-async function launch3(context) {
-  const outcome = await launch_lane(context);
-  if (outcome.kind !== "launched") return FAILURE_EXIT_CODE;
-  console.info(outcome.pid);
-  return SUCCESS_EXIT_CODE;
-}
-async function run(argv) {
-  const context = read_context(argv);
-  if (context === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  return await launch3(context);
-}
-var lane_launch_cli = {
-  keep_pending: lane_launch_pending.keep,
-  launch_lane,
-  launch_ready_lane,
-  read_context,
-  run
-};
-
-export {
-  lane_launch_cli
-};