toolroll 0.9.104 → 0.9.105

package/dist/cli-http.d.ts

@@ -1,58 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Store } from './store.js';
-import type { Principal } from './operate.js';
-import { type RemoteCommandLookup } from './remote-command.js';
-import { type Admission, type BudgetLimit } from './request-budget.js';
-/**
- * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
- * server runs that same command as that person. There is no per-resource API here and no second policy: the transport
- * authenticates one API token, checks the shared command contract and transport arguments, and hands the argv to
- * `runOperateAs`, which owns scope, project grants and attribution.
- *
- * Only `Authorization: Bearer so_…` is accepted — never a password, cookie or the owner's saved login — and a request
- * carrying a browser Origin is refused, so a page can never drive it.
- */
-/** Who a remote command runs as, and the runner: operate.ts's own types, so a change there breaks this build instead of
- * drifting. Type-only: the value is loaded lazily through `run` (operate.ts imports the server that imports this). */
-export type { Principal } from './operate.js';
-export type RunOperateAs = typeof import('./operate.js').runOperateAs;
-export type CliRequest = {
-    argv: string[];
-    files: Record<string, string>;
-};
-export type CliReply = {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-};
-export type CliFailure = {
-    ok: false;
-    code: string;
-    message: string;
-    limit?: BudgetLimit;
-    retryAfter?: number;
-};
-/** Inlined file contents, summed as UTF-8 bytes. */
-export declare const CLI_FILES_BYTES: number;
-/** The whole JSON body: the files plus argv and JSON escaping headroom. */
-export declare const CLI_REQUEST_BYTES: number;
-export type CliHttpOptions = {
-    /** The live API token's person, or null. Only called for a single, well-formed `Bearer so_…` header. */
-    authenticate: (request: IncomingMessage) => Principal | null;
-    /** The shared command boundary; null when this server cannot run remote commands. */
-    run: () => Promise<RunOperateAs | null>;
-    /** Tests: command policy while the parallel command contract is not yet available. Defaults to COMMAND_GUIDE. */
-    modeOf?: RemoteCommandLookup | undefined;
-    /** The token's request budget (request-budget.ts), charged once per request before its body is read. */
-    admit?: ((principal: Principal) => Admission) | undefined;
-    store: Store;
-};
-/** Decode the request's shape and byte limits. The endpoint checks file references against its command policy. */
-export declare function cliRequest(value: unknown): CliRequest | {
-    problem: string;
-    tooLarge?: true;
-};
-/** The longest one request may hold the server: the client polls again for longer waits. */
-export declare const CLI_WAIT_SECONDS = 25;
-/** Handles exactly `/api/cli`; false for any other path. */
-export declare function handleCliHttp(request: IncomingMessage, response: ServerResponse, options: CliHttpOptions): Promise<boolean>;

