@cruxy/cli 1.0.3 → 1.0.4

package/dist/indexing/walker.d.ts

@@ -1,53 +0,0 @@
-/**
- * Repository walker for the index. Enumerates indexable text files under a root,
- * honoring `.gitignore` and `.cruxyignore` (nested files included), an
- * always-ignore set, a hard secrets denylist, a per-file size cap, and a binary
- * sniff. Yielded paths are project-relative and POSIX-separated.
- */
-/** A file the walker considers indexable. */
-export interface WalkEntry {
-    /** Project-relative POSIX path. */
-    relPath: string;
-    /** Absolute path on disk. */
-    absPath: string;
-    /** File size in bytes. */
-    size: number;
-}
-export interface WalkOptions {
-    /** Hard per-file size cap, in bytes. Larger files are skipped. */
-    maxFileBytes: number;
-    /** Ignore-file names to honor, relative to each directory (gitignore syntax). */
-    ignoreFileNames?: string[];
-    /**
-     * Yield binary files too (default false). The index never wants them; the
-     * checkpoint capturer (C.32) does — a snapshot must be complete to restore.
-     */
-    includeBinary?: boolean;
-}
-/**
- * The C.17 secrets denylist test, shared beyond the index: the checkpoint
- * capturer (C.32) applies the exact same rule so a working-tree snapshot can
- * never contain a secret-bearing file either.
- */
-export declare function isSecretPath(relPath: string): boolean;
-/**
- * A compiled set of gitignore-style patterns, matched against paths relative to
- * the file's own directory. Supports comments, blank lines, `!` negation,
- * leading-`/` anchoring, trailing-`/` directory-only rules, and `*`/`**`/`?`.
- */
-export declare class IgnoreMatcher {
-    private readonly rules;
-    constructor(patterns: string[]);
-    private add;
-    /**
-     * Decide whether `relPath` is ignored: `true`/`false` when a rule matches
-     * (last match wins), or `undefined` when no rule applies.
-     */
-    decide(relPath: string, isDir: boolean): boolean | undefined;
-}
-/**
- * Walk `root` and yield every indexable text file. Directories in the
- * always-ignore set are skipped wholesale; ignore files accumulate down the
- * tree; secret-bearing, oversized, and binary files are filtered out.
- */
-export declare function walkRepo(root: string, opts: WalkOptions): AsyncGenerator<WalkEntry>;

package/dist/jobs/approval-queue.d.ts

