bareloop 0.30.0 → 0.32.0

package/types/config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @param {string} [home] test seam; production never passes it
+ * @returns {string} `<home>/config.json`
+ */
+export function configPath(home?: string): string;
+/**
+ * @typedef {object} ConfigRead
+ * @property {Record<string, any>} config the parsed document ({} when missing/unreadable)
+ * @property {boolean} exists
+ * @property {string|null} problem plain words when the file is there but unreadable
+ */
+/**
+ * @param {{ home?: string }} [opts]
+ * @returns {ConfigRead}
+ */
+export function readConfig(opts?: {
+    home?: string;
+}): ConfigRead;
+/**
+ * Apply a patch and write. `null` deletes a field. Top-level fields shallow-merge;
+ * `keys` merges per key variable name, then per field. Validated before anything is
+ * written; nothing is written on a refusal.
+ *
+ * Patch fields understood: `monthlyLimitUsd` (finite > 0), `anthropicBalanceNote`
+ * (finite >= 0), `keys.<ENV NAME>.{name,shape,baseUrl}` (Name = a model id, shape = a provider table name, baseUrl = blank or http(s)). Any other
+ * field is passed through untouched (kept), but the whole document is swept for
+ * secret-shaped strings first.
+ * @param {Record<string, any>} patch
+ * @param {{ home?: string }} [opts]
+ * @returns {Record<string, any>} the document as written
+ */
+export function updateConfig(patch: Record<string, any>, opts?: {
+    home?: string;
+}): Record<string, any>;
+/** A plain-words config failure (bad value, secret-shaped string, unreadable file). */
+export class ConfigError extends Error {
+}
+export type ConfigRead = {
+    /**
+     * the parsed document ({} when missing/unreadable)
+     */
+    config: Record<string, any>;
+    exists: boolean;
+    /**
+     * plain words when the file is there but unreadable
+     */
+    problem: string | null;
+};

package/types/interviewrun.d.ts

@@ -1,6 +1,7 @@
 /**
  * @typedef {object} Deps
  * @property {Record<string,string|undefined>} [env]
+ * @property {string} [keysHome] P4a — test seam: load this home's `.env` keys file even when `env` is injected.
  * @property {NodeJS.ReadStream} [stdin]
  * @property {NodeJS.WritableStream} [stdout]
  * @property {NodeJS.WritableStream} [stderr]
@@ -25,6 +26,10 @@
 export function main(argv: string[], deps?: Deps): Promise<number>;
 export type Deps = {
     env?: Record<string, string | undefined> | undefined;
+    /**
+     * P4a — test seam: load this home's `.env` keys file even when `env` is injected.
+     */
+    keysHome?: string | undefined;
     stdin?: NodeJS.ReadStream | undefined;
     stdout?: NodeJS.WritableStream | undefined;
     stderr?: NodeJS.WritableStream | undefined;