package/dist/cli.d.ts

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-/**
- * The command.
- *
- * `toolroll` with no arguments reads the repositories below the working
- * directory and prints what is in flight. It writes nothing, starts nothing,
- * and asks nothing. Everything it knows comes from git and from the operator's
- * own filesystem.
- *
- * `--json` exists because half the intended audience is an agent, and an agent
- * should not have to parse a column layout.
- */
-import { previewGithubRepo, cloneGithubRepo } from "./onboard.js";
-import { type QuickStartSeams } from "./quick-start.js";
-import { type ConnectOptions } from "./connect-cli.js";
-import { type RemoteExecOptions } from "./remote-exec.js";
-import type { UpdateCliDeps } from "./toolroll-update-cli.js";
-import type { ReleaseCliDeps } from "./release-cli.js";
-import type { OperateOptions } from "./operate.js";
-import { HELP } from "./cli-help.js";
-export type CliOptions = {
-    roots: string[];
-    /** The positional tokens exactly as typed, index-aligned with `roots` —
-     * kept because a resolved absolute path can no longer say whether the
-     * operator typed a bare word that might have been a command. */
-    rawRoots: string[];
-    /** Whether roots came from the command line, as opposed to the default. */
-    rootsGiven: boolean;
-    maxDepth: number;
-    json: boolean;
-    includeHidden: boolean;
-    /** Report everything discoverable, ignoring the enrolled list. */
-    all: boolean;
-    dirty: boolean;
-    /** Skip the network entirely: branches only, no pull requests or issues. */
-    local: boolean;
-    help: boolean;
-};
-export type ParseResult = {
-    options: CliOptions;
-} | {
-    error: string;
-};
-type Write = (line: string) => void;
-/** The top-level usage text (cli-help.ts), re-exported where it always lived. */
-export { HELP };
-export declare function parseArgs(argv: readonly string[]): ParseResult;
-/** The commands that operate the queue rather than report on the world. */
-export declare const OPERATE_COMMANDS: Set<string>;
-/** binSource exists so tests can exercise linking without depending on a build. */
-export type MainOptions = {
-    binSource?: string;
-    operate?: OperateOptions;
-    connect?: ConnectOptions;
-    /** Injected by tests: the remote CLI's profile, fetch and output streams (defaults to `connect`'s profile seams). */
-    remote?: RemoteExecOptions;
-    /** Injected by tests: the gh-facing halves of `repos add-from-github` —
-     * the verb's parsing, gating, and enrollment are what CLI tests prove;
-     * gh itself is proved by onboard.test.ts. */
-    onboard?: {
-        preview?: typeof previewGithubRepo;
-        clone?: typeof cloneGithubRepo;
-    };
-    update?: UpdateCliDeps;
-    release?: ReleaseCliDeps;
-    /** Tests: bare `toolroll` in a repository (quick-start.ts) — its repository, agent check, proofs and actions. */
-    quickStart?: Partial<QuickStartSeams>;
-    /** Tests: bare `toolroll` at a person's terminal (easy-start.ts) — the terminal and agent checks, and its seams. */
-    easyStart?: {
-        terminal?: boolean;
-        underAgent?: boolean;
-        seams?: Partial<import("./easy-start.js").EasyStartSeams>;
-    };
-};
-/**
- * Strip `-o <file>` / `--output <file>` before dispatch. The flag belongs to
- * the entry point, not to any one command: after the command runs, whatever
- * envelope it serialized is copied to the file, so an agent reads its answer
- * from a path instead of scraping a terminal. Requires `--json`, because the
- * file receives the machine envelope and nothing else does.
- */
-export declare function extractOutputFlag(argv: readonly string[]): {
-    args: string[];
-    outputFile?: string;
-} | {
-    error: string;
-};
-export declare function main(argv: readonly string[], write?: Write, mainOptions?: MainOptions): Promise<number>;
-/** What every former `toolroll routine …` command says now (v115; kept for this release only). */
-export declare const ROUTINES_MOVED = "Routines are now scheduled flows: see `toolroll flows list` (your routines were moved there).";
-export declare function partitionRoots(roots: readonly string[], exists: (path: string) => boolean): {
-    present: string[];
-    missing: string[];
-};
-export type LinkArgs = {
-    to?: string;
-    yes: boolean;
-};
-export declare function parseLinkArgs(argv: readonly string[]): {
-    args: LinkArgs;
-} | {
-    error: string;
-};
-/**
- * `skills install`: with --claude-code, install this binary's lead guides
- * in the user's Claude Code skills directory. Without it, retain the older
- * repository-local Agent Skills entry and optional managed AGENTS.md block.
- * Both paths preview by default, write only with --yes, and refuse files
- * they do not own.
- */
-/** The skills subcommands and their EXACT flag vocabularies — consulted
- * by the parser above and compared verbatim by the command guide's tests
- * (arc-5 review, finding 5). */
-export declare const SKILLS_ACTIONS: readonly ["install", "list", "get"];
-export declare const SKILLS_FLAGS: {
-    readonly install: {
-        readonly json: "flag";
-        readonly yes: "flag";
-        readonly "claude-code": "flag";
-        readonly dir: "value";
-        readonly "write-context": "flag";
-        readonly repo: "value";
-    };
-    readonly list: {
-        readonly json: "flag";
-    };
-    readonly get: {
-        readonly json: "flag";
-    };
-};
-/**
- * `contract` is the machine contract, stated by the machine: the envelope
- * version and the capability tokens an agent consumer can feature-detect on.
- * Behaviors, not versions — consumers ignore tokens they do not recognize.
- */
-/** contract's EXACT flags — consulted below and compared by the command
- * guide's tests (arc-5 review, finding 5). */
-export declare const CONTRACT_FLAGS: readonly ["json", "commands"];
-/**
- * Whether this module is the program being run, rather than an import.
- *
- * Node resolves a module to its real path while argv[1] keeps whatever name it
- * was invoked by, so a symlinked `toolroll` on PATH compares unequal to
- * itself unless both sides are resolved. Getting this wrong is silent: the
- * command runs, prints nothing, and exits 0.
- */
-export declare function isDirectInvocation(moduleUrl: string, entry: string | undefined, toRealPath?: (path: string) => string): boolean;
-/** The process entry the bin calls: the SQLite notice hushed, the exit code set. */
-export declare function runCliProcess(argv: readonly string[]): Promise<void>;