@@ -1,85 +0,0 @@
-import type { ApprovalDecision, RiskTier } from "../approval/index.js";
-/**
- * The single foreground pending-approval queue (C.28) — the seam that lets a
- * NON-interactive background job get a gated action approved by the ONE
- * interactive foreground human, without becoming a second interactive context.
- *
- * The §0 model: a background job is not a competing consumer of the terminal —
- * it is a PRODUCER on this queue. When a job hits a gated action it `submit`s the
- * request here and blocks on the returned promise; it holds no terminal, no
- * mutex, and (having released its execution slot) no compute while it waits. The
- * foreground drains the queue when it is idle (between turns): {@link serviceAll}
- * runs each request's `finalize` — the REAL U.3 prompt + checkpoint, serialized
- * through the shared approval mutex INSIDE `finalize` — and settles the producer
- * with the human's decision. Because the prompt happens on the foreground under
- * the shared mutex, a background job can never paint a second prompt over a
- * foreground one, and the action never executes until a human has decided.
- *
- * This queue is pure transport: it holds pending entries and settles them. It
- * knows nothing about checkpoints, the mutex, or how a decision is reached — the
- * manager composes that into each entry's `finalize`.
- */
-/** A read-only view of one pending request (for `/jobs` display + tests). */
-export interface PendingApproval {
-    /** Queue-unique id. */
-    readonly id: string;
-    /** The job that is blocked on this decision. */
-    readonly jobId: string;
-    /** One plain line describing the action (e.g. "run: rm -rf build"). */
-    readonly summary: string;
-    /** Risk tier (mutate | destructive — reads never reach the queue). */
-    readonly tier: RiskTier;
-}
-/** What a producing job submits: how to describe it, and how to actually decide. */
-export interface ApprovalSubmission {
-    jobId: string;
-    summary: string;
-    tier: RiskTier;
-    /**
-     * Run the REAL decision: the interactive U.3 prompt + the job's checkpoint
-     * snapshot, serialized on the shared approval mutex. Composed by the manager so
-     * this queue stays decoupled. Called by {@link serviceAll} on the foreground;
-     * its resolved decision settles the producer's `submit` promise. A throw
-     * (e.g. a checkpoint failure) rejects the producer's promise so the job fails
-     * loud rather than hanging.
-     */
-    finalize: () => Promise<ApprovalDecision>;
-}
-export declare class ApprovalQueue {
-    private readonly queue;
-    private seq;
-    /**
-     * A job submits a gated action and awaits the decision. Resolves when the
-     * foreground services it ({@link serviceAll}) or a caller {@link withdraw}s it;
-     * rejects if the finalize throws. The action does NOT execute here — the caller
-     * only proceeds after this resolves `{allow:true}`.
-     */
-    submit(sub: ApprovalSubmission): Promise<ApprovalDecision>;
-    /** Whether any request is waiting to be serviced. */
-    hasPending(): boolean;
-    /** Count of requests waiting. */
-    get size(): number;
-    /** Read-only snapshot of every pending request, FIFO order. */
-    pending(): PendingApproval[];
-    /** The pending request for one job (a job has at most one at a time), if any. */
-    pendingFor(jobId: string): PendingApproval | undefined;
-    /**
-     * Foreground drain: service every currently-pending request, FIFO, ONE AT A
-     * TIME — each `finalize` fully settles (including the human's keypress) before
-     * the next begins, so two background prompts never overlap and the shared mutex
-     * inside `finalize` also serializes them against any foreground action. Returns
-     * the number serviced. Requests that arrive AFTER draining starts wait for the
-     * next drain (bounded work per idle window). A finalize throw rejects that one
-     * producer and drains on — one job's checkpoint failure never wedges the queue.
-     */
-    serviceAll(): Promise<number>;
-    /**
-     * Withdraw a job's pending request WITHOUT prompting — used when the job is
-     * cancelled (or the session exits) while it is paused: settle the producer with
-     * `decision` (a deny) so its `submit` promise resolves and the job can finish
-     * tearing down instead of blocking forever. Returns true if one was withdrawn.
-     */
-    withdraw(jobId: string, decision: ApprovalDecision): boolean;
-    /** Settle an entry exactly once (double-settle is a defensive no-op). */
-    private settle;
-}

package/dist/jobs/dispatch-tool.d.ts

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../tools/index.js";
-import type { JobManager } from "./manager.js";
-/**
- * The `run_in_background` tool (C.28): the agent-facing seam for dispatching a
- * background job. Unlike `spawn_subagent`, it does NOT block — it returns a job
- * id immediately and the job runs CONCURRENTLY with the rest of the turn and the
- * session. The agent uses it for long-running, self-contained work it does not
- * want to wait on inline; the human watches it with `/jobs` and `/logs`, and any
- * side effect the job takes still requires a foreground approval.
- */
-export declare const RUN_IN_BACKGROUND_TOOL_NAME = "run_in_background";
-declare const parameters: z.ZodObject<{
-    task: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    root: z.ZodOptional<z.ZodString>;
-    maxIterations: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    task: string;
-    root?: string | undefined;
-    maxIterations?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: [string, ...string[]] | undefined;
-}, {
-    task: string;
-    root?: string | undefined;
-    maxIterations?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: [string, ...string[]] | undefined;
-}>;
-/** Build the `run_in_background` tool bound to the session's job manager. */
-export declare function makeRunInBackgroundTool(manager: JobManager): Tool<typeof parameters>;
-export {};

package/dist/jobs/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./types.js";
-export * from "./log-buffer.js";
-export * from "./log-renderer.js";
-export * from "./approval-queue.js";
-export * from "./manager.js";
-export * from "./dispatch-tool.js";

package/dist/jobs/log-buffer.d.ts