package/types/keysfile.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `~/.config/bareloop` (or the injected override) — same home every other
+ * per-person file (runs.jsonl, config.json) lives in.
+ * @param {string} [home] test seam; production never passes it
+ * @returns {string}
+ */
+export function keysHome(home?: string): string;
+/**
+ * @param {string} [home]
+ * @returns {string} `<home>/.env`
+ */
+export function keysFilePath(home?: string): string;
+/**
+ * Parse the file's text. Lines that are not `NAME=value` are skipped silently
+ * (never echoed — a malformed line may hold a secret).
+ * @param {string} text
+ * @returns {Record<string,string>}
+ */
+export function parseKeysText(text: string): Record<string, string>;
+/**
+ * The NAMES in the file that carry a non-empty value, in file order — the Providers rows
+ * (an empty preset line is not a row). Names only; a missing/unreadable file = none.
+ * @param {string} [home]
+ * @returns {string[]}
+ */
+export function filledKeyNames(home?: string): string[];
+/**
+ * Create the keys file with the five empty preset lines when — and only when — it does not
+ * exist (mode 600). An existing file is never touched.
+ * @param {readonly string[]} presetNames the names to seed, in order
+ * @param {string} [home]
+ * @returns {boolean} true if it was created
+ */
+export function ensureKeysFile(presetNames: readonly string[], home?: string): boolean;
+/**
+ * @typedef {object} KeysLoad
+ * @property {boolean} exists the file is there
+ * @property {string[]} names the NAMES the file defines (sorted; never values)
+ * @property {string|null} warning a plain-words warning (file readable by others, or
+ *   unreadable), else null — a warning, never a refusal
+ * @property {Record<string,string|undefined>} env shell env with the file filling the
+ *   names the shell does not set. THE ONLY place values leave this module.
+ */
+/**
+ * Load the keys file over an env. Missing file is fine (no names, env unchanged).
+ * @param {{ env?: Record<string,string|undefined>, home?: string }} [opts]
+ * @returns {KeysLoad}
+ */
+export function loadKeysEnv(opts?: {
+    env?: Record<string, string | undefined>;
+    home?: string;
+}): KeysLoad;
+/**
+ * The door helper the CLI and the panel call: load the file only when the caller is
+ * on the REAL environment (no injected env) or names a keys home explicitly — so a
+ * test that injects `env` alone never reads the real `~/.config/bareloop/.env`.
+ * @param {{ env?: Record<string,string|undefined>, keysHome?: string }} deps
+ * @returns {KeysLoad & { env: Record<string,string|undefined>, home: string|undefined }}
+ *   `home` = the home the file was loaded from (the real `~/.config/bareloop` when none was
+ *   injected) — or `undefined` when loading was skipped (injected env, no keysHome). The
+ *   door passes it on so config.json (src/config.js) is read from the SAME place, and never
+ *   from the real home in a test.
+ */
+export function keysForDoor(deps: {
+    env?: Record<string, string | undefined>;
+    keysHome?: string;
+}): KeysLoad & {
+    env: Record<string, string | undefined>;
+    home: string | undefined;
+};
+export type KeysLoad = {
+    /**
+     * the file is there
+     */
+    exists: boolean;
+    /**
+     * the NAMES the file defines (sorted; never values)
+     */
+    names: string[];
+    /**
+     * a plain-words warning (file readable by others, or
+     * unreadable), else null — a warning, never a refusal
+     */
+    warning: string | null;
+    /**
+     * shell env with the file filling the
+     * names the shell does not set. THE ONLY place values leave this module.
+     */
+    env: Record<string, string | undefined>;
+};

package/types/ledger.d.ts

@@ -81,6 +81,20 @@ export function spendProvenance(events: any[]): {
     unpriced: ProvenanceBucket;
     unknown: ProvenanceBucket;
 };