package/dist/code-extract.d.ts

@@ -1,44 +0,0 @@
-/**
- * The static read of one TS/JS file and the module resolution over a set of paths held in memory: nothing here touches
- * the filesystem, a repository or a checker. Repository context (repository-context.ts) reads a checkout through it; the
- * code map's parser child (code-map-main.ts) reads blobs through it. The file name decides the parse mode.
- */
-import type ts from 'typescript-parser';
-export type Compiler = typeof ts;
-export type EdgeKind = 'imports' | 're-exports' | 'dynamic-import';
-export type DeclarationKind = 'function' | 'class' | 'interface' | 'type' | 'enum' | 'method' | 'variable' | 'default';
-export type Declaration = {
-    name: string;
-    kind: Exclude<DeclarationKind, 'default'>;
-    line: number;
-    endLine: number;
-};
-export type ExportedName = {
-    name: string;
-    kind: DeclarationKind;
-    line: number;
-};
-export type Specifier = {
-    specifier: string;
-    kind: EdgeKind;
-    line: number;
-};
-export type Extracted = {
-    declarations: Declaration[];
-    exports: ExportedName[];
-    specifiers: Specifier[];
-    parseFailed: boolean;
-};
-/** Declarations, the names the file exports (under the name they are exported as) and the module specifiers it names. `require` isn't counted: it may
- * be shadowed, and a guessed call isn't a proven relationship. */
-export declare function extractFile(compiler: Compiler, fileName: string, text: string): Extracted;
-/** The compiler options a project's tsconfig text gives, read as JSONC and converted, non-string options included.
- * `extends` isn't followed. */
-export declare function compilerOptionsOf(compiler: Compiler, configPath: string, text: string | undefined, root: string): {
-    options: ts.CompilerOptions;
-    problem: 'extends' | 'unreadable' | null;
-};
-/** Resolve a specifier to one of `paths` (absolute, in memory); null when it names nothing there. */
-export declare function resolveAll(compiler: Compiler, root: string, paths: ReadonlyMap<string, {
-    text?: string;
-}>, directories: ReadonlySet<string>, options: ts.CompilerOptions, normal: (file: string) => string): (specifier: string, fromFile: string) => string | null;

package/dist/code-map-acts.d.ts