@@ -1,31 +0,0 @@
-/**
- * A bounded ring buffer of a background job's log lines (C.28). A job runs
- * non-interactively, so its progress isn't on screen — `cruxy logs <id>` reads
- * it back here. Bounded so a chatty job cannot grow memory without limit: once
- * `capacity` lines are held, the oldest roll off. When anything is dropped the
- * buffer records how many, so a reader is never misled into thinking a truncated
- * tail is the whole story (`cruxy logs` prints an honest "… N earlier lines").
- */
-export interface LogLine {
-    /** Milliseconds since the job started (monotonic, injected — never wall clock
-     * inside the buffer, so it stays deterministic and testable). */
-    atMs: number;
-    /** `out` for normal progress, `err` for diagnostics/failures. */
-    stream: "out" | "err";
-    /** The line text (no trailing newline). */
-    text: string;
-}
-export declare class LogBuffer {
-    private readonly capacity;
-    private readonly lines;
-    private droppedCount;
-    constructor(capacity: number);
-    /** Append a line, rolling the oldest off (and counting it) when at capacity. */
-    append(line: LogLine): void;
-    /** The retained lines, oldest-first (a copy — callers never mutate the buffer). */
-    snapshot(): LogLine[];
-    /** How many lines rolled off the front (0 when nothing was dropped). */
-    get dropped(): number;
-    /** Lines currently retained. */
-    get size(): number;
-}

package/dist/jobs/log-renderer.d.ts

@@ -1,32 +0,0 @@
-import { type Theme } from "../theme/index.js";
-import type { RenderCapabilities, StreamRenderer, ToolLifecycleEvent } from "../render/index.js";
-/**
- * A {@link StreamRenderer} for a background job (C.28) that captures activity into
- * the job's log buffer and writes NOTHING to any terminal — a job runs
- * non-interactively, off screen, and its foreground session owns the terminal.
- * `cruxy logs <id>` (a REPL `/logs`) reads back what was captured here.
- *
- * Assistant text is accumulated and flushed a line at a time on `endSegment`;
- * committed chrome notes and tool-call completions are captured verbatim. The
- * live-region methods (status, phase, progress, prompt-resolved) are dropped —
- * transient decor has no meaning in an append-only log.
- */
-export declare class JobLogRenderer implements StreamRenderer {
-    private readonly sink;
-    readonly caps: RenderCapabilities;
-    readonly theme: Theme;
-    private pending;
-    constructor(sink: (stream: "out" | "err", text: string) => void);
-    beginTurn(): void;
-    write(delta: string): void;
-    endSegment(): void;
-    note(text: string): void;
-    toolLifecycle(event: ToolLifecycleEvent): void;
-    endTurn(): void;
-    preview(): void;
-    status(): void;
-    setPhase(): void;
-    progress(): void;
-    promptResolved(): void;
-    close(): void;
-}

package/dist/jobs/manager.d.ts

