icoa-cli 2.19.458 → 2.19.460

package/dist/lib/i18n.d.ts

@@ -1,215 +0,0 @@
-type Strings = Partial<typeof EN>;
-export declare const EN: {
-    howToPlay: string;
-    htpAnswer: string;
-    htpHelp: string;
-    htpNav: string;
-    htpMoreHelp: string;
-    htpBack: string;
-    htpLang: string;
-    egg3: string;
-    egg5: string;
-    egg7: string;
-    egg9: string;
-    egg11: string;
-    egg13: string;
-    egg15: string;
-    answerThis: string;
-    helpRemove: string;
-    helpUsedUp: string;
-    helpAllUsed: string;
-    wrong: string;
-    qTutorial: string;
-    qTutorialBlock: string;
-    qTutorialRequired: string;
-    allAnswered: string;
-    typeSubmit: string;
-    autoSubmitting: string;
-    grading: string;
-    complete: string;
-    passed: string;
-    notPassed: string;
-    score: string;
-    incorrectIntro: string;
-    yourAnswer: string;
-    correct: string;
-    perfectScore: string;
-    theoryDone: string;
-    theoryDone2: string;
-    didYouKnow: string;
-    ctfHistory1: string;
-    ctfHistory2: string;
-    ctfHistory3: string;
-    ctfFlags1: string;
-    ctfFlags2: string;
-    ctfFlags3: string;
-    timeline1: string;
-    timeline2: string;
-    timeline3: string;
-    twoTracks: string;
-    ai4ctfDesc: string;
-    ai4ctfSub: string;
-    ctf4aiDesc: string;
-    ctf4aiSub: string;
-    wantToContinue: string;
-    orBack: string;
-    ai4ctfTitle: string;
-    ai4ctfSample: string;
-    ai4ctfChallenge: string;
-    ai4ctfIntercepted: string;
-    ai4ctfDecode: string;
-    ai4ctfLevels: string;
-    ai4ctfHintA: string;
-    ai4ctfHintAUses: string;
-    ai4ctfHintB: string;
-    ai4ctfHintBUses: string;
-    ai4ctfHintC: string;
-    ai4ctfHintCUses: string;
-    ai4ctfTryNow: string;
-    ai4ctfExample: string;
-    ai4ctfFreeChat: string;
-    ai4ctfExit: string;
-    ai4ctfReport: string;
-    ai4ctfTokens: string;
-    ai4ctfModel: string;
-    ai4ctfNext: string;
-    tokenLimit: string;
-    ctf4aiTitle: string;
-    ctf4aiChallenge: string;
-    ctf4aiIntro1: string;
-    ctf4aiIntro2: string;
-    ctf4aiRule: string;
-    ctf4aiMission: string;
-    ctf4aiIdeas: string;
-    ctf4aiIdea1: string;
-    ctf4aiIdea2: string;
-    ctf4aiIdea3: string;
-    ctf4aiIdea4: string;
-    ctf4aiBudget: string;
-    ctf4aiQuit: string;
-    ctf4aiSuccess: string;
-    ctf4aiDefense: string;
-    ctf4aiInjection: string;
-    ctf4aiHeld: string;
-    reportTitle: string;
-    reportStage1: string;
-    reportCompleted: string;
-    reportStage2: string;
-    reportExperienced: string;
-    reportStage2Sub: string;
-    reportStage2Hints: string;
-    reportStage3: string;
-    reportSolved: string;
-    reportNotSolved: string;
-    reportRecommend: string;
-    reportRec1: string;
-    reportRec2: string;
-    reportRec3: string;
-    reportRec4: string;
-    reportReady: string;
-    reportNations: string;
-    reportAbout: string;
-    reportDemo: string;
-    continueTitle: string;
-    continueLevels: string;
-    continueHints: string;
-    continueHintA: string;
-    continueHintB: string;
-    continueHintC: string;
-    continueTry: string;
-    continueChat: string;
-    continueAfter: string;
-    ai4ctfCommands: string;
-    ai4ctfSubmitCmd: string;
-    ai4ctfShellCmd: string;
-    ai4ctfEndSession: string;
-    ai4ctfCorrectFlag: string;
-    ai4ctfDecoded: string;
-    ai4ctfWouldEarn: string;
-    ai4ctfWrongFlag: string;
-    ai4ctfFlagHint: string;
-    ai4ctfFoundFlag: string;
-    ai4ctfThinking: string;
-    ctf4aiRelaxed: string;
-    ctf4aiEnded: string;
-    ctf4aiAlready: string;
-    ctf4aiPrompt: string;
-    ctf4aiThinking: string;
-    readyToTry: string;
-    forNational: string;
-    viewRegions: string;
-    enterExam: string;
-    htpJump: string;
-    htpReview: string;
-    htpSubmit: string;
-    htpMark: string;
-    nextLabel: string;
-    reportRetryCta: string;
-    reportRetryWrongN: string;
-    reportRetryWrongNPlural: string;
-    reportBackHint: string;
-    reportAboutHint: string;
-    reportExamSetupHint: string;
-    ai4ctfExitNextTitle: string;
-    ai4ctfExitNextSub: string;
-    ai4ctfExitNextBody: string;
-    ai4ctfExitCmdNext: string;
-    ai4ctfExitCmdBack: string;
-    ai4ctfWelcomeCta: string;
-    ai4ctfHintNudge: string;
-    ai4ctfHintTechnique: string;
-    ai4ctfHintPrinciple: string;
-    ai4ctfWelcomeNoReveal: string;
-    ai4ctfOrChat: string;
-    ai4ctfOrChatExample: string;
-    ai4ctfCmdHintLine: string;
-    ai4ctfCmdShellLine: string;
-    ai4ctfHintABody: string;
-    ai4ctfHintBBody: string;
-    ai4ctfHintCBody: string;
-    ai4ctfHintNextA: string;
-    ai4ctfHintNextB: string;
-    ai4ctfHintNextC: string;
-    examWaysToSolve: string;
-    examWaysSavedTo: string;
-    examWaysShell: string;
-    examWaysPythonRepl: string;
-    examWaysRefPython: string;
-    examWaysAi4ctf: string;
-    examWaysFound: string;
-    ai4ctfWrapTitle: string;
-    ai4ctfWrapLine1Head: string;
-    ai4ctfWrapLine1Body: string;
-    ai4ctfWrapLine2Head: string;
-    ai4ctfWrapLine2Body: string;
-    ai4ctfWrapQuotasTitle: string;
-    ai4ctfWrapQuotaA: string;
-    ai4ctfWrapQuotaAHint: string;
-    ai4ctfWrapQuotaB: string;
-    ai4ctfWrapQuotaBHint: string;
-    ai4ctfWrapQuotaC: string;
-    ai4ctfWrapQuotaCHint: string;
-    ai4ctfWrapQuotaFooter: string;
-    ai4ctfWrapNextTitle: string;
-    ai4ctfWrapNextSub: string;
-    ai4ctfWrapNextBody: string;
-    ai4ctfWrapNoProg: string;
-    ai4ctfWrapTypeCtf4ai: string;
-    typeAndEnterToBegin: string;
-    ai4ctfRevealTitle: string;
-    ai4ctfRevealBody: string;
-    ai4ctfRevealSeeFlag: string;
-    ai4ctfRevealThenSubmit: string;
-    ai4ctfRevealLockNote: string;
-    ai4ctfLockedTitle: string;
-    ai4ctfLockedUse: string;
-    ai4ctfLockedThen: string;
-};
-/**
- * Force (re)load the UI pack for `lang` into the in-memory cache. Call right
- * after a fetch (boot / lang switch) so a freshly-downloaded ui.json takes
- * effect even if t() already memoized an empty pack for this lang.
- */
-export declare function loadUiPack(lang: string): void;
-export declare function t(key: keyof Strings): string;
-export {};