@@ -1,24 +0,0 @@
-import type { Store } from "./store.js";
-export type MapPerson = {
-    actor: string;
-    generation: number;
-    method: string;
-    live?: () => boolean;
-};
-export type MapDoor = {
-    kind: "person";
-    person: MapPerson;
-} | {
-    kind: "local-owner";
-    actor: string;
-};
-export type MapActResult = {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/** Turn the map on or off. The proof is checked in the write's own transaction. */
-export declare function setCodeMapSwitch(store: Store, door: MapDoor, repo: string, on: boolean, now: Date): MapActResult;
-/** End the holdout early: enrollment stops; families keep their arms. */
-export declare function endHoldout(store: Store, door: MapDoor, repo: string, now: Date): MapActResult;

package/dist/code-map-admission.d.ts

@@ -1,52 +0,0 @@
-import { type CodeMap } from "./code-map-shape.js";
-import { type Store } from "./store.js";
-export declare const EXCERPT_BYTES: number;
-export declare const ENROLL_DAYS = 30;
-export declare const OBSERVE_DAYS = 21;
-export type SnapshotState = "map" | "off" | "none" | "remote-changed" | "holdout" | "unavailable";
-export type Snapshot = {
-    run: number;
-    state: SnapshotState;
-    version: number | null;
-    excerpt: string;
-    excerptSha: string;
-    fileSelected: boolean;
-};
-export declare function readSnapshot(store: Store, run: number): Snapshot | null;
-/** One labelled record, at most 6 KB: the areas a task touches, their neighbours, then matches on its words. */
-export declare function codeMapExcerpt(map: CodeMap, input: {
-    touches: readonly string[];
-    words: string;
-    base: string | null;
-}): string;
-export declare const armOf: (rootTask: string) => "map" | "holdout";
-/**
- * The run's map selection, fixed once: called inside knowledgeContext's transaction. Returns the excerpt for its brief,
- * "" when it has none. `firstAdmission` says this run's knowledge snapshot was made just now; a run above the watermark
- * that reaches here later with no row didn't get one, and that is recorded.
- */
-export declare function codeMapAdmission(store: Store, input: {
-    run: number;
-    taskRef: number;
-    repo: string;
-    parent: number | null;
-    firstAdmission: boolean;
-    touches: readonly string[];
-    words: string;
-    base: string | null;
-}, now: Date): string;
-export type DeliveryReason = "no-confinement" | "write-failed" | "sha-mismatch" | "version-pruned" | "not-selected";
-export declare const deliveryRoot: (databaseFile: string) => string;
-export declare const fenceAvailableNow: () => boolean;
-/** Serialize the file: the label first, so whoever opens it reads that before any repository value. */
-export declare const mapFileBody: (map: CodeMap) => string;
-/**
- * This launch's delivery: one row per launch attempt, and the file when the selection names one and the launch is
- * confined. Exclusive create, no following a link, read back and checked against the stored payload. Never touches
- * launch configuration or credentials, and never blocks the launch. Returns the words for the brief.
- */
-export declare function deliverCodeMap(store: Store, run: number, now: Date, confined?: () => boolean): string;
-/** The file this run's latest launch was given, for the fence's exact-file grant; null when it was given none. */
-export declare function deliveredFile(store: Store, run: number): string | null;
-/** Finished runs' delivered files go: the rows stay. */
-export declare function sweepDeliveries(store: Store): number;

package/dist/code-map-build.d.ts

@@ -1,63 +0,0 @@
-import { type BoundedRunner } from "./bounded-spawn.js";
-import { type CodeMap } from "./code-map-shape.js";
-import { type Lookup, type Pin } from "./remote-destination.js";
-import { type Store } from "./store.js";
-export declare const REFRESH_EVERY_MS: number;
-export type MapDeps = {
-    /** The folder private fetches go under: inside Toolroll's state, denied to builds. */
-    scratch: string;
-    bounded?: BoundedRunner;
-    lookup?: Lookup;
-    /** Whether this git's libcurl honours the pin; refused when it doesn't. */
-    pinWorks?: () => Promise<boolean>;
-    env?: Readonly<Record<string, string | undefined>>;
-    owner?: string;
-    helper?: string;
-    clock?: () => Date;
-    /** Tests: stops inside the build, to race it. */
-    atStage?: (stage: "before-fetch" | "after-fetch" | "before-publish") => void | Promise<void>;
-};
-/** Pinned by the parser's own package: a parser bump rebuilds every map. */
-export declare function currentExtractor(): string;
-/** Connect a pinned name that can't resolve to a local listener: only a libcurl that honours the pin reaches it. */
-export declare function curlPinWorks(): Promise<boolean>;
-type RawEntry = {
-    path: string | null;
-    mode: string;
-    kind: string;
-    oid: string;
-    bytes: number;
-};
-export declare function parseTree(output: Buffer): RawEntry[];
-/** A failed build's reason, in the words the page shows, and the state it reads as. */
-export declare class MapRefused extends Error {
-    readonly state: "failed" | "too-large";
-    constructor(message: string, state: "failed" | "too-large");
-}
-/** The parser process's entry, from the installed release (the sources under a test). */
-export declare function parserEntry(): {
-    file: string;
-    args: string[];
-};
-export type BuildContext = {
-    repo: string;
-    commit: string;
-    urlDigest: string;
-    record: number;
-    builtAt: string;
-    extractor: string;
-};
-/** Everything between a clean private folder and a map. Throws MapRefused when no new version can come of it. */
-export declare function buildFromFolder(dir: string, pin: Pin, bounded: BoundedRunner, context: BuildContext, entry?: {
-    file: string;
-    args: string[];
-}): Promise<CodeMap>;
-export type CheckOutcome = "unavailable" | "held" | "waits" | "fresh" | "published" | "stored" | "no-main" | "empty" | "failed" | "too-large" | "lease-lost";
-/** Check one project; build and publish when main moved. Never throws for a remote's sake. */
-export declare function checkCodeMap(store: Store, repo: string, deps: MapDeps): Promise<CheckOutcome>;
-/** Projects due a check: the map on, a remote recorded, past any back-off, and a request queued or 30 minutes since the
- * last completed check. */
-export declare function dueProjects(store: Store, now: Date): string[];
-/** The watch loop's step: every due project in turn, one build at a time. */
-export declare function refreshCodeMaps(store: Store, deps: MapDeps): Promise<number>;
-export {};

package/dist/code-map-cli.d.ts

@@ -1,153 +0,0 @@
-import { type MapDoor } from "./code-map-acts.js";
-import type { Store } from "./store.js";
-export declare const MAP_DESCRIPTORS: readonly [{
-    readonly action: "";
-    readonly synopsis: "a project's code map: its areas, and how they use each other";
-    readonly mutation: "none";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-}, {
-    readonly action: "area";
-    readonly synopsis: "one area's files, exported names, tests and connections: map area <id>";
-    readonly mutation: "none";
-    readonly positional: "the area's id";
-    readonly flags: readonly Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>[];
-}, {
-    readonly action: "file";
-    readonly synopsis: "one file's exported names, imports and who imports it: map file <path>";
-    readonly mutation: "none";
-    readonly positional: "the file's exact path";
-    readonly flags: readonly Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>[];
-}, {
-    readonly action: "search";
-    readonly synopsis: "search files and exported names: map search <words>";
-    readonly mutation: "none";
-    readonly positional: "words to search for";
-    readonly flags: readonly Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>[];
-}, {
-    readonly action: "refresh";
-    readonly synopsis: "ask for a check of main now; it runs on the next pass";
-    readonly mutation: "unkeyed";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-}, {
-    readonly action: "report";
-    readonly synopsis: "builds with and without the map, by assigned arm";
-    readonly mutation: "none";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-}, {
-    readonly action: "on";
-    readonly synopsis: "turn a project's code map on (a person, or this computer's owner)";
-    readonly mutation: "unkeyed";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-    readonly audience: "operator";
-}, {
-    readonly action: "off";
-    readonly synopsis: "turn a project's code map off (a person, or this computer's owner)";
-    readonly mutation: "unkeyed";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-    readonly audience: "operator";
-}, {
-    readonly action: "holdout end";
-    readonly synopsis: "stop enrolling new builds in the holdout; existing ones keep their arm (a person)";
-    readonly mutation: "unkeyed";
-    readonly positional: null;
-    readonly flags: readonly [Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>, Readonly<{
-        [x: string]: unknown;
-        name: string;
-        takesValue: boolean;
-        meaning: string;
-    }>];
-    readonly audience: "operator";
-}];
-export type MapCliContext = {
-    store: Store;
-    write: (line: string) => void;
-    json: boolean;
-    now: Date;
-    actor: string | null;
-    repos: readonly string[];
-    /** Whether the caller stands as an approver of this project, proved now (a lead token does; a local owner doesn't). */
-    approver: (repo: string) => boolean;
-    /** Who may change this project's map, as proved for this command; null when nobody was. */
-    door: (repo: string) => MapDoor | null;
-};
-export declare function runMapCommand(positional: readonly string[], options: Map<string, string | true>, context: MapCliContext): Promise<number>;

package/dist/code-map-main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/code-map-read.d.ts

@@ -1,106 +0,0 @@
-/**
- * The one reader of the code map (docs/plans/code-map.md §4, §6): the lead tools, MCP, chat, the page and the CLI all come
- * through here, so they can't drift. It checks the project's switch and the remote's identity on every read. A first
- * answer pins the current version; later pages name that version and a cursor, so a refresh between pages never skips
- * or repeats entries. Everything it returns came from the repository and is labelled untrusted.
- */
-import { type Refresh, type VersionRow } from "./code-map-store.js";
-import { type CodeMap, type MapArea, type MapFile } from "./code-map-shape.js";
-import { type Store } from "./store.js";
-export declare const ANSWER_BYTES: number;
-export type MapStateName = "not-available" | "off" | "making" | "current" | "stale" | "couldnt-check" | "too-large" | "remote-changed" | "empty" | "no-main";
-export type MapStatus = {
-    state: MapStateName;
-    words: string;
-    version: VersionRow | null;
-    nextTry: string | null;
-    movedTo: string | null;
-    refresh: Refresh | null;
-};
-/** The project's map state, as every surface states it. `at` renders a time; tests and the CLI use the plain ISO. */
-export declare function codeMapStatus(store: Store, repo: string, now: Date, at?: (iso: string) => string): MapStatus;
-/** The verified map at a version of this project, or why not. Identity is checked on every read. */
-export declare function openMap(store: Store, repo: string, version?: number): {
-    ok: true;
-    map: CodeMap;
-    version: VersionRow;
-} | {
-    ok: false;
-    state: "off" | "remote-changed" | "none" | "gone" | "unavailable";
-    words: string;
-};
-export type AreaRow = {
-    id: string;
-    name: string;
-    files: number;
-    languages: string[];
-    tests: number;
-    uses: {
-        id: string;
-        count: number;
-    }[];
-    usedBy: {
-        id: string;
-        count: number;
-    }[];
-};
-export declare const areaRow: (map: CodeMap, area: MapArea) => AreaRow;
-export declare const areaRows: (map: CodeMap) => AreaRow[];
-export type AreaView = {
-    area: AreaRow;
-    entryPoints: string[];
-    external: string[];
-    files: MapFile[];
-};
-export declare function areaView(map: CodeMap, id: string): AreaView | null;
-export type FileView = {
-    file: MapFile;
-    imports: {
-        path: string;
-        kind: string;
-        line: number;
-    }[];
-    importedBy: {
-        path: string;
-        kind: string;
-        line: number;
-    }[];
-};
-/** Exact lookup in the stored version: a path is never resolved, joined or normalized. */
-export declare function fileView(map: CodeMap, path: string): FileView | null;
-export type SearchHit = {
-    kind: "file" | "name";
-    path: string;
-    name: string | null;
-    line: number | null;
-};
-export declare function searchMap(map: CodeMap, query: string, limit?: number): SearchHit[];
-export type MapView = "overview" | "area" | "file" | "search";
-export type MapQuestion = {
-    repo: string;
-    version?: number;
-    view: MapView;
-    id?: string;
-    query?: string;
-    cursor?: string;
-};
-export type MapAnswer = {
-    v: 1;
-    ok: true;
-    label: string;
-    repo: string;
-    version: number;
-    commit: string;
-    view: MapView;
-    header: Record<string, unknown>;
-    items: unknown[];
-    omitted: number;
-    cursor: string | null;
-} | {
-    v: 1;
-    ok: false;
-    state: string;
-    message: string;
-};
-/** The labelled answer to one question, at most `maxBytes`. The first page pins the version it read. */
-export declare function answerMap(store: Store, question: MapQuestion, maxBytes?: number): MapAnswer;