@@ -1,139 +0,0 @@
-import type { Provider } from "@cruxy/sdk";
-import { runAgent } from "../agent/loop.js";
-import { type ApprovalMutex, type PromptIO } from "../approval/index.js";
-import type { CruxyConfig } from "../config/index.js";
-import type { Router } from "../routing/index.js";
-import type { SandboxService } from "../sandbox/index.js";
-import { Semaphore } from "../subagent/index.js";
-import type { ToolRegistry } from "../tools/index.js";
-import type { logger as Logger } from "../utils/logger.js";
-import { Workspace } from "../workspace/index.js";
-import { ApprovalQueue } from "./approval-queue.js";
-import type { JobLog, JobSpec, JobView } from "./types.js";
-/**
- * Everything the manager needs from the surrounding session, injected by the
- * session factory. The SHARED members are the crux of C.28's "one system, not
- * two": `semaphore`, `approvalQueue`, and `approvalMutex` are the SAME instances
- * the foreground loop and subagents use, so a job contends for the one execution
- * cap and serializes its prompts/checkpoints on the one mutex — never a parallel
- * universe with its own limits.
- */
-export interface JobManagerDeps {
-    config: CruxyConfig;
-    provider: Provider;
-    router?: Router;
-    /** The parent's registry — the ceiling every job's tool scope derives from. */
-    parentRegistry: ToolRegistry;
-    cwd: string;
-    workspace: Workspace;
-    logger: typeof Logger;
-    git?: {
-        branch: string;
-        dirty: boolean;
-    } | null;
-    projectInstructions?: string | null;
-    sandbox?: SandboxService;
-    /** The ONE execution semaphore, shared with subagents (JC-D, the shared cap). */
-    semaphore: Semaphore;
-    /** The ONE foreground pending-approval queue jobs produce onto. */
-    approvalQueue: ApprovalQueue;
-    /** The ONE approval mutex — job prompts/checkpoints serialize on it. */
-    approvalMutex: ApprovalMutex;
-    /**
-     * Whether an interactive foreground exists to service the queue. FALSE (a
-     * one-shot / piped run) means a job's gated action fails loud with
-     * `CRUXY_E_APPROVAL_REQUIRED` — it never auto-approves and never hangs on a
-     * human who will never come.
-     */
-    foregroundInteractive: boolean;
-    /** The shared prompt I/O used when the foreground services a job's request. */
-    promptIO: PromptIO;
-    /** Test seam: the loop driver. Defaults to the real {@link runAgent}. */
-    runAgentFn?: typeof runAgent;
-    /** Test seam: deterministic job ids. Defaults to `job-<seq>-<rand>`. */
-    idFactory?: () => string;
-    /** Test seam: log-line clock (ms). Defaults to `Date.now`. */
-    now?: () => number;
-}
-/**
- * Session-scoped background jobs (C.28). The main agent dispatches a job with
- * `run_in_background`; it runs the SAME agent loop as a subagent but CONCURRENTLY
- * with the foreground session, off screen (its output goes to a log buffer). A
- * gated action pauses the job, releases its execution slot, and enqueues an
- * approval request the foreground human services between turns; on approval the
- * job re-acquires a slot (with priority) and runs on — its pre- AND post-pause
- * mutations coalescing under ONE checkpoint. Cancel and session exit kill-tree a
- * job's process tree (via its cancellation signal), leaving no orphan.
- *
- * The manager is session-scoped and dies with the session (NOT a daemon): nothing
- * here persists a live registry across processes. What survives on disk is a
- * job's checkpoint set, so `cruxy rollback <id>` still works afterwards.
- */
-export declare class JobManager {
-    private readonly deps;
-    private readonly jobs;
-    /** In-flight executions, awaited on {@link cancelAll} so teardown completes. */
-    private readonly running;
-    private readonly idFactory;
-    private readonly now;
-    private readonly runAgentFn;
-    private seq;
-    constructor(deps: JobManagerDeps);
-    /**
-     * Dispatch a background job (the `run_in_background` seam). Fails loud when the
-     * feature is disabled, when the live-job ceiling is reached, or when a named
-     * root is unknown — all BEFORE the job is registered, so a refused dispatch
-     * leaves no ghost. Returns a view immediately; the job runs asynchronously.
-     */
-    dispatch(spec: JobSpec): JobView;
-    /** Live view of every job this session, dispatch order. */
-    list(): JobView[];
-    /** One job's view, or undefined if the id is unknown. */
-    get(id: string): JobView | undefined;
-    /** One job's full log (for `/logs <id>`). Fails loud on an unknown id. */
-    logs(id: string): JobLog;
-    /**
-     * Cancel one job: abort its run (kill-tree'ing any in-flight process via the
-     * signal reaching `ctx.signal`) and, if it is paused, withdraw its queued
-     * approval so it stops waiting. A checkpoint it already took SURVIVES for
-     * review/rollback. Fails loud on an unknown id; a no-op on an already-terminal
-     * job (returns false).
-     */
-    cancel(id: string): boolean;
-    /**
-     * Cancel EVERY live job (session exit / teardown) and AWAIT their teardown, so
-     * nothing is left running or orphaned. Returns how many were cancelled — the
-     * caller prints the honest "N job(s) cancelled". Idempotent.
-     */
-    cancelAll(reason: string): Promise<number>;
-    /** Jobs that are not yet terminal (queued + running + paused). */
-    liveCount(): number;
-    /** Whether any job is paused awaiting a foreground approval (drive the drain). */
-    hasPendingApprovals(): boolean;
-    /** Service every pending job approval on the foreground (called between turns). */
-    serviceApprovals(): Promise<number>;
-    /** Abort a job's run and unblock it if paused (shared by cancel/cancelAll). */
-    private abort;
-    /** Drive one job to completion, mapping every outcome onto its status. */
-    private execute;
-    /** Build the {@link runAgent} args for a job: scoped registry, budget, ctx. */
-    private runArgs;
-    /**
-     * The job's approval gate — the producer side of the pending-approval queue.
-     * A read-tier action passes freely. A mutate/destructive action with NO
-     * interactive foreground fails loud (never auto-approve, never hang). Otherwise
-     * the job PAUSES: it releases its execution slot (JC-D), enqueues the request
-     * for the foreground human, and blocks. On resolution it re-acquires a slot
-     * with PRIORITY (so it is not starved by work dispatched while it waited) and
-     * returns the decision. The real prompt + this job's checkpoint snapshot happen
-     * inside `finalize` on the foreground, serialized on the shared mutex.
-     */
-    private makeJobApproval;
-    /** Resolve a job's scope from an optional root name (fail-loud on unknown). */
-    private jobScope;
-    private statusFor;
-    private errorFor;
-    private requireJob;
-    private log;
-    private view;
-}