package/dist/lib/input-dynamics.d.ts

@@ -1,38 +0,0 @@
-import type { InputDynamics } from '../types/index.js';
-export declare const FOCUS_CARRY_MAX_GAP_MS = 20;
-export declare function classifyBurst(interKeyMs: number[]): {
-    maxBurst: number;
-    suspectPaste: boolean;
-};
-export declare function countFocusMarkers(s: string): {
-    focusIn: number;
-    focusOut: number;
-};
-export declare function getFocusState(): 'in' | 'out' | 'unknown';
-export declare function consumeFocusEvents(): Array<{
-    kind: 'focus_in' | 'focus_out';
-    ts: number;
-}>;
-export declare function rearmFocusMode(): void;
-export declare function stripTerminalMarkers(line: string): string;
-export declare function installInputDynamics(enableBracketed?: boolean): void;
-export declare function uninstallInputDynamics(): void;
-/** Reset focus-probe state to fresh, feed raw chunks through the real onData
- *  handler in order, and return whatever focus events resulted.
- *
- *  `gapsMs[i]` is the simulated delay BEFORE chunk `i + 1` (i.e. gapsMs[0] is
- *  the gap between chunk 0 and chunk 1). Omitted/undefined entries default to
- *  0ms — back-to-back chunks, exactly what a genuinely torn escape sequence
- *  looks like. This drives onData's real `nowOverride` parameter (fix round
- *  2's staleness bound) with a simulated clock rather than adding a separate
- *  clock-injection global — the timestamp rides this existing test seam. */
-export declare function __feedFocusDataForTest(chunks: string[], gapsMs?: number[]): Array<{
-    kind: 'focus_in' | 'focus_out';
-    ts: number;
-}>;
-/** Feed one synthetic keypress event through the real onKeypress handler. */
-export declare function __feedKeypressForTest(key: {
-    name?: string;
-    code?: string;
-} | undefined): void;
-export declare function consumeLineDynamics(): InputDynamics | undefined;

