icoa-cli 2.19.458 → 2.19.459

package/dist/lib/learn-render.d.ts

@@ -1,107 +0,0 @@
-import type { Card, Curriculum } from './learn-curricula.js';
-import type { LearnState } from './learn-state.js';
-import type { LearnWidthMode } from '../types/index.js';
-import { type CardReply } from './learn-replies.js';
-export declare function resolveLearnWidth(cfg: {
-    learnWidth?: LearnWidthMode;
-    learnWide?: boolean;
-}): LearnWidthMode;
-export declare function setLearnWidth(mode: LearnWidthMode): void;
-export declare function learnWidthCap(mode?: LearnWidthMode): number;
-export declare function learnW(): number;
-export declare function renderWelcome(curriculum: Curriculum, state: LearnState, isNewSession: boolean): void;
-export declare function wrapMixed(text: string, width: number): string[];
-export declare function setLearnAiEnabled(on: boolean): void;
-export declare function setLearnPqsViewCards(cards: ReadonlySet<number>): void;
-export declare function setLearnHonorRanks(ranks: ReadonlyMap<number, number>): void;
-export declare function setLearnReplies(r: CardReply[]): void;
-export type HonorWallData = {
-    totals: {
-        gold: number;
-        silver: number;
-        bronze: number;
-    };
-    chapters: Array<{
-        chapter: number;
-        gold: number;
-        silver: number;
-        bronze: number;
-        cards: Array<{
-            card: number;
-            rank: number;
-            icon: string;
-            score: number;
-            since: string;
-        }>;
-    }>;
-    floor?: number;
-};
-export declare function renderHonorWall(data: HonorWallData): void;
-export declare function renderKnowledgeCard(card: Extract<Card, {
-    type: 'knowledge';
-}>, curriculum: Curriculum): void;
-export declare function renderCheckFeedback(card: Extract<Card, {
-    type: 'knowledge';
-}>, userAnswer: 'y' | 'n', correct: boolean, premiumExplain?: boolean): void;
-export declare function renderPhaseComplete(curriculum: Curriculum, state: LearnState, done: {
-    number: number;
-    name: string;
-    cardRange: [number, number];
-}, next?: {
-    number: number;
-    name: string;
-    cardRange: [number, number];
-}, pqsScores?: Array<{
-    card: number;
-    score: number;
-    tier: string;
-}>, gatePhase?: {
-    configured: boolean;
-    contest?: {
-        passed: boolean;
-        best_ac?: number;
-        need?: number;
-        n?: number;
-        attempts?: number;
-        slots?: Array<{
-            slot: number;
-            passed: boolean;
-            best_ac: number;
-            need: number;
-            n: number;
-            attempts: number;
-        }>;
-    };
-    research?: {
-        good_cards: number;
-        need_cards: number;
-        min_score: number;
-        passed: boolean;
-    };
-}): void;
-export declare function renderCurriculumComplete(curriculum: Curriculum, state: LearnState): void;
-export declare function renderMCQCard(card: Extract<Card, {
-    type: 'mcq';
-}>, curriculum: Curriculum): void;
-export declare function renderMCQFeedback(card: Extract<Card, {
-    type: 'mcq';
-}>, selected: 'A' | 'B' | 'C' | 'D', correct: boolean, state: LearnState): void;
-export declare function renderPracticalCard(card: Extract<Card, {
-    type: 'practical';
-}>, curriculum: Curriculum): void;
-export declare function renderPracticalSuccess(card: Extract<Card, {
-    type: 'practical';
-}>): void;
-export declare function renderSimDemoCard(card: Extract<Card, {
-    type: 'sim_demo';
-}>, curriculum: Curriculum): void;
-export declare function renderArenaTaskCard(card: Extract<Card, {
-    type: 'arena_task';
-}>, curriculum: Curriculum): void;
-export declare function renderComingSoonCard(card: Extract<Card, {
-    type: 'coming_soon';
-}>, curriculum: Curriculum): void;
-export declare function renderMilestone(card: Extract<Card, {
-    type: 'milestone';
-}>, curriculum: Curriculum): void;
-export declare function renderStatus(curriculum: Curriculum, state: LearnState): void;

