@yagni-app/code-staging 0.0.0 → 0.1.0-staging.1002.1

package/dist/extension/decisions.js

@@ -0,0 +1,200 @@
+/**
+ * The client-side decisions surface (spec §4, W4): the `/decide` and
+ * `/decisions` commands plus the shared write helper the bless-capture flow
+ * reuses.
+ *
+ *  - `bankDecision` POSTs a `source: 'cli_correction'` decision with a generated
+ *    idempotencyKey through the durable write-spool (part A), so a transport
+ *    failure or 5xx spools it for replay instead of losing it, and a replay can
+ *    never double-bank (server dedups on the key).
+ *  - `fetchDecisions` / `supersedeDecision` reuse the shared authed-fetch seam,
+ *    so a GET/PATCH inherits the one 401-refresh-then-retry-once behaviour.
+ *  - `/decide <question> => <decision>` records ONE decision directly (the user
+ *    typed it — explicit intent, no extra confirm or debounce).
+ *  - `/decisions` lists recent decisions (id-prefixed, compact); `/decisions
+ *    supersede <id>` flips one to superseded.
+ *
+ * Formatters and the arg parser are pure; the network calls are injectable via
+ * the shared `SpoolClientOpts` so tests never touch disk or the network.
+ */
+import { randomUUID } from "node:crypto";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+import { sendOrSpool } from "./spool.js";
+/**
+ * Bank a `cli_correction` decision durably. Every logical write carries a
+ * generated idempotencyKey; the backend dedups on it, so a spool replay or a
+ * 401 retry can never bank the same decision twice. Transport failures and 5xx
+ * are spooled for replay instead of lost (R4 write half). Never throws.
+ */
+export function bankDecision(opts, params, signal) {
+    const idempotencyKey = (opts.makeIdempotencyKey ?? randomUUID)();
+    return sendOrSpool(opts, "record_decision", "/api/yagni-code/decisions", {
+        question: params.question,
+        decision: params.decision,
+        rationale: params.rationale,
+        repo: params.repo,
+        source: "cli_correction",
+    }, idempotencyKey, signal);
+}
+export const DEFAULT_LIST_LIMIT = 20;
+/** GET recent decisions (any read scope). Throws a friendly error on non-2xx. */
+export async function fetchDecisions(opts, list = {}, signal) {
+    const limit = list.limit ?? DEFAULT_LIST_LIMIT;
+    const query = new URLSearchParams({ limit: String(limit) });
+    if (list.repo)
+        query.set("repo", list.repo);
+    const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/decisions?${query.toString()}`, { method: "GET", headers: { authorization: `Bearer ${opts.getToken() ?? ""}` } }, { fetchImpl: opts.fetchImpl, signal });
+    if (!res.ok)
+        throw new Error(await friendlyFetchError("list decisions", res));
+    const data = (await res.json());
+    return Array.isArray(data.decisions) ? data.decisions : [];
+}
+/**
+ * PATCH one decision to `superseded` (scope yagni_code:write). Idempotent flip,
+ * so a single attempt is enough — no client retry (invariant §0.8). Throws a
+ * friendly error on non-2xx.
+ */
+export async function supersedeDecision(opts, id, supersededBy, signal) {
+    const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/decisions/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${opts.getToken() ?? ""}`,
+        },
+        body: JSON.stringify({ status: "superseded", ...(supersededBy ? { supersededBy } : {}) }),
+    }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+    if (!res.ok)
+        throw new Error(await friendlyFetchError("supersede decision", res));
+}
+/** Pure: parse `<question> => <decision>`; null when either half is missing. */
+export function parseDecideArgs(raw) {
+    const idx = raw.indexOf("=>");
+    if (idx < 0)
+        return null;
+    const question = raw.slice(0, idx).trim();
+    const decision = raw.slice(idx + 2).trim();
+    if (!question || !decision)
+        return null;
+    return { question, decision };
+}
+/** Pure: a short id prefix for compact display. */
+export function shortId(id) {
+    return id.slice(0, 8);
+}
+/** Pure: render the compact, id-prefixed decisions list (no em-dashes). */
+export function formatDecisionsList(items) {
+    if (items.length === 0) {
+        return "No decisions recorded yet. Use /decide <question> => <decision> to bank one.";
+    }
+    const header = `Recorded decisions (${items.length}):`;
+    const lines = items.map((d) => {
+        const flag = d.status === "active" ? "" : ` [${d.status}]`;
+        const cited = d.citedCount > 0 ? ` (cited ${d.citedCount})` : "";
+        return `${shortId(d.id)}${flag} ${d.question} => ${d.decision}${cited}`;
+    });
+    return [header, ...lines].join("\n");
+}
+/**
+ * Resolve a displayed short-id prefix (or a full id) to the full decision id by
+ * matching against the current list. Returns the full id, the raw arg when no
+ * match is found (let the backend answer an honest 404), or "ambiguous" when
+ * more than one decision shares the prefix. Fail-soft: a list error falls back
+ * to the raw arg.
+ */
+async function resolveDecisionId(opts, arg, signal) {
+    let items = [];
+    try {
+        items = await fetchDecisions(opts, {}, signal);
+    }
+    catch {
+        return arg; // cannot resolve → let the PATCH itself surface the outcome
+    }
+    const matches = items.filter((d) => d.id === arg || d.id.startsWith(arg));
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length > 1)
+        return "ambiguous";
+    return arg;
+}
+/** A friendly one-liner for a bank outcome, or null when nothing to say. */
+function bankOutcomeNotice(outcome) {
+    if (outcome.kind === "ok")
+        return { message: "Recorded the decision in YAGNI.", type: "info" };
+    if (outcome.kind === "spooled") {
+        return {
+            message: `Could not reach YAGNI (${outcome.reason}). Saved the decision locally; it will sync automatically.`,
+            type: "warning",
+        };
+    }
+    return { message: outcome.message, type: "error" };
+}
+/**
+ * Wire the `/decide` and `/decisions` commands. Both are fail-soft: any
+ * transport error surfaces as an honest notice, never a thrown command.
+ */
+export function registerDecisionCommands(pi, opts) {
+    pi.registerCommand("decide", {
+        description: "Record a product-intent decision directly: /decide <question> => <decision>. YAGNI answers the same question next time.",
+        handler: async (args, ctx) => {
+            const notify = (m, t) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(m, t);
+            };
+            const parsed = parseDecideArgs(args);
+            if (!parsed) {
+                notify("Usage: /decide <question> => <decision>", "warning");
+                return;
+            }
+            try {
+                const outcome = await bankDecision(opts, { question: parsed.question, decision: parsed.decision }, ctx.signal);
+                const notice = bankOutcomeNotice(outcome);
+                notify(notice.message, notice.type);
+            }
+            catch (err) {
+                notify(`Could not record the decision: ${err instanceof Error ? err.message : String(err)}`, "error");
+            }
+        },
+    });
+    pi.registerCommand("decisions", {
+        description: "List recent recorded decisions. /decisions supersede <id> marks one superseded.",
+        handler: async (args, ctx) => {
+            const notify = (m, t) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(m, t);
+            };
+            const trimmed = args.trim();
+            if (trimmed.toLowerCase().startsWith("supersede")) {
+                const arg = trimmed.slice("supersede".length).trim();
+                if (!arg) {
+                    notify("Usage: /decisions supersede <id>", "warning");
+                    return;
+                }
+                try {
+                    // The list shows short id prefixes, so resolve the argument against
+                    // the current list to the full UUID the backend PATCH requires. A
+                    // failed lookup falls through with the raw arg (the backend then
+                    // answers an honest 404).
+                    const id = await resolveDecisionId(opts, arg, ctx.signal);
+                    if (id === "ambiguous") {
+                        notify(`Ambiguous decision id "${arg}"; use more characters.`, "warning");
+                        return;
+                    }
+                    await supersedeDecision(opts, id, undefined, ctx.signal);
+                    notify(`Superseded decision ${shortId(id)}.`, "info");
+                }
+                catch (err) {
+                    notify(`Could not supersede decision: ${err instanceof Error ? err.message : String(err)}`, "error");
+                }
+                return;
+            }
+            try {
+                const items = await fetchDecisions(opts, {}, ctx.signal);
+                await pi.sendUserMessage(formatDecisionsList(items));
+            }
+            catch (err) {
+                notify(`Could not list decisions: ${err instanceof Error ? err.message : String(err)}`, "error");
+            }
+        },
+    });
+}
+//# sourceMappingURL=decisions.js.map