package/dist/lib/integrity-snapshot.d.ts

@@ -1,22 +0,0 @@
-/**
- * Pure payload builder — no I/O, no network. Extracted from
- * `postIntegritySnapshot` so the SCRUBBED shape (and the secret-exclusion
- * invariant: config.accessToken / config.token never enter this object) is
- * unit-testable without a live server or filesystem.
- */
-export declare function buildSnapshotPayload(cfg: {
-    deviceFingerprint?: string;
-    installSalt?: string;
-}, budget: {
-    tokensUsed: number;
-    tokenCap: number;
-}, extras?: {
-    simCooldown?: unknown;
-    tokenBindings?: unknown;
-}): Record<string, unknown>;
-/**
- * Fire a scrubbed integrity snapshot to the server. Best-effort, non-blocking,
- * and self-swallowing — callers may `await` it inside an existing try/catch
- * without risking the submit flow.
- */
-export declare function postIntegritySnapshot(): Promise<void>;

package/dist/lib/interactive-spawn.d.ts

@@ -1,25 +0,0 @@
-/**
- * Run an interactive child process (nc / ncat / ssh) with the terminal fully
- * released so the user's INPUT and Ctrl-C reach the child.
- *
- * Why this exists (BUG: pwn `connect` could read output but not send input and
- * Ctrl-C was dead): when dispatched IN-PROCESS from the icoa REPL, the main
- * readline holds stdin in RAW mode. A child spawned with `stdio: 'inherit'`
- * then inherits a raw, non-blocking stdin → its reads see no keystrokes, and
- * raw mode means Ctrl-C is delivered as a byte (0x03), never as SIGINT → the
- * session looks frozen and won't quit. `execSync`/`execFileSync` never dropped
- * raw mode, which is the bug.
- *
- * This mirrors repl.ts `runSystemCommand`'s proven TTY dance (pause the rl +
- * `setRawMode(false)` + async spawn + restore), but pulls the active REPL
- * readline via getMainRl() so it works BOTH inside the REPL and standalone
- * (`icoa connect …`, where getMainRl() === null → pause/restore are no-ops).
- *
- * Pass a file + args (no shell — injection-safe, preferred for server-supplied
- * host/port) OR set `shell: true` to run `file` as a full command string.
- *
- * Resolves with the child's exit code (1 on spawn error).
- */
-export declare function runInteractive(file: string, args?: string[], opts?: {
-    shell?: boolean;
-}): Promise<number>;

package/dist/lib/ipynb-input.d.ts