package/dist/lib/learn-replies.d.ts

@@ -1,42 +0,0 @@
-/**
- * learn-replies — pure functions for the card human-reply channel (student
- * presses `e` to report a card problem; a human writes one reply; the
- * student reads it with `r` under that card). No chalk, no I/O — mirrors
- * the board-render.ts pure-module pattern. Every user-facing string ships
- * both EN and ZH; this channel never promises a reply timeline.
- */
-export type CardReply = {
-    id: number;
-    curriculumId: string;
-    cardNumber: number;
-    myText: string;
-    sentAt: string;
-    replyText?: string;
-    repliedBy?: string;
-    repliedAt?: string;
-    seen: boolean;
-};
-export declare function sanitizeReplyText(s: string): string;
-export declare function parseReplies(raw: unknown): CardReply[];
-/** Local calendar day `MM-DD` — never a "3 days ago" delta (learn-continue lesson). */
-export declare function shortDay(iso: string): string;
-export declare function repliesForCard(all: CardReply[], card: number): CardReply[];
-/**
- * Recognizes an `r` / `reply` / `replies` command line — bare (current card)
- * or with an argument (`r 17` / `reply all` / ...) — and extracts the
- * target. Pure so it is directly unit-testable instead of only probeable by
- * grepping the regex literal out of `learn.ts`'s source text (review finding
- * I3, 2026-07-30: that grep went stale during an earlier fix round and the
- * test silently degraded to vacuous). `learn.ts`'s dispatch calls this exact
- * function — it is the real guard, not a copy of it.
- *
- * Returns `null` for anything that is not a reply command, including
- * look-alikes (`read 3`, `rally`, `r x`).
- */
-export declare function parseReplyCommand(input: string): {
-    target: number | 'all' | 'current';
-} | null;
-export declare function unreadReplies(all: CardReply[]): CardReply[];
-export declare function replyPushLine(all: CardReply[], zh: boolean): string | null;
-export declare function replyChipLabel(all: CardReply[], card: number, zh: boolean): string | null;
-export declare function renderReplyLines(all: CardReply[], card: number | 'all', zh: boolean, width: number): string[];

package/dist/lib/learn-state.d.ts

@@ -1,66 +0,0 @@
-export type MCQResult = {
-    answer: 'A' | 'B' | 'C' | 'D';
-    correct: boolean;
-    submittedAt: string;
-};
-export type CheckResult = {
-    answer: 'y' | 'n';
-    correct: boolean;
-    submittedAt: string;
-};
-export type LearnState = {
-    token: string;
-    curriculumId: string;
-    currentCard: number;
-    totalCards: number;
-    startedAt: string;
-    lastSeenAt: string;
-    streakDays: number;
-    longestStreak: number;
-    cardsCompleted: number[];
-    mcqResults: Record<string, MCQResult>;
-    checkResults?: Record<string, CheckResult>;
-    practicalsCompleted: number[];
-    bookmarks: number[];
-    achievements: string[];
-    totalSecondsActive: number;
-};
-/** Courses listed on the Learn picker. The rest need `c <track>` or `c all`. */
-export declare const CONTINUE_LIST_MAX = 5;
-/**
- * Every remembered course, most-recently-seen first.
- *
- * The active session comes from learn-state.json; a same-token copy left in the
- * archive is ignored (see `activateSession` — promotion deliberately does not
- * delete, so the active file always wins).
- */
-export declare function listLearnSessions(): LearnState[];
-/**
- * Switch the active course to `token`.
- *
- * Archives whichever course is active now, then returns this token's stored
- * progress if we have ever seen it (the caller writes it back via
- * `saveLearnState`, keeping a single writer for learn-state.json). Returns null
- * for a course this machine has never opened — the caller makes a fresh state.
- *
- * Promotion does NOT delete the archived copy. Deleting would open a window
- * where a crash between this call and the caller's `saveLearnState` loses the
- * course from both files; leaving a stale copy is harmless because the lookup
- * rule always prefers the active file for the active token.
- */
-export declare function activateSession(token: string): LearnState | null;
-export declare function loadLearnState(): LearnState | null;
-export declare function saveLearnState(state: LearnState): void;
-export declare function newLearnState(token: string, curriculumId: string, totalCards: number): LearnState;
-/**
- * Update streak based on last-seen-at vs today.
- *  - Same day:    streak unchanged
- *  - Next day:    streak + 1
- *  - Gap > 1 day: streak resets to 1
- */
-export declare function updateStreak(state: LearnState): void;
-export declare function markCardComplete(state: LearnState, cardNumber: number): void;
-export declare function recordMCQ(state: LearnState, cardNumber: number, result: MCQResult): void;
-export declare function recordCheck(state: LearnState, cardNumber: number, result: CheckResult): void;
-export declare function markPracticalComplete(state: LearnState, cardNumber: number): void;
-export declare function addAchievement(state: LearnState, badge: string): void;