+/**
+ * The priced-rounds spend floor + first-record→last-record wall floor,
+ * derived straight off the spine's raw records — the same derivation a
+ * died run's "at least …" figures use, factored out so build item 6
+ * (2026-09-28) can hand a genuinely-still-running spine the identical
+ * floor instead of "unknown" on the Run tab, without a second copy of this
+ * math.
+ * @param {any[]} records raw parsed spine records
+ * @returns {{spendFloorUsd: number|null, wallFloorMs: number|null}}
+ */
+export function floorsFromRecords(records: any[]): {
+    spendFloorUsd: number | null;
+    wallFloorMs: number | null;
+};
 /** severity order, worst-first (the fold's display order; frequency ranks within) */
 export const LEDGER_CLASSES: readonly string[];
 /**

package/types/monthly.d.ts

@@ -0,0 +1,192 @@
+/**
+ * One run's own spend, off its spine records: this LEG's figure (never the chain fold),
+ * plus the drafting spend the run was signed with (counted once — on the first leg only).
+ * @param {any[]} records
+ * @returns {{ usd: number, complete: boolean }}
+ */
+export function legSpend(records: any[]): {
+    usd: number;
+    complete: boolean;
+};
+/**
+ * One run's wall time off its spine: job-start -> job-end when the run ended (exact), else the
+ * first -> last record floor (the SAME floor a died / still-running run's "at least" wall uses,
+ * `floorsFromRecords`). `ms` null = unknown — never 0.
+ * @param {any[]} records
+ * @returns {{ ms: number|null, complete: boolean }}
+ */
+export function legWall(records: any[]): {
+    ms: number | null;
+    complete: boolean;
+};
+/**
+ * Tokens a spine's rounds processed (input + output + cache read + cache write — all four,
+ * so a cache-heavy run is not under-reported), off the real `usage` field names.
+ * @param {any[]} records
+ * @returns {number}
+ */
+export function legTokens(records: any[]): number;
+/**
+ * Every listed run as one {@link Leg}. The ONE reader the month total, the all-time total
+ * and the per-provider figures share.
+ * @param {{ home?: string, now?: () => number, resumingSpine?: string|null }} [opts] `now` = the clock for the in-flight test; `resumingSpine` = the spine a resume continues: that leg reserves its spend only, never its unspent cap (the resume's own leg cap is that remainder)
+ * @returns {Leg[]}
+ */
+export function readLegs(opts?: {
+    home?: string;
+    now?: () => number;
+    resumingSpine?: string | null;
+}): Leg[];
+/**
+ * @param {{ home?: string, now?: () => number, resumingSpine?: string|null }} [opts] `resumingSpine`: see {@link readLegs}
+ * @returns {{ usd: number, atLeast: boolean, runs: number, reservedUsd: number }} `usd` = real spend (the Money tab's figure); `reservedUsd` = the same with in-flight runs at their cap (the refusal check's)
+ */
+export function monthSpend(opts?: {
+    home?: string;
+    now?: () => number;
+    resumingSpine?: string | null;
+}): {
+    usd: number;
+    atLeast: boolean;
+    runs: number;
+    reservedUsd: number;
+};
+/**
+ * The Money tab's figures: all-time and this-month spend, and per-provider breakdown
+ * (rows from `rowIdFor`; a run on no known row lands under its own provider name, never
+ * pooled into another row). Any leg with unknown spend makes the figure it belongs to
+ * an "at least".
+ * @param {{ home?: string, now?: () => number, rows?: readonly import('./providerrows.js').KeyRow[] }} [opts] `rows` = the Providers rows: when given, `tokensByRow` sums each row's tokens
+ * @returns {{ tokensByRow: Record<string, number>, total: {usd: number, atLeast: boolean, tokens: number}, month: {usd: number, atLeast: boolean, tokens: number},
+ *   byProvider: Record<string, {label: string, monthUsd: number, monthAtLeast: boolean, totalUsd: number, totalAtLeast: boolean, tokens: number, vouchedRounds: number, otherRounds: number, monthWallMs: number|null, monthWallAtLeast: boolean, totalWallMs: number|null, totalWallAtLeast: boolean}> }}
+ */
+export function spendSummary(opts?: {
+    home?: string;
+    now?: () => number;
+    rows?: readonly import("./providerrows.js").KeyRow[];
+}): {
+    tokensByRow: Record<string, number>;
+    total: {
+        usd: number;
+        atLeast: boolean;
+        tokens: number;
+    };
+    month: {
+        usd: number;
+        atLeast: boolean;
+        tokens: number;
+    };
+    byProvider: Record<string, {
+        label: string;
+        monthUsd: number;
+        monthAtLeast: boolean;
+        totalUsd: number;
+        totalAtLeast: boolean;
+        tokens: number;
+        vouchedRounds: number;
+        otherRounds: number;
+        monthWallMs: number | null;
+        monthWallAtLeast: boolean;
+        totalWallMs: number | null;
+        totalWallAtLeast: boolean;
+    }>;
+};
+/**
+ * @typedef {object} MonthlyRoom
+ * @property {boolean} ok
+ * @property {number|null} leftUsd what is left this month (null = no limit set)
+ * @property {number|null} limitUsd the person's monthly limit (null = none)
+ * @property {boolean} atLeast the month's spend is a floor, so `leftUsd` is a ceiling
+ */
+/**
+ * The person's monthly limit off a parsed config.json: key absent (or null) = no limit (null);
+ * a number above 0 = the limit; ANY other value present is a broken setting and throws
+ * `ConfigError` — a limit the file names but this code cannot read never reads as "no limit".
+ * @param {Record<string, any>} config
+ * @param {string} [home]
+ * @returns {number|null}
+ */
+export function monthlyLimitOf(config: Record<string, any>, home?: string): number | null;
+/**
+ * Does a run with this $ cap fit in what is left this month (running jobs counted at their full cap, except the spine a resume continues — `resumingSpine` — which counts its real spend)? No limit set (key absent or null) = ok, no check; a limit that is present but not a
+ * number above 0 throws `ConfigError`.
+ * Compared in whole cents. Also throws `ConfigError` when config.json is unreadable — a gate
+ * whose own instrument is broken refuses; it never silently runs with no limit.
+ * @param {{ capUsd: number, home?: string, now?: () => number, resumingSpine?: string|null }} args
+ * @returns {MonthlyRoom}
+ */
+export function checkMonthlyRoom({ capUsd, home, now, resumingSpine }: {
+    capUsd: number;
+    home?: string;
+    now?: () => number;
+    resumingSpine?: string | null;
+}): MonthlyRoom;
+/**
+ * The ONE refusal text, everywhere (CLI, panel cap note, panel Sign refusal).
+ * @param {MonthlyRoom} room
+ * @returns {string|null} null when the run fits
+ */
+export function monthlyRefusalText(room: MonthlyRoom): string | null;
+export type Leg = {
+    /**
+     * when the run was listed
+     */
+    at: Date;
+    /**
+     * job-start's provider (null = an older spine that carried none)
+     */
+    provider: string | null;
+    baseUrl: string | null;
+    /**
+     * this leg's spend (a floor when `!complete`)
+     */
+    usd: number;
+    /**
+     * every figure behind `usd` is known
+     */
+    complete: boolean;
+    tokens: number;
+    /**
+     * job-start's model (older spines carry a model but no provider)
+     */
+    model: string | null;
+    /**
+     * this leg's wall time (null = unknown; a floor when `!wallComplete`)
+     */
+    wallMs: number | null;
+    /**
+     * the wall is the exact job-start -> job-end span
+     */
+    wallComplete: boolean;
+    /**
+     * rounds priced by a rate somebody vouched for (`provider`/`caller`)
+     */
+    vouchedRounds: number;
+    /**
+     * every other round: a built-in guess, unpriced, or no provenance on record
+     */
+    otherRounds: number;
+    /**
+     * what the refusal check counts: `usd`, or the leg's cap when the run is in flight
+     */
+    reservedUsd: number;
+    /**
+     * the spine was missing/unreadable or the listed date was bad (spend unknown)
+     */
+    unreadable: boolean;
+};
+export type MonthlyRoom = {
+    ok: boolean;
+    /**
+     * what is left this month (null = no limit set)
+     */
+    leftUsd: number | null;
+    /**
+     * the person's monthly limit (null = none)
+     */
+    limitUsd: number | null;
+    /**
+     * the month's spend is a floor, so `leftUsd` is a ceiling
+     */
+    atLeast: boolean;
+};