package/dist/jobs/types.d.ts

@@ -1,81 +0,0 @@
-import type { Usage } from "@cruxy/sdk";
-import type { LogLine } from "./log-buffer.js";
-/**
- * Types for session-scoped background jobs (C.28): non-interactive orchestration
- * the main agent dispatches with `run_in_background`. A job runs the SAME agent
- * loop as a subagent, but CONCURRENTLY with (and outliving the turn of) the
- * foreground session — bound to the session's lifetime, nothing survives exit
- * (NOT a daemon). Its gated actions enqueue approval requests into the one
- * foreground queue; a paused job releases its execution slot.
- */
-/**
- * A job's lifecycle state. Every state is HONEST — a job is `done` only when its
- * run actually completed, never a fabricated success. Terminal states are `done`,
- * `failed`, `cancelled`; the rest are live.
- * - `queued` — dispatched, waiting for an execution slot (the shared cap is full).
- * - `running` — holding a slot, executing its agent loop.
- * - `paused-needs-approval` — hit a gated action; its approval is enqueued for a
- *   foreground human and it has RELEASED its slot until the human decides (JC-D).
- * - `done` — the run completed.
- * - `failed` — the run errored, exceeded budget, or hit a no-foreground approval
- *   wall (`CRUXY_E_APPROVAL_REQUIRED`); `error` carries the coded reason.
- * - `cancelled` — `cruxy cancel <id>` or session exit stopped it; its process tree
- *   was kill-tree'd and any checkpoint it took survives for review/rollback.
- */
-export type JobStatus = "queued" | "running" | "paused-needs-approval" | "done" | "failed" | "cancelled";
-/** The terminal states — a job in one of these will never run again. */
-export declare const TERMINAL_JOB_STATUSES: readonly JobStatus[];
-/** Whether a status is terminal (no further execution). */
-export declare function isTerminal(status: JobStatus): boolean;
-/**
- * What a background job should do — mirrors the self-contained subtask shape of a
- * subagent spawn (C.14/C.33). A job starts with NO context beyond `task`.
- */
-export interface JobSpec {
-    /** The complete, self-contained task the job should perform. */
-    task: string;
-    /**
-     * Tool names to grant, resolved against the parent registry — a job can only
-     * scope DOWN. Omitted → the default read-only set. A job granted write/shell
-     * tools takes real, gated actions in the background.
-     */
-    tools?: readonly string[];
-    /**
-     * The workspace root (by exact name, C.26) this job is confined to. Omitted →
-     * the full session workspace (read-only, or a single-root session).
-     */
-    root?: string;
-    /** Budget overrides, clamped to `subagent.defaultBudget` (never raised). */
-    budget?: {
-        maxIterations?: number;
-        maxTokens?: number;
-    };
-}
-/**
- * A read-only view of one job for `cruxy jobs` / the dispatch tool's result /
- * tests. Never exposes the live control handles (abort controller, checkpoint
- * gate) — those stay inside the manager.
- */
-export interface JobView {
-    /** Stable, session-unique id (also the checkpoint run id for `cruxy rollback`). */
-    id: string;
-    status: JobStatus;
-    /** One-line task excerpt (for listings). */
-    label: string;
-    /** Present on `failed`: the coded, actionable reason. */
-    error?: string;
-    /** Model turns consumed so far. */
-    iterations: number;
-    /** Token usage accumulated so far. */
-    usage: Usage;
-    /** A one-line summary of what's pending, when `paused-needs-approval`. */
-    pendingApproval?: string;
-}
-/** The full log of one job, for `cruxy logs <id>`. */
-export interface JobLog {
-    id: string;
-    status: JobStatus;
-    lines: LogLine[];
-    /** How many earlier lines rolled off the ring buffer (0 when none). */
-    dropped: number;
-}

package/dist/lsp/client.d.ts