package/dist/lib/log-sync.d.ts

@@ -1,2 +0,0 @@
-export declare function startLogSync(): void;
-export declare function stopLogSync(): void;

package/dist/lib/logger.d.ts

@@ -1,12 +0,0 @@
-import type { LogEntry } from '../types/index.js';
-/** Test-only: force the next currentLastMac() call to re-seed from the log
- * tail, simulating a fresh process picking up an existing session.log. */
-export declare function __resetChainHeadForTest(): void;
-export declare function chainMac(prevMac: string, entry: object, key: Buffer): string;
-export declare function verifyChain(entries: Array<Record<string, unknown>>, startMac: string, key: Buffer): {
-    ok: boolean;
-    brokenAt: number;
-};
-export declare function logCommand(command: string): void;
-export declare function logSubmission(challengeId: number, flag: string): void;
-export declare function getSessionLog(): LogEntry[];

package/dist/lib/main-rl.d.ts

@@ -1,20 +0,0 @@
-/**
- * Shared reference to the main REPL's readline.Interface.
- *
- * Linear-flow commands (demo2, future others) need to PAUSE the main
- * rl while reading their own input — otherwise two readline interfaces
- * on the same TTY both echo every keystroke ("lang" → "llaanngg") and
- * both fire 'line' events.
- *
- * Pattern:
- *   1. startRepl() calls setMainRl(rl) right after creating its rl.
- *   2. Linear-flow command on entry: getMainRl()?.pause()
- *   3. Linear-flow command on exit:  getMainRl()?.resume()
- *
- * Side note: when called from `icoa demo2` direct (no REPL parent),
- * getMainRl() returns null and pause/resume are no-ops. Correct
- * behaviour either way.
- */
-import type { Interface as ReadlineInterface } from 'node:readline';
-export declare function setMainRl(rl: ReadlineInterface | null): void;
-export declare function getMainRl(): ReadlineInterface | null;

package/dist/lib/md-term.d.ts

@@ -1,17 +0,0 @@
-/**
- * md-term — tiny markdown → ANSI renderer for `icoa ipynb` markdown cells.
- * Deliberately minimal (headers, bold/italic, inline + fenced code, lists,
- * quotes, rules, links); full CommonMark is a non-goal — an unrecognized line
- * degrades to plain styled text, never an error. chalk-only styling per the
- * terminal color rules (black background — no default-color text), UTF-8
- * box/bullet chars only (4-platform baseline, no images/sixel).
- */
-/**
- * Render markdown source to display lines (already indented + chalk-styled).
- * Pure w.r.t. the terminal: caller prints. `width` bounds rules/underlines.
- */
-export declare function renderMarkdown(src: string, indent?: string, width?: number): string[];
-/** Heuristic: does this (failed-as-Python) source look like markdown/prose?
- *  Markdown markers, or a plain multi-word line with no code-ish characters.
- *  Only consulted AFTER a SyntaxError, so a false positive costs one gray hint. */
-export declare function looksLikeMarkdown(src: string): boolean;