@@ -1,25 +0,0 @@
-/**
- * ipynb-input — pure cell-input decision logic for the `icoa ipynb` REPL
- * (Phase 1 UI of the CLI notebook arena).
- *
- * IPython-style model: a one-liner runs the moment you press Enter; a block
- * (def/for/if/…, an open bracket, or a trailing backslash) keeps accepting
- * lines until you end it with a blank line. Kept pure so the rule is unit-
- * tested without a kernel or readline.
- */
-/**
- * Does this line open a multi-line block? True when its CODE portion (trailing
- * `#` comment stripped) ends with a colon. Naive comment-strip — good enough for
- * opener detection (a real block opener never hides its colon in a comment).
- */
-export declare function isBlockOpener(line: string): boolean;
-/**
- * Given the lines accumulated SO FAR (including the just-entered line), decide
- * whether to execute the cell now or keep taking input.
- *
- *  - empty buffer → nothing to run (false),
- *  - multi-line cell → execute as soon as the last line is blank,
- *  - single line → execute unless it opens a block / ends with `\` / has an
- *    unbalanced bracket.
- */
-export declare function shouldExecuteCell(lines: string[]): boolean;

package/dist/lib/kaggle.d.ts

@@ -1,115 +0,0 @@
-/**
- * kaggle — pure core behind `icoa kaggle` (Kaggle-style practice arena, M0).
- *
- * The student loop this powers: download a competition dataset that the ICOA
- * server hosts (never bundled into npm — Thin-Client plane 3), open a starter
- * notebook in `icoa ipynb`, run all cells on the LOCAL CPU kernel to produce
- * `submission.csv`, then submit it on kaggle.com manually (their own account —
- * no Kaggle API, no shared-account ToS risk).
- *
- * Unlike the arena starter (MODEL cell deliberately blank — that part is
- * judged server-side), the Kaggle starter ships a WORKING baseline: nothing
- * here is graded by us, Kaggle is the judge, and M0's whole point is that the
- * chain runs end-to-end without edits. The student then improves the model.
- *
- * Pure module: no I/O, no chalk — everything unit-testable.
- */
-import type { NbCell } from './notebook-doc.js';
-export interface KaggleTask {
-    comp_id: string;
-    title: string;
-    metric: string;
-    /** Student-facing challenge intro: what each row is, what you predict, how
-     * it's scored. Rendered in the download flow and as the notebook's cell 1. */
-    description?: string;
-    kaggle_url?: string | null;
-    licence?: string;
-    attribution?: string;
-    /** M1: base URL of this competition's public Object-Storage prefix. When
-     * present the client fetches the CSVs straight from the bucket (practice
-     * serves only this pointer); absent → M0 fallback via the /data bundle. */
-    data_base?: string | null;
-    id_col?: string;
-    target_col?: string;
-    n_train?: number;
-    n_test?: number;
-    /** M2.5 (one engine, two judges): absent/"kaggle" → manual kaggle.com upload;
-     * "icoa-holdout" → `kaggle submit` scores server-side vs secret labels and
-     * lands on the ICOA Board. */
-    judge?: string;
-    /** Board event this competition's submissions are recorded under. */
-    board_event?: string | null;
-    /** Task-4 Audio Classifier: a GPU task whose (large) dataset already lives on
-     * the GPU box. The client does NOT download data locally — it fetches the
-     * notebook and points the student at `gpu on`. */
-    needs_gpu?: boolean;
-}
-export type KaggleMeta = KaggleTask;
-/** Extract the task list from a server response ({success,data:{tasks}} or bare). */
-export declare function parseKaggleTaskList(resp: unknown): KaggleTask[];
-export interface DataFileUrls {
-    train: string;
-    test: string;
-    sample_submission: string;
-}
-/** The three CSV URLs under a competition's bucket prefix, or null when the
- * server advertised no bucket (client then falls back to the /data bundle). */
-export declare function dataFileUrls(task: {
-    data_base?: string | null;
-}): DataFileUrls | null;
-/**
- * Build the starter notebook cells for a competition. The data dir is baked in
- * as an absolute path so the notebook runs from anywhere; the submission cell
- * uses the meta's id/target column names so its output matches
- * sample_submission.csv byte-for-byte in shape.
- */
-export declare function buildStarterCells(dir: string, meta: KaggleMeta): NbCell[];
-export interface SubmitOutcome {
-    ok: boolean;
-    score?: number;
-    metric?: string;
-    rank?: number | null;
-    fieldSize?: number | null;
-    deduped?: boolean;
-    boardEvent?: string | null;
-    /** machine-readable failure: network · bad_token · format · kaggle_judged ·
-     * event_closed · outside_window · cap_reached · judge_unavailable · … */
-    reason?: string;
-    error?: string;
-    problems?: string[];
-}
-/** Unwrap the server's judge response ({success,data} envelope or bare). */
-export declare function parseSubmitResponse(resp: unknown): SubmitOutcome;
-export interface SubmissionVerdict {
-    ok: boolean;
-    problems: string[];
-}
-/**
- * Validate a submission CSV against sample_submission.csv the way Kaggle's
- * uploader would: same header, same row count, same id set (any order), no
- * empty cells. Both files are program-generated simple CSVs (no quoting), so
- * naive comma-splitting is safe here.
- */
-export declare function validateSubmissionText(submission: string, sample: string): SubmissionVerdict;
-/**
- * Starter cells for a teleload-only task — the 6 sprint tasks whose dataset is a
- * pack of images / weights / archives rather than a CSV three-pack.
- *
- * Those tasks shipped with NO notebook at all: `teleload` unpacked a folder and
- * left the student staring at it. This is deliberately an ORIENTATION starter,
- * not a solution — it inventories the pack, draws one picture of what is inside,
- * and states what has to be built. Shipping the official winning notebook here
- * would hand over the answer and delete the exercise.
- *
- * Same cell model as the CSV starter: markdown for prose, python for work, one
- * `plt.show()` so `icoa ipynb` writes exactly one figure and opens one viewer.
- */
-export declare function buildMediaStarterCells(dir: string, task: {
-    seq?: number;
-    title?: string;
-    topic_cn?: string;
-    media?: {
-        kind?: string;
-        glob?: string;
-    };
-}): NbCell[];