package/dist/extension/diagnostics.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CLI diagnostics for the image-paste feature — layer C of the
+ * observability decision (A=debug flag, B=backend events, C=local log+report).
+ *
+ * The CLI is a terminal app, so it cannot log to stdout without corrupting the
+ * TUI. Instead it appends sanitized, single-line JSON events to a small
+ * rotating log under `~/.yagni-code/logs/`. "Sanitized" means event names,
+ * counts, mime types, byte sizes, and boolean outcomes — NEVER image bytes,
+ * message content, tokens, or file contents. Paths are recorded by basename
+ * only (the tmp `clipboard-*.png` name), never the full directory.
+ *
+ * A support flow can tail this file and POST it with the user's consent;
+ * nothing is uploaded automatically.
+ */
+export declare function _setDiagnosticsHomeForTest(dir: string | null): void;
+export declare function diagnosticsLogPath(): string;
+/** Layer A: verbose mode. `YAGNI_DEBUG=1` (or "true") turns on extra detail. */
+export declare function isDebug(env?: NodeJS.ProcessEnv): boolean;
+export interface ImagePasteEvent {
+    /** Stable event name: "paste_path" | "chip_drop" | "transform" | "backend_status". */
+    event: string;
+    /** Outcome: "ok" | "passthrough" | "error" | a status code as string. */
+    outcome?: string;
+    mimeType?: string;
+    bytes?: number;
+    imageCount?: number;
+    /** basename of the tmp image file only (never a full path). */
+    file?: string;
+    /** Extra debug-only detail; written only when YAGNI_DEBUG is on. */
+    detail?: string;
+}
+/**
+ * Append one sanitized event. Fail-soft: a logging failure must never break the
+ * prompt. `detail` is included only when YAGNI_DEBUG is on.
+ */
+export declare function logImagePaste(ev: ImagePasteEvent): void;
+/** Read the most recent log content (for a user-triggered report). */
+export declare function readRecentDiagnostics(maxBytes?: number): string;
+/** List existing diagnostic log files (active + rotations), for a report. */
+export declare function listDiagnosticFiles(): string[];
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/extension/diagnostics.js