package/dist/lib/menu-nav.d.ts

@@ -1,25 +0,0 @@
-/**
- * Exit code the worker uses to ask the supervisor (in index.ts) to relaunch a
- * fresh CLI process. Picked from the unreserved 64–113 sysexits range so it
- * can't collide with a normal `process.exit(0|1)`. See index.ts for the
- * supervisor loop that consumes it.
- */
-export declare const RELAUNCH_CODE = 75;
-interface RlLike {
-    close: () => void;
-    removeAllListeners?: (event?: string) => unknown;
-}
-export declare function registerRealExit(fn: (code?: number) => never): void;
-/**
- * One-line standalone hint for sub-REPLs and mode landing screens.
- * Prints a friendly cue that `menu` is always available.
- */
-export declare function printMenuHint(): void;
-/**
- * Inline fragment for embedding in existing Tip / footer lines.
- * Returns a chalk-styled string like:  menu returns home
- * so callers can splice it with ` · ` separators.
- */
-export declare function menuHintInline(): string;
-export declare function returnToMainMenu(rl?: RlLike): void;
-export {};

package/dist/lib/notebook-doc.d.ts

@@ -1,38 +0,0 @@
-/**
- * notebook-doc — the pure cell model behind `icoa ipynb`'s cell-stepper
- * (cells / show / edit / run / save). nbformat v4 is plain JSON, so parse and
- * serialize live here with zero dependencies; keeping the module pure (no I/O,
- * no chalk) means the whole document lifecycle is unit-tested without a kernel.
- *
- * Round-trip safety: cells loaded from disk keep their original outputs in
- * `rawOutputs` and are written back verbatim on save unless the cell was
- * re-run this session (then the fresh FoldedCell result wins).
- */
-import type { FoldedCell } from './kernel-protocol.js';
-export type CellKind = 'code' | 'markdown';
-export interface NbCell {
-    kind: CellKind;
-    source: string;
-    /** Result of running the cell THIS session; null = not run yet. */
-    result: FoldedCell | null;
-    /** nbformat outputs as loaded from disk (preserved on save if not re-run). */
-    rawOutputs?: unknown[];
-    rawExecCount?: number | null;
-}
-/** Parse a .ipynb (nbformat v4) JSON string. Raw cells are dropped. */
-export declare function parseIpynb(json: string): NbCell[];
-/**
- * Split a Python script into cells on `# %%` markers (jupytext percent
- * format; the arena starter uses the same markers). Marker lines are
- * separators and are dropped. No markers → the whole file is one cell.
- */
-export declare function parsePercentPy(text: string): NbCell[];
-/** Serialize cells to a Jupyter-openable nbformat v4.5 JSON string. */
-export declare function serializeIpynb(cells: NbCell[]): string;
-/** One-char run state for the `cells` listing. */
-export declare function statusChar(cell: NbCell): string;
-/** First non-blank line, trimmed and truncated to `width` (with ellipsis). */
-export declare function cellPreview(cell: NbCell, width: number): string;
-/** Parse `run` arguments: '3' → [3], '1-5' → [1..5], 'all' → [1..count].
- *  1-based, validated against count; null = not a valid range. */
-export declare function parseRunRange(arg: string, count: number): number[] | null;

package/dist/lib/open-file.d.ts