package/dist/lib/kernel-protocol.d.ts

@@ -1,92 +0,0 @@
-/**
- * Kernel protocol — the pure Node side of the Node ↔ Python-bridge boundary
- * (Phase 1 of the CLI notebook arena, see `project_cli_notebook_arena_plan`).
- *
- * icoa is TypeScript/Node, but Jupyter kernels are driven by `jupyter_client`
- * (Python). So a thin Python bridge (shipped alongside, run from the aienv
- * venv) owns the kernel and speaks a line-delimited JSON protocol to Node: one
- * event object per stdout line. This module parses those lines and folds them
- * into renderable cell outputs.
- *
- * Keeping this layer pure (no I/O) means the wire contract is unit-tested
- * without spawning Python — and it stays identical whether the bridge drives a
- * LOCAL kernel (Phase 1) or a REMOTE one over a Kernel Gateway (Phase 2/4). The
- * Node side never changes; only the bridge's connection does.
- */
-/** Events the Python bridge emits, one JSON object per stdout line. */
-export type KernelEvent = {
-    type: 'ready';
-} | {
-    type: 'stream';
-    name: 'stdout' | 'stderr';
-    text: string;
-} | {
-    type: 'result';
-    text: string;
-    data?: Record<string, string>;
-} | {
-    type: 'display';
-    data: Record<string, string>;
-} | {
-    type: 'error';
-    ename: string;
-    evalue: string;
-    traceback: string[];
-} | {
-    type: 'done';
-    id: number;
-    count: number | null;
-} | {
-    type: 'file';
-    id: number;
-    data: string;
-    size: number;
-} | {
-    type: 'file_error';
-    id: number;
-    message: string;
-} | {
-    type: 'fatal';
-    message: string;
-};
-/** Normalized, render-ready outputs for one executed cell. */
-export type CellOutput = {
-    kind: 'stream';
-    name: 'stdout' | 'stderr';
-    text: string;
-} | {
-    kind: 'result';
-    text: string;
-    data?: Record<string, string>;
-} | {
-    kind: 'display';
-    data: Record<string, string>;
-} | {
-    kind: 'error';
-    ename: string;
-    evalue: string;
-    traceback: string[];
-};
-export interface FoldedCell {
-    outputs: CellOutput[];
-    /** false if the cell raised. */
-    ok: boolean;
-    /** the kernel's execution_count, or null if no `done` event was seen. */
-    execCount: number | null;
-}
-/**
- * Parse one stdout line from the bridge into a KernelEvent. Returns null for
- * blank lines, non-JSON, or JSON without a recognized `type` (the bridge may
- * interleave incidental output; we ignore anything not in the protocol).
- */
-export declare function parseKernelEvent(line: string): KernelEvent | null;
-/**
- * Fold a cell's event stream into renderable outputs.
- *
- *  - consecutive `stream` events of the SAME name coalesce into one text block
- *    (matches Jupyter's stdout/stderr batching → clean rendering),
- *  - `result` / `display` / `error` pass through as discrete blocks,
- *  - any `error` sets ok=false,
- *  - `done.count` becomes execCount (null if the cell never finished).
- */
-export declare function foldCellOutputs(events: KernelEvent[]): FoldedCell;