@@ -0,0 +1,110 @@
+/**
+ * CLI diagnostics for the image-paste feature — layer C of the
+ * observability decision (A=debug flag, B=backend events, C=local log+report).
+ *
+ * The CLI is a terminal app, so it cannot log to stdout without corrupting the
+ * TUI. Instead it appends sanitized, single-line JSON events to a small
+ * rotating log under `~/.yagni-code/logs/`. "Sanitized" means event names,
+ * counts, mime types, byte sizes, and boolean outcomes — NEVER image bytes,
+ * message content, tokens, or file contents. Paths are recorded by basename
+ * only (the tmp `clipboard-*.png` name), never the full directory.
+ *
+ * A support flow can tail this file and POST it with the user's consent;
+ * nothing is uploaded automatically.
+ */
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, } from "node:fs";
+import { dirname, join, basename } from "node:path";
+import { codeStateHome } from "./stateHome.js";
+/** Test seam (mirrors `_setYagniCodeHomeForTest`): point the log at a tmpdir. */
+let homeOverride = null;
+export function _setDiagnosticsHomeForTest(dir) {
+    homeOverride = dir;
+}
+function yagniCodeHome() {
+    return codeStateHome(homeOverride);
+}
+export function diagnosticsLogPath() {
+    return join(yagniCodeHome(), "logs", "image-paste.log");
+}
+const MAX_LOG_BYTES = 256 * 1024; // rotate the active file past this
+const KEEP_ROTATIONS = 2; // keep image-paste.log.1 and .2 alongside the active file
+/** Layer A: verbose mode. `YAGNI_DEBUG=1` (or "true") turns on extra detail. */
+export function isDebug(env = process.env) {
+    const v = env.YAGNI_DEBUG;
+    return v === "1" || v === "true";
+}
+/**
+ * Append one sanitized event. Fail-soft: a logging failure must never break the
+ * prompt. `detail` is included only when YAGNI_DEBUG is on.
+ */
+export function logImagePaste(ev) {
+    try {
+        // Hermetic under `node --test`: never touch the real home dir from a test
+        // unless the test explicitly stubbed it. Writing to the runner's $HOME made
+        // the suite's exit depend on the CI filesystem (a read-only or slow $HOME
+        // could stall the write), which is the leading suspect for the CI hang.
+        if (process.env.NODE_TEST_CONTEXT && homeOverride === null)
+            return;
+        const line = {
+            ts: new Date().toISOString(),
+            event: ev.event,
+            ...(ev.outcome !== undefined ? { outcome: ev.outcome } : {}),
+            ...(ev.mimeType !== undefined ? { mimeType: ev.mimeType } : {}),
+            ...(ev.bytes !== undefined ? { bytes: ev.bytes } : {}),
+            ...(ev.imageCount !== undefined ? { imageCount: ev.imageCount } : {}),
+            ...(ev.file !== undefined ? { file: basename(ev.file) } : {}),
+            ...(ev.detail !== undefined && isDebug() ? { detail: ev.detail } : {}),
+        };
+        const path = diagnosticsLogPath();
+        mkdirSync(dirname(path), { recursive: true });
+        rotateIfNeeded(path);
+        appendFileSync(path, JSON.stringify(line) + "\n", "utf8");
+    }
+    catch {
+        /* logging must never throw into the editor */
+    }
+}
+/** Shift image-paste.log -> .1 -> .2 once the active file passes the size cap. */
+function rotateIfNeeded(path) {
+    try {
+        if (statSync(path).size < MAX_LOG_BYTES)
+            return;
+        for (let i = KEEP_ROTATIONS; i >= 1; i--) {
+            const from = i === 1 ? path : `${path}.${i - 1}`;
+            const to = `${path}.${i}`;
+            try {
+                renameSync(from, to);
+            }
+            catch {
+                /* absent source — fine */
+            }
+        }
+    }
+    catch {
+        /* rotation is best-effort */
+    }
+}
+/** Read the most recent log content (for a user-triggered report). */
+export function readRecentDiagnostics(maxBytes = 64 * 1024) {
+    try {
+        const data = readFileSync(diagnosticsLogPath(), "utf8");
+        return data.length > maxBytes ? data.slice(data.length - maxBytes) : data;
+    }
+    catch {
+        return "";
+    }
+}
+/** List existing diagnostic log files (active + rotations), for a report. */
+export function listDiagnosticFiles() {
+    try {
+        const dir = dirname(diagnosticsLogPath());
+        return readdirSync(dir)
+            .filter((f) => f.startsWith("image-paste.log"))
+            .sort()
+            .map((f) => join(dir, f));
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/extension/index.d.ts

@@ -0,0 +1,116 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runInitPass as defaultRunInitPass } from "./initPass.js";
+import { type FlushOutcome, type SpoolClientOpts } from "./spool.js";
+import { type TokenProvider } from "./tokenProvider.js";
+import { type ContextBrief, type ModelEntry } from "./config.js";
+/**
+ * YAGNI Code extension entry point.
+ *
+ * pi awaits async factory functions before startup, so fetching the model
+ * catalog here is safe. The factory:
+ *  1. registers the `yagni` model provider (catalog fetched from the backend),
+ *  2. registers the `ask_yagni` tool,
+ *  3. rebrands the system prompt as YAGNI Code on every turn (no "pi" leaks), and
+ *  4. sets the terminal title + a footer brand mark.
+ *
+ * If the catalog fetch fails, the error propagates (fail loud) carrying an
+ * actionable `yagni login` message.
+ */
+/** Injectable seams so the factory is unit-testable without pi or a network. */
+export interface RegisterYagniDeps {
+    baseUrl?: string;
+    getToken?: () => string | undefined;
+    /** The token's ISO expiry, forwarded by the launcher (for the expiry notice). */
+    getTokenExpiresAt?: () => string | undefined;
+    /** Clock seam for the expiry notice (defaults to Date.now). */
+    now?: () => number;
+    fetchImpl?: typeof fetch;
+    fetchCatalog?: (opts: {
+        baseUrl: string;
+        getToken: () => string | undefined;
+        fetchImpl?: typeof fetch;
+    }) => Promise<ModelEntry[]>;
+    fetchContextBrief?: (opts: {
+        baseUrl: string;
+        getToken: () => string | undefined;
+        fetchImpl?: typeof fetch;
+    }) => Promise<ContextBrief | null>;
+    /**
+     * The CLI init pass (Onramp Door B). Injectable so tests assert it fires on a
+     * fresh-workspace first-run and is skipped otherwise, without a network or disk.
+     */
+    runInitPass?: typeof defaultRunInitPass;
+    /** The workspace id the token is bound to (keys the one-time init marker). */
+    getWorkspaceId?: () => string | undefined;
+    /** Has the init pass already run once for this workspace? Injectable (no disk in tests). */
+    isInitDone?: (workspaceId: string) => boolean;
+    /** Record that the init pass ran once for this workspace. Injectable (no disk in tests). */
+    markInitDone?: (workspaceId: string) => void;
+    /**
+     * The refreshing token provider (spec §4). Injectable so tests control the
+     * rotation surface; the default provider seeds from `getToken`/
+     * `getTokenExpiresAt` (falling back to the env) and owns the proactive
+     * refresh timer + the 401 refresh-and-retry-once seam.
+     */
+    tokenProvider?: TokenProvider;
+    /** The spool flush (R4 write half), injectable so tests never touch disk. */
+    flushSpool?: (opts: SpoolClientOpts) => Promise<FlushOutcome>;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function registerYagni(pi: ExtensionAPI, deps?: RegisterYagniDeps): Promise<void>;
+export default function (pi: ExtensionAPI): Promise<void>;
+export { makeAskYagniTool } from "./askYagniTool.js";
+export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
+export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
+export type { Citation, MakeAskYagniToolOptions } from "./askYagniTool.js";
+export { makeReviewBusinessMatchTool } from "./reviewTool.js";
+export type { MakeReviewToolOptions } from "./reviewTool.js";
+export { makeRecordEngineeringContextTool } from "./recordContextTool.js";
+export type { MakeRecordContextToolOptions } from "./recordContextTool.js";
+export { makeRecordDecisionTool } from "./recordDecisionTool.js";
+export type { MakeRecordDecisionToolOptions } from "./recordDecisionTool.js";
+export { makeSuggestNextWorkTool, defaultNextAction } from "./nextWorkTool.js";
+export type { MakeNextWorkToolOptions, DefaultNextAction, NextActionOption, } from "./nextWorkTool.js";
+export { recordDecision } from "./recordDecisionTool.js";
+export type { RecordDecisionParams } from "./recordDecisionTool.js";
+export { runInitPass, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
+export type { RunInitPassDeps, InitPassOutcome, RepoIntake, RepoIntakeFs, RepoAdr, EngineeringDraft, DraftTeam, } from "./initPass.js";
+export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
+export { brandSystemPrompt, YAGNI_IDENTITY, BRAND_NAME } from "./branding.js";
+export { fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl } from "./config.js";
+export type { FetchCatalogOptions, ModelEntry } from "./config.js";
+export { buildYagniProvider } from "./provider.js";
+export { registerGoCommand } from "./pipeline/goCommand.js";
+export type { RegisterGoDeps } from "./pipeline/goCommand.js";
+export { runPipeline } from "./pipeline/orchestrator.js";
+export type { RunPipelineDeps } from "./pipeline/orchestrator.js";
+export { withResilience, classifyTransient, composeAbortSignal } from "./pipeline/resilience.js";
+export type { ResilienceAttemptRecord, ResilienceSeams, RunStageFn } from "./pipeline/resilience.js";
+export { DEFAULT_RESILIENCE_POLICY } from "./pipeline/types.js";
+export type { ResiliencePolicy } from "./pipeline/types.js";
+export { buildVerifyEnv, detectVerifyCommand, makeRunVerify, parseVerifyFailures } from "./pipeline/verify.js";
+export type { VerifyCommand, VerifyOutcome } from "./pipeline/verify.js";
+export { blindStages, reportOnlyStages, makeGroundedVsBlindEval, formatComparisonReport } from "./pipeline/eval.js";
+export type { ComparisonReport, LaneFit, LaneOutcome } from "./pipeline/eval.js";
+export { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
+export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
+export type { SubagentDef, SubagentSource } from "./subagents.js";
+export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, todoSummary, TODO_TOOL_NAME, MAX_TODOS, } from "./todos.js";
+export type { TodoItem, TodoStatus, TodoTheme } from "./todos.js";
+export { decideGate, registerPermissionGate, filterStalePlanContext, DEFAULT_PERMISSION_POLICY, PLAN_CONTEXT_TYPE, PLAN_CONTEXT_MESSAGE, } from "./permission.js";
+export type { PermissionMode, PermissionPolicy, GateDecision, RegisterPermissionDeps, BlessRememberInfo, } from "./permission.js";
+export { makeBlessStore, blessPath } from "./bless.js";
+export type { BlessStore, BlessRule } from "./bless.js";
+export { bankDecision, fetchDecisions, supersedeDecision, parseDecideArgs, formatDecisionsList, shortId, registerDecisionCommands, DEFAULT_LIST_LIMIT, } from "./decisions.js";
+export type { DecisionClientOpts, DecisionListItem, BankDecisionParams, DecideArgs } from "./decisions.js";
+export { makeDecisionCapture, CAPTURE_DEBOUNCE_MS } from "./decisionCapture.js";
+export type { DecisionCapture, DecisionCaptureDeps, BlessCaptureInfo, CaptureCtx } from "./decisionCapture.js";
+export { registerAmbientRecall, fetchRecall, formatRecallBlock, toRepoRelativePath, normalizeRecall, RECALL_TIMEOUT_MS, RECALL_MIN_DECISIONS, } from "./recall.js";
+export type { RecallResult, RecallClientOpts, RegisterRecallDeps } from "./recall.js";
+export { makeCostAccumulator, formatCostLine, registerCostCommand } from "./costHud.js";
+export type { CostSnapshot, Headroom } from "./costHud.js";
+export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE_REFRESH_WINDOW_MS, REFRESH_RETRY_MS, } from "./tokenProvider.js";
+export type { TokenProvider, TokenProviderDeps, ScheduleFn } from "./tokenProvider.js";
+export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
+export type { SpoolEntry, SpoolClientOpts, FlushOutcome, JudgmentWriteOutcome } from "./spool.js";
+//# sourceMappingURL=index.d.ts.map