@@ -1,35 +0,0 @@
-export interface OpenCommand {
-    cmd: string;
-    args: string[];
-}
-/** Decide the OS "open" command for `path`. Pure — platform + env are injected
- *  so every baseline target (macOS / Linux / WSL / Windows) is unit-testable. */
-export declare function openFileCommand(path: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): OpenCommand;
-/**
- * Open `path` in the OS default app (detached). Returns false when we could not
- * launch an opener — callers MUST surface the path themselves in that case.
- *
- * 🔴 spawn() does NOT throw when the binary is missing. ENOENT arrives as an
- * asynchronous 'error' event on the next tick, so a try/catch around spawn()
- * catches nothing, and with no 'error' listener Node re-throws it as an
- * UNCAUGHT EXCEPTION and dumps a full multi-block stack trace. That is exactly
- * what a WSL student saw instead of the demo2 clip (2026-07-28): Ubuntu's WSL
- * rootfs ships no xdg-utils, so `xdg-open` is absent on every fresh box.
- *
- * Two guards, both required:
- *   1. whichBinary() — a PATH scan BEFORE spawning, so "no opener" is an
- *      honest synchronous false instead of a crash several ticks later.
- *   2. an 'error' listener anyway — the PATH scan can still lose a race
- *      (binary removed, not executable), and one un-listened event kills icoa.
- */
-export declare function openFile(path: string): boolean;
-/** The line to print when no opener exists. Pure so every baseline target is
- *  unit-testable; WSL gets the Windows path because `\\wsl.localhost\...` is
- *  what a student can actually paste into Explorer. */
-export declare function openFallbackHint(path: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
-/**
- * Open a rendered clip/figure and ALWAYS tell the student what happened.
- * Silence is the bug: on a box with no opener the old code either said
- * "Opening in your default video player..." and did nothing, or crashed.
- */
-export declare function openMedia(path: string, log: (line: string) => void): boolean;

package/dist/lib/paper-upgrade.d.ts

@@ -1,27 +0,0 @@
-/**
- * Paper C → Paper B upgrade prompt.
- *
- * Shown after a successful Paper C submission. Paper C is the K-12 entry
- * funnel (MCQ only, no tools). Paper B is the next step — adds AI4CTF
- * and CTF4AI practical challenges for 150-point total. The upgrade path
- * depends on which platform the student is on.
- *
- * Policy:
- * - Only triggered after Paper C submission (examId ends in `-c` or
- *   starts with a country code + `-2026-c`).
- * - Only triggered if student passed. Students who failed C should
- *   retry C before being pushed toward a harder paper.
- * - Always points at https://icoa2026.au/selectionguide/ for detailed
- *   platform-specific install instructions, so the CLI copy stays
- *   concise and the canonical guide lives in one place.
- * - Never prescribes a token — students must request one from their
- *   organizer. This prevents the CLI from implying self-service token
- *   issuance.
- */
-/**
- * Renders the C→B upgrade prompt to stdout. No-op if conditions aren't met.
- *
- * @param examId   The submitted exam ID (from state.session.examId before clear)
- * @param passed   Whether the student met the passing bar
- */
-export declare function showCToBUpgradePrompt(examId: string | undefined, passed: boolean): void;

package/dist/lib/platform.d.ts

@@ -1,110 +0,0 @@
-/**
- * Platform detection primitives — 3 exported probes:
- *   isInWSL()            — running inside a WSL distribution
- *   isNativeWindowsCmd() — cmd.exe or PowerShell, NOT WSL
- *   hasPython()          — any python3 / python / py binary reachable
- *
- * Callers (repl.ts menu, exam.ts setup gate, exam.ts peek logic) inline
- * the policy decisions — e.g. `!isNativeWindowsCmd()` for "show exam setup"
- * and `isNativeWindowsCmd()` for "recommend C paper". This file stays as a
- * thin detection layer; policy lives with its caller.
- *
- * Context: Windows middle-school students (12-14 y/o) are an expected cohort
- * for ICOA 2026. Observed in-field: students blocked by WSL install complexity.
- * Windows native cmd + Node.js handles MCQ + AI chat but not Q31-36 practical
- * (Unix grep / strings / pwntools). Decision (v2.19.97 + v2.19.110): C paper
- * is the cmd / setup-less entry funnel. See the peek-based gate in exam.ts.
- */
-/**
- * Heuristic: true when running inside a WSL distribution. Node.js reports
- * `process.platform === 'linux'` in that case, but WSL sets specific env vars.
- */
-export declare function isInWSL(): boolean;
-/**
- * True when the user is on Windows native (cmd.exe or PowerShell), NOT a
- * WSL distribution.
- */
-export declare function isNativeWindowsCmd(): boolean;
-/**
- * True on Windows Node, full stop — no WSL env override.
- *
- * Inside a WSL distribution Node reports `process.platform === 'linux'`, so
- * `win32` on its own already means "not WSL". Prefer this over
- * isNativeWindowsCmd() wherever a wrong answer HIDES a diagnosis: a Windows
- * user who has set WSLENV on the Windows side (a documented way to configure
- * env passing into WSL) trips isInWSL() and would be told they are on Linux.
- * That is how the arena `/edit` "vi not found" message stayed wrong.
- */
-export declare function isNativeWindows(): boolean;
-/**
- * The "wrong build" trap: a WINDOWS icoa launched from inside a WSL shell.
- *
- * WSL appends the Windows PATH by default (`appendWindowsPath=true`), and a
- * Windows `npm i -g` writes THREE shims — `icoa.cmd`, `icoa.ps1`, and an
- * extensionless sh script `icoa` that bash will happily execute. So a student
- * who installed icoa with Windows npm and types `icoa` inside Ubuntu runs the
- * Windows build: the shell is Linux, the process is win32.
- *
- * Signature: platform is win32 while cwd is the WSL share. Windows resolves a
- * WSL directory as `\\wsl.localhost\<distro>\...` (older builds: `\\wsl$\`),
- * which no genuine Windows working directory looks like.
- *
- * Matters because the advice inverts: "go run it in Ubuntu" is a dead end for
- * someone already in Ubuntu — they need to install icoa on the Linux side.
- */
-export declare function isWindowsBuildInWslShell(cwd?: string, plat?: NodeJS.Platform): boolean;
-/**
- * Every absolute path `bin` could occupy on PATH, in PATH order. Pure — takes
- * env + platform so the win32 branch is unit-testable from a posix box.
- *
- * Windows needs PATHEXT expansion (`vi` never matches a bare `vi`; it would be
- * `vi.exe` / `vi.cmd`) and `;` as the PATH delimiter, so the separator and the
- * suffix set BOTH have to follow `plat`, not the host.
- */
-export declare function binaryCandidates(bin: string, env?: NodeJS.ProcessEnv, plat?: NodeJS.Platform): string[];
-/**
- * True when `bin` is reachable on PATH. A PATH scan, NOT a shell probe: the
- * old `execSync('command -v vi')` idiom is a POSIX-shell builtin, and on
- * Windows `execSync` routes through cmd.exe where `command` does not exist —
- * so it reported EVERY binary as missing regardless of what was installed.
- * (That is the v2.19.42x arena `/edit` "vi not found" false negative.)
- */
-export declare function whichBinary(bin: string, env?: NodeJS.ProcessEnv, plat?: NodeJS.Platform): boolean;
-/**
- * Probe whether any Python 3 binary is reachable. Silent — no stderr leaks
- * to the user. Used to decide whether Q31-35 practical questions are even
- * theoretically doable on this machine.
- *
- * Uses execFileSync (no shell) so probe failures don't leak cmd.exe's
- * "not recognized as internal or external command" messages to stdout.
- */
-export declare function hasPython(): boolean;
-/**
- * Detect duplicate icoa installations on PATH.
- *
- * Real-world failure mode (v2.19.103 → 2.19.111 upgrade incident, 2026-05-05):
- * a contestant's box had Node.js installed twice over time — first via NodeSource
- * (npm prefix /usr/local), later via apt (npm prefix /usr). The latest
- * `sudo npm install -g icoa-cli@latest` updated /usr/lib/... but PATH ordering
- * (/usr/local/bin > /usr/bin) meant `which icoa` still resolved to the
- * stale /usr/local copy. Banner stayed at "8 versions behind" forever; the
- * student / coordinator pinged the project lead.
- *
- * This probe surfaces the condition at startup so the user can resolve it
- * themselves. Runs `which -a icoa` (POSIX-only — skipped on Windows native).
- * For each result, attempts to read its package.json version so the banner
- * can clearly mark "older / newer / same".
- *
- * Returns an array of { path, version? } in PATH order. The FIRST entry is
- * what the shell currently runs. Empty/undefined version means the package
- * couldn't be resolved (broken symlink, atypical install layout).
- *
- * Performance: ~5ms total (one `which` call + 1-2 small file reads).
- * Performance budget at startup is generous; this stays well within it.
- */
-export interface IcoaInstall {
-    path: string;
-    version?: string;
-    pkgDir?: string;
-}
-export declare function detectIcoaInstalls(): IcoaInstall[];

package/dist/lib/py-syntax.d.ts

@@ -1,36 +0,0 @@
-export interface SyntaxEntry {
-    /** lookup keys — first one is the display title */
-    keys: string[];
-    en: string;
-    zh: string;
-    /** runnable demo; language-neutral, `# →` marks the result */
-    demo: string[];
-}
-export declare const SYNTAX_TABLE: SyntaxEntry[];
-/** Flat index of primary keys — what `/syntax` with no argument shows. */
-export declare const SYNTAX_INDEX: string[];
-/**
- * Exact-then-token match against the curated table.
- *
- * 🔴 Single-word keys match WHOLE TOKENS ONLY — never as a substring. A plain
- * `q.includes(k)` let the 2-char key `in` (the set entry) fire inside
- * "IndexError", so `/syntax IndexError` answered with set operations instead of
- * falling through to pydoc. Caught by the live arena PTY walk, not by the unit
- * test — the table is exactly where a wrong-but-confident answer hurts most.
- * Multi-word keys ("2d list", "fast io") still match as a phrase.
- */
-export declare function lookupLocal(query: string): SyntaxEntry | null;
-/** Nearest primary keys for a miss — suggestions, never a model. */
-export declare function nearKeys(query: string, limit?: number): string[];
-export interface PydocHit {
-    title: string;
-    lines: string[];
-}
-/** Ask the student's OWN interpreter. Returns null on any miss/error. */
-export declare function lookupPydoc(py: string, query: string, maxLines?: number): Promise<PydocHit | null>;
-/**
- * Render one lookup. All output is chalked (black-background rule). `zh`
- * selects the gloss language; demo code is never translated.
- */
-export declare function renderSyntax(hit: SyntaxEntry, zh: boolean): void;
-export declare function renderPydoc(hit: PydocHit, zh: boolean): void;

package/dist/lib/render-card.d.ts

@@ -1,17 +0,0 @@
-import type { Curriculum } from './learn-curricula.js';
-export type RenderCaps = {
-    tier: 'T0' | 'T1';
-    cols: number;
-    utf8: boolean;
-};
-export declare function detectCaps(): RenderCaps;
-/**
- * Render chart art for a list of chart_ids. Each chart prints on its own
- * "block" with a blank separator line above. Lines are left-padded with the
- * three-sided-frame left bar to match learn-render body style.
- *
- * Pass `frameLeft = false` for standalone (non-card-frame) contexts.
- */
-export declare function renderCharts(chartIds: string[] | undefined, charts: Curriculum['charts'], caps?: RenderCaps, opts?: {
-    frameLeft?: boolean;
-}): void;

package/dist/lib/repl-asker.d.ts

@@ -1,7 +0,0 @@
-export type Asker = (q: string) => Promise<string | null>;
-export interface AskerSession {
-    ask: Asker;
-    /** Restore the main REPL's 'line' listeners (or close the standalone rl). */
-    close: () => void;
-}
-export declare function makeReplAsker(): AskerSession;

package/dist/lib/resume.d.ts

@@ -1,7 +0,0 @@
-export interface ResumePoint {
-    kind: 'exam' | 'learn' | 'demo';
-    label: string;
-    command: string[];
-    urgent: boolean;
-}
-export declare function resolveResumePoint(): ResumePoint | null;

package/dist/lib/sample-runner.d.ts

@@ -1,14 +0,0 @@
-export declare const RUNNER_PY: string;
-/**
- * Write the runner to ~/.icoa/bin/icoa-judge.py (+ a `icoa-judge` shell shim on POSIX).
- * Idempotent: rewrites only if missing or stale (older version line). Stdlib-only —
- * needs nothing installed beyond a working python3 the student already has.
- */
-export declare function placeSampleRunner(): {
-    ok: boolean;
-    path: string;
-    updated: boolean;
-    why?: string;
-};
-/** Is a current copy of the runner present? (for `env` status display) */
-export declare function sampleRunnerInstalled(): boolean;

package/dist/lib/sandbox.d.ts

@@ -1,30 +0,0 @@
-/**
- * Sandbox images, newest first. `2026.1` bakes the aienv ML venv (core+data+
- * physics groups, mujoco==3.9.0 judge-parity pin) at ~/.icoa/aienv — the same
- * path `aienv setup` provisions on a host — so arena / self_check / notebook
- * flows work inside the container without teams self-installing an ML stack
- * that drifts from the server judge (the 2026-07 finals feedback). The legacy
- * `2026` tag stays as a fallback so the sandbox keeps working for users who
- * only have (or can only reach) the old image.
- */
-export declare const SANDBOX_IMAGES: readonly ["icoa/sandbox:2026.1", "icoa/sandbox:2026"];
-/**
- * Pick the sandbox image: any LOCAL image first (offline-graceful — never block
- * a session on a multi-GB pull when a working sandbox is already on disk), then
- * pull newest-first. null → caller decides the fallback (host shell / local
- * build). Probes are injected so the ladder stays pure + unit-tested (tests
- * live in test/shell-sandbox-mounts.test.js via the shell.ts re-export).
- */
-export declare function resolveSandboxImage(hasLocal: (image: string) => boolean, pull: (image: string) => boolean, images?: readonly string[]): string | null;
-/**
- * Is Docker usable right now? Probes the daemon socket directly (never the
- * `docker` CLI) so a stopped Docker Desktop is NOT auto-started — the sandbox
- * is optional and the host shell is the fallback, so merely *checking* must not
- * wake Docker. See lib/docker-probe.ts.
- */
-export declare function isDockerAvailable(): Promise<boolean>;
-export declare function ensureSandbox(): Promise<boolean>;
-export declare function runInSandbox(command: string, rl: {
-    pause: () => void;
-    resume: () => void;
-}): Promise<void>;

package/dist/lib/secure-store.d.ts

@@ -1,18 +0,0 @@
-export type IntegrityVerdict = 'ok' | 'tampered' | 'unsigned' | 'absent' | 'corrupt';
-export interface SigBlock {
-    v: 1;
-    alg: 'HS256';
-    mac: string;
-    ts: string;
-}
-export declare function deriveFileKey(installSalt: string, fileId: string): Buffer;
-export declare function canonicalize(obj: unknown): string;
-export declare function signObject(payload: object, key: Buffer): SigBlock;
-export declare function verifyObject(payloadWithSig: object, key: Buffer): IntegrityVerdict;
-export declare function writeSignedFile(path: string, payload: object, key: Buffer): void;
-export declare function readSignedFile<T>(path: string, key: Buffer): {
-    data: T | null;
-    verdict: IntegrityVerdict;
-};
-export declare function recordVerdict(fileId: string, verdict: IntegrityVerdict): void;
-export declare function collectVerdicts(): Record<string, IntegrityVerdict>;