package/dist/lib/kernel.d.ts

@@ -1,81 +0,0 @@
-/**
- * NotebookKernel — the Node driver for a Jupyter kernel, Phase 1 of the CLI
- * notebook arena (see `project_cli_notebook_arena_plan`).
- *
- * icoa (Node) can't talk to a Jupyter kernel directly, so we spawn a small
- * Python BRIDGE under the aienv venv. The bridge owns the kernel via
- * `jupyter_client` and exchanges line-delimited JSON with us (parsed by
- * `kernel-protocol.ts`). This keeps the kernel a PLUGGABLE backend: Phase 1
- * runs it locally; Phase 2/4 point the same bridge at a remote Kernel Gateway
- * with zero change to the Node side.
- *
- * Isolation: the bridge runs as `<venv>/bin/python`, and it registers its
- * kernelspec INSIDE the venv's own `share/jupyter` tree — so the kernel is the
- * venv interpreter, never the system python3 (BUG3 invariant), and nothing is
- * written outside the venv. On posix the kernel uses IPC transport (unix
- * sockets) so it opens no TCP ports.
- */
-import { type FoldedCell } from './kernel-protocol.js';
-export declare const KERNEL_BRIDGE_PY: string;
-export interface KernelSpawnSpec {
-    command: string;
-    args: string[];
-}
-export interface KernelStartOptions {
-    /** Local kernel: absolute path to the venv python (from aienvPaths().python). */
-    venvPython?: string;
-    /** Local kernel: directory to drop the bridge script in (the venv root). */
-    venvRoot?: string;
-    /** Remote kernel (M2 GPU sessions): spawn THIS instead of the local venv
-     * bridge — typically `ssh … <buildRemoteBridgeCommand(...)>`. The bridge
-     * rides inside the command itself, so the box needs no pre-provisioned
-     * bridge file; the wire protocol is identical to the local kernel. */
-    spawnSpec?: KernelSpawnSpec;
-    /** Optional: max ms to wait for the kernel `ready` event. */
-    readyTimeoutMs?: number;
-}
-/**
- * The single shell-command string that runs the bridge on a remote box (the
- * one argument after `ssh user@host`). The bridge source travels as base64
- * inside a `python -c exec(...)` so any box with the ML venv works — nothing
- * to pre-install beyond the venv itself. `env` carries the fixed-path dataset
- * pointers (ICOA_KAGGLE_DATA / ICOA_KAGGLE_OUT — the §4 UX invariant), `cwd`
- * is the per-session workspace.
- */
-export declare function buildRemoteBridgeCommand(remotePython: string, env?: Record<string, string>, cwd?: string): string;
-/**
- * A live notebook kernel. Executes are serialized (one cell at a time, as a
- * notebook does) so the line-buffered output demux stays unambiguous.
- */
-export declare class NotebookKernel {
-    private proc;
-    private buf;
-    private errTail;
-    private nextId;
-    private ready;
-    private pending;
-    private pendingFetch;
-    private onReady;
-    private onExit;
-    private readonly opts;
-    private readonly bridgePath;
-    constructor(opts: KernelStartOptions);
-    /**
-     * Write the bridge + spawn it; resolves once the kernel reports `ready`.
-     * Safe to call again after shutdown() to get a fresh kernel (restart) — all
-     * per-run state is reset here.
-     */
-    start(): Promise<void>;
-    /** Run one cell; resolves with its folded outputs after the `done` event. */
-    execute(code: string): Promise<FoldedCell>;
-    /**
-     * Fetch one small file from the kernel's filesystem (local box or remote
-     * GPU box — same pipe either way). Resolves with the raw bytes; rejects on
-     * missing file or the bridge's 20MB artifact cap.
-     */
-    fetchFile(path: string): Promise<Buffer>;
-    /** Ask the bridge to shut the kernel down; resolves when the process exits. */
-    shutdown(): Promise<void>;
-    private onStdout;
-    private handleEvent;
-}