package/types/panel/authorroutes.d.ts

@@ -0,0 +1,67 @@
+/** @returns {string} a fresh per-process token — never persisted, never logged */
+export function mintToken(): string;
+/**
+ * `true` when a request may reach ANY route in this file — the token header
+ * plus an Origin/Host that names this exact bind address. `req.headers`
+ * lower-cases header names (node's own `http` behaviour), so this reads
+ * lower-case names throughout.
+ * @param {import('node:http').IncomingMessage} req
+ * @param {{token: string, port: number}} o
+ * @returns {{ok: true}|{ok: false, reason: string}}
+ */
+export function checkHumanGuard(req: import("node:http").IncomingMessage, { token, port }: {
+    token: string;
+    port: number;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Builds this file's own request handler, holding its session store in a
+ * closure (one per `createPanelServer` call, exactly like `handleRequest`'s
+ * own module holds none — this file owns the state `src/panel/server.js`
+ * deliberately has none of).
+ * @param {{ port: number, token: string, env?: Record<string,string|undefined>,
+ *   sessionsRoot?: string, spawnFn?: typeof realSpawn, bareloopBin?: string,
+ *   jobsDir?: string, fetchImpl?: typeof fetch, home?: string }} opts
+ */
+export function createAuthorRoutes(opts: {
+    port: number;
+    token: string;
+    env?: Record<string, string | undefined>;
+    sessionsRoot?: string;
+    spawnFn?: typeof realSpawn;
+    bareloopBin?: string;
+    jobsDir?: string;
+    fetchImpl?: typeof fetch;
+    home?: string;
+}): {
+    handle: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, pathname: string, body: any) => boolean;
+    sessions: Map<string, any>;
+};
+/**
+ * THE ONLY function in this file (or anywhere in the panel) that spawns a
+ * run. Refuses unless the session is `prepared` AND the hash the request
+ * carried matches the session's OWN `signing.json` `specHash` exactly — the
+ * click carries the hash (per the mockup's own "the person never has to copy
+ * it to sign"), and this is where it is checked, not trusted.
+ * @param {ReturnType<typeof createSession>} session
+ * @param {string} claimedHash
+ * @param {{env: any, spawnFn: typeof realSpawn, bareloopBin: string, sessionsRoot?: string, home?: string}} o
+ * @returns {{ok: boolean, error?: string, job?: string}}
+ */
+export function signRun(session: ReturnType<typeof createSession>, claimedHash: string, o: {
+    env: any;
+    spawnFn: typeof realSpawn;
+    bareloopBin: string;
+    sessionsRoot?: string;
+    home?: string;
+}): {
+    ok: boolean;
+    error?: string;
+    job?: string;
+};
+import { spawn as realSpawn } from 'node:child_process';
+import { createSession } from './authorsession.js';

package/types/panel/authorsession.d.ts

@@ -0,0 +1,53 @@
+/**
+ * `true` when `jobs/<name>.json` already exists in the repo's own jobs/ dir
+ * (resolved from THIS module's own on-disk location, never `process.cwd()`,
+ * the same rule `src/panel/server.js`'s `jobsDir()` follows) — P3 is new-jobs-
+ * only (Q4=A), so a name collision refuses at $0 rather than silently
+ * overwriting or authoring a second spec under one name.
+ * @param {string} name
+ * @param {{jobsDir?: string}} [opts] test seam
+ * @returns {boolean}
+ */
+export function jobNameTaken(name: string, opts?: {
+    jobsDir?: string;
+}): boolean;
+/**
+ * `$0` validation of the job card fields the server must check BEFORE it
+ * creates a session or spends anything — never inside the async pipeline,
+ * so a bad card refuses synchronously, in the same HTTP response.
+ * @param {any} card
+ * @param {{jobsDir?: string, rows?: readonly import('../providerrows.js').KeyRow[]}} [opts] `rows` = the Settings rows (the Model menu); jobsDir is a server-side test seam — NEVER read off the client card
+ * @returns {{ok: true}|{ok: false, error: string}}
+ */
+export function validateJobCard(card: any, opts?: {
+    jobsDir?: string;
+    rows?: readonly import("../providerrows.js").KeyRow[];
+}): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * ONE session's engine — created already RUNNING (the caller awaits nothing;
+ * the pipeline drives itself, reporting through `state`). `state.pendingAsk`
+ * is the ONE thing a person answers next; `answer()`/`send()`/`revise()`/
+ * `signPrepare()` are the only ways in.
+ * @param {any} card the validated job card (see {@link validateJobCard})
+ * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,
+ *   scout?: any, generate?: Function, confirmGenerate?: Function, authorFn?: Function,
+ *   prepareSigningFn?: Function}} [deps] the last five are TEST SEAMS ONLY — see the note
+ *   just above where each is read, below.
+ * @returns {any} the session object
+ */
+export function createSession(card: any, deps?: {
+    env?: Record<string, string | undefined>;
+    sessionsRoot?: string;
+    home?: string;
+    timeoutMs?: number;
+    scout?: any;
+    generate?: Function;
+    confirmGenerate?: Function;
+    authorFn?: Function;
+    prepareSigningFn?: Function;
+}): any;