@@ -1,25 +0,0 @@
-import type { LspPool } from "./pool.js";
-import type { LspDiagnostic, LspHover, LspLocation } from "./types.js";
-/**
- * Typed, normalized LSP queries over a {@link LspPool} (C.12). Its only real
- * job beyond delegating is the availability discipline: it resolves a file's
- * language and acquires a server, letting the pool's coded errors (no server /
- * timeout / crash) propagate — while a server's genuine `[]`/`null` answer flows
- * back untouched. That keeps "couldn't ask" and "asked, nothing found" distinct
- * all the way up to the tool boundary. Callers pass ABSOLUTE, in-root paths
- * (validated by the tool via `resolveInRoot`); the server relativizes results.
- */
-export declare class LspClient {
-    private readonly pool;
-    constructor(pool: LspPool);
-    definition(file: string, line: number, col: number): Promise<LspLocation[]>;
-    references(file: string, line: number, col: number): Promise<LspLocation[]>;
-    hover(file: string, line: number, col: number): Promise<LspHover | null>;
-    diagnostics(file: string): Promise<LspDiagnostic[]>;
-    /**
-     * Resolve the file's language and hand back a live server. An unmapped
-     * extension is a coded, actionable failure (`no-spec`) — NOT an empty result,
-     * so "unknown language" can never read as "no references found".
-     */
-    private serverFor;
-}

package/dist/lsp/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./types.js";
-export { DEFAULT_SPECS, EXT_TO_LANGUAGE, LspRegistry, binaryOnPath, languageForFile, } from "./registry.js";
-export { StdioTransport, TransportTimeoutError, killTree, } from "./transport.js";
-export { Server, type ServerTimeouts } from "./server.js";
-export { LspPool, type PoolOptions, type PoolDeps } from "./pool.js";
-export { LspClient } from "./client.js";
-export { getLspService, resetLspServices, type LspService, type LspServiceDeps, } from "./service.js";
-export { findDefinitionTool, findReferencesTool, getDiagnosticsTool, hoverTool, } from "./tools/index.js";

package/dist/lsp/pool.d.ts

@@ -1,48 +0,0 @@
-import { type ServerTimeouts } from "./server.js";
-import { LspRegistry } from "./registry.js";
-import type { LanguageServer, ServerSpec } from "./types.js";
-/** Pool bounds + timeouts, threaded from `lsp.*` config. */
-export interface PoolOptions extends ServerTimeouts {
-    maxServers: number;
-    idleTimeout: number;
-}
-/** Test seams: substitute the spawn+handshake and the clock. */
-export interface PoolDeps {
-    /** Build+initialize a server for a spec. Defaults to a real stdio process. */
-    startServer?: (spec: ServerSpec) => Promise<LanguageServer>;
-    /** Monotonic-ish clock for idle accounting; defaults to `Date.now`. */
-    now?: () => number;
-}
-/**
- * A per-project pool of language servers (C.12): one server per language,
- * spawned lazily on first use, reused across calls, evicted when idle or when
- * the `maxServers` cap forces it, restarted ONCE on crash then surfaced as a
- * coded error, and all shut down cleanly on teardown. Unavailability (no spec /
- * missing binary) throws an actionable error — never a silent empty result.
- */
-export declare class LspPool {
-    private readonly registry;
-    private readonly root;
-    private readonly options;
-    private readonly entries;
-    private readonly starting;
-    private readonly now;
-    private readonly startServer;
-    constructor(registry: LspRegistry, root: string, options: PoolOptions, deps?: PoolDeps);
-    /**
-     * Get a ready server for `language`, spawning lazily and reusing across calls.
-     * Throws `CRUXY_E_LSP_SERVER_NOT_FOUND` when unavailable, `CRUXY_E_LSP_TIMEOUT`
-     * on a startup timeout, or `CRUXY_E_LSP_CRASHED` when a crashed server cannot
-     * be recovered by its single automatic restart.
-     */
-    acquire(language: string): Promise<LanguageServer>;
-    /** Shut down every server idle beyond `idleTimeout` (called on each acquire). */
-    sweepIdle(): void;
-    /** Cleanly shut down all servers (session end / process teardown). */
-    shutdownAll(force?: boolean): Promise<void>;
-    /** Live server count — for tests asserting reuse and the maxServers bound. */
-    size(): number;
-    private startAndStore;
-    /** Evict least-recently-used servers until there is room under the cap. */
-    private evictToCap;
-}

package/dist/lsp/registry.d.ts

@@ -1,38 +0,0 @@
-import type { BinaryPresent, LspConfig, ServerResolution, ServerSpec } from "./types.js";
-/**
- * The default language → server table (C.12). Documented and overridable per
- * language via `lsp.servers.<lang>`. cruxy never guesses a command: a language
- * is served only if it appears here or in config, and the binary must actually
- * be installed — otherwise the caller gets a coded, actionable failure.
- */
-export declare const DEFAULT_SPECS: Record<string, Omit<ServerSpec, "language">>;
-/**
- * File extension → language id. Extensions are matched case-insensitively and
- * include the leading dot. A file whose extension is absent here has no server
- * (the caller reports `no-spec`, distinct from a missing binary).
- */
-export declare const EXT_TO_LANGUAGE: Record<string, string>;
-/** The language id for a file path, or `null` when its extension is unmapped. */
-export declare function languageForFile(filePath: string): string | null;
-/**
- * Default binary-presence check: resolves `command` the way a shell would.
- * An absolute/relative path is tested directly; a bare name is searched across
- * `PATH` (with `PATHEXT` on win32). Pure filesystem probing — never spawns.
- * Injectable via {@link LspRegistry} so tests can force present/absent.
- */
-export declare const binaryOnPath: BinaryPresent;
-/**
- * Resolves a language to a launchable {@link ServerSpec}, or an explicit
- * "not available" verdict. Config overrides (`lsp.servers.<lang>`, a full
- * command line split on whitespace) win over the default table; the resolved
- * binary must be present or the verdict is `binary-missing`.
- */
-export declare class LspRegistry {
-    private readonly config;
-    private readonly present;
-    constructor(config: LspConfig, present?: BinaryPresent);
-    /** The server spec for a language, from config override or the default table. */
-    specFor(language: string): ServerSpec | null;
-    /** Explicit availability verdict — never conflates "no spec" with "no binary". */
-    resolve(language: string): ServerResolution;
-}

package/dist/lsp/server.d.ts

@@ -1,48 +0,0 @@
-import type { LanguageServer, LspDiagnostic, LspHover, LspLocation, LspTransport, ServerSpec } from "./types.js";
-/** Bounds threaded from `lsp.*` config into a server. */
-export interface ServerTimeouts {
-    startupTimeout: number;
-    requestTimeout: number;
-}
-/**
- * An initialized {@link LanguageServer} over an {@link LspTransport} (C.12).
- * Owns the LSP handshake, lazily opens documents (servers answer only for open
- * files), converts LSP's 0-based positions / `file://` URIs to normalized
- * 1-based / path results, and shuts down cleanly. A missing/timed-out/crashed
- * server surfaces as a coded error; an empty answer stays an honest `[]`/`null`.
- */
-export declare class Server implements LanguageServer {
-    private readonly transport;
-    private readonly root;
-    private readonly timeouts;
-    readonly language: string;
-    private _alive;
-    private readonly openDocs;
-    private readonly diagnosticsByUri;
-    private readonly diagnosticsWaiters;
-    private constructor();
-    get alive(): boolean;
-    /**
-     * Spawn+handshake a server: `initialize` (bounded by `startupTimeout`) then
-     * the `initialized` notification. A startup timeout throws a coded error after
-     * the transport is force-disposed — never a hang.
-     */
-    static start(transport: LspTransport, root: string, spec: ServerSpec, timeouts: ServerTimeouts): Promise<Server>;
-    definition(file: string, line: number, col: number): Promise<LspLocation[]>;
-    references(file: string, line: number, col: number): Promise<LspLocation[]>;
-    hover(file: string, line: number, col: number): Promise<LspHover | null>;
-    diagnostics(file: string): Promise<LspDiagnostic[]>;
-    shutdown(force?: boolean): Promise<void>;
-    private uri;
-    private ensureOpen;
-    private query;
-    /** One request with per-request timeout + coded-error mapping (timeout/crash). */
-    private request;
-    private onPublishDiagnostics;
-    private waitForDiagnostics;
-    private toLocations;
-    private toLocation;
-    private toDiagnostic;
-    /** `file://` URI → project-relative path (falls back to the fs path on error). */
-    private relativize;
-}