package/types/panel/server.d.ts

@@ -200,13 +200,25 @@ export function getRunJob(runid: string, opts?: {
  * separately from {@link createPanelServer} so tests can drive it without a
  * real listening socket where that is simpler (most path-safety/405 tests
  * still go through a real socket, per the build spec).
+ *
+ * PANEL-BUILD.md P3: this file's own GET/HEAD-only rule stands for every
+ * route it owns; `/api/author/*` is the ONE family of routes that may be
+ * POSTed to, and it is handled entirely by {@link createAuthorRoutes}
+ * (`src/panel/authorroutes.js`) — a separate module so this file's own
+ * "read-only, by construction" header comment stays true of everything else
+ * in it. `opts.authorRoutes` is absent on every P1/P2 caller (read-only
+ * tests, and the CLI's own `panelMain` when no author routes are wired) —
+ * only `createPanelServer` below always supplies one.
  * @param {import('node:http').IncomingMessage} req
  * @param {import('node:http').ServerResponse} res
- * @param {{ home?: string, port: number }} opts
+ * @param {{ home?: string, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes> }} opts
  */
 export function handleRequest(req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, opts: {
     home?: string;
     port: number;
+    token?: string;
+    authorRoutes?: ReturnType<typeof createAuthorRoutes>;
+    settingsRoutes?: ReturnType<typeof createSettingsRoutes>;
 }): void;
 /**
  * Start the panel server. Binds `127.0.0.1` ONLY. A taken port is a LOUD,
@@ -214,15 +226,33 @@ export function handleRequest(req: import("node:http").IncomingMessage, res: imp
  * header). Resolves once actually listening; rejects on a bind error
  * (including `EADDRINUSE`) with a `.port` field on the error for the
  * caller's message.
- * @param {{ port?: number, home?: string }} [opts]
- * @returns {Promise<{ server: import('node:http').Server, port: number, close: () => Promise<void> }>}
+ *
+ * PANEL-BUILD.md P3: a fresh {@link mintToken} token and one {@link
+ * createAuthorRoutes} instance are built here, ONCE per server start, and
+ * held for the server's lifetime — `opts.env`/`opts.sessionsRoot`/
+ * `opts.spawnFn`/`opts.bareloopBin` are test seams the author routes take
+ * (a real caller passes none of them and {@link createAuthorRoutes} defaults
+ * each one to the real environment/spawn/binary, this file itself touching
+ * none of them, and the real
+ * `~/.config/bareloop/panel-sessions`, the real `child_process.spawn`, and
+ * this package's own `bin/bareloop.mjs`).
+ * @param {{ port?: number, home?: string, env?: Record<string,string|undefined>,
+ *   sessionsRoot?: string, spawnFn?: (...a: any[]) => any, bareloopBin?: string,
+ *   fetchImpl?: typeof fetch }} [opts]
+ * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, close: () => Promise<void> }>}
  */
 export function createPanelServer(opts?: {
     port?: number;
     home?: string;
+    env?: Record<string, string | undefined>;
+    sessionsRoot?: string;
+    spawnFn?: (...a: any[]) => any;
+    bareloopBin?: string;
+    fetchImpl?: typeof fetch;
 }): Promise<{
     server: import("node:http").Server;
     port: number;
+    token: string;
     close: () => Promise<void>;
 }>;
 /**
@@ -230,13 +260,17 @@ export function createPanelServer(opts?: {
  * Never picks a different port on collision (see file header): prints a
  * loud, named error to stderr and returns 1.
  * @param {string[]} argv
- * @param {{ out: (s: string) => void, err: (s: string) => void, runlistHome?: string }} ctx
+ * @param {{ out: (s: string) => void, err: (s: string) => void, runlistHome?: string, env?: Record<string,string|undefined> }} ctx
+ *   `env` is the RAW shell env (never the start-time merge with the keys file) — the routes
+ *   re-merge `~/.config/bareloop/.env` onto it per request so Reload keys is real;
+ *   undefined = the process env.
  * @returns {Promise<number>}
  */
 export function panelMain(argv: string[], ctx: {
     out: (s: string) => void;
     err: (s: string) => void;
     runlistHome?: string;
+    env?: Record<string, string | undefined>;
 }): Promise<number>;
 /**
  * A runid, as it appears in a URL path segment — never a raw filesystem
@@ -257,9 +291,12 @@ export const DEFAULT_PORT: 4700;
  * 2026-09-25).
  */
 export const SOFTGREEN_ADMITTED_ISO: "2026-08-18T00:00:00.000Z";
-export const DIED_MTIME_MS: number;
+export { DIED_MTIME_MS };
 /** The default/max page size for {@link getRunRounds} — tighten-only,
  * named so a future change is a deliberate, visible edit (item 5,
  * 2026-09-25). */
 export const ROUNDS_PAGE_DEFAULT: 50;
 export const ROUNDS_PAGE_MAX: 200;
+import { createAuthorRoutes } from './authorroutes.js';
+import { createSettingsRoutes } from './settingsroutes.js';
+import { DIED_MTIME_MS } from '../runlist.js';

package/types/panel/settingsroutes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {{ port: number, token: string, home?: string, env?: Record<string,string|undefined>,
+ *   fetchImpl?: typeof fetch, now?: () => number }} opts
+ */
+export function createSettingsRoutes(opts: {
+    port: number;
+    token: string;
+    home?: string;
+    env?: Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}): {
+    handle: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, pathname: string, body: any) => boolean;
+};