@cmetech/otto 1.1.1 → 1.2.4

package/packages/coworker-scratchpad/dist/child-process-runtime.js

@@ -0,0 +1,427 @@
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+import { writeNdjson, readNdjson } from '@otto/coworker-utils';
+import { filterEnv, kernelExecArgv, resolveKernelEntry } from './kernel-spawn.js';
+import { isDataLoadEvent, isProgressEvent, isStartupErrorEvent, isSnapshotResult, isArtifactCreateEvent, isArtifactCreateRequest, isArtifactUpdateRequest, } from './kernel-protocol.js';
+const DEFAULT_CELL_TIMEOUT_MS = 120_000;
+const DEFAULT_INACTIVITY_MS = 30_000;
+const DEFAULT_INACTIVITY_AFTER_PROGRESS_MS = 60_000;
+const DEFAULT_CANCEL_GRACE_MS = 2_000;
+const MAX_RESTARTS_BEFORE_SUCCESS = 1;
+export class ChildProcessRuntime {
+    options;
+    child = null;
+    pending = new Map();
+    pendingSnapshots = new Map();
+    activeId = null;
+    nextId = 1;
+    alive = false;
+    childReady = false;
+    disposed = false;
+    restartsSinceSuccess = 0;
+    recoveryNotes_ = [];
+    resolveReady = () => { };
+    rejectReady = () => { };
+    ready = Promise.resolve();
+    /**
+     * Phase 2 Task 13: timestamp of the most recent successful spawn(). Used by
+     * higher-level staleness checks (Task 15) to decide whether a warm kernel's
+     * env-injected credentials need to be refreshed. Pre-start() value is epoch
+     * so callers can distinguish "never spawned" without nullable juggling.
+     */
+    spawnTime = new Date(0);
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        if (this.disposed)
+            throw new Error('runtime disposed');
+        await this.spawnChild();
+    }
+    /**
+     * Phase 2 Task 13: env construction split out so the injector hop has a clean
+     * seam to extend. Existing semantics unchanged: filterEnv applies the kernel's
+     * allowlist/denylist, then (when configured) the injector overlays OTTO_DS_*
+     * vars from vault entries. Only the spawned child sees the result; the parent
+     * process.env is never mutated.
+     */
+    async buildBaseEnv() {
+        const base = filterEnv(process.env);
+        const { injector, bindings } = this.options;
+        if (!injector || !bindings || bindings.length === 0)
+            return base;
+        return injector.injectEnv(base, bindings, {
+            scratchpadName: this.options.scratchpadName ?? '',
+            sessionId: this.options.sessionId ?? '',
+            pid: process.pid,
+        });
+    }
+    async spawnChild() {
+        this.ready = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        const entry = this.options.entryPath ?? resolveKernelEntry();
+        const args = [...kernelExecArgv(), entry, this.options.workspace];
+        if (this.options.scratchpadDir !== undefined)
+            args.push(this.options.scratchpadDir);
+        const env = await this.buildBaseEnv();
+        const child = spawn(process.execPath, args, { stdio: ['pipe', 'pipe', 'inherit'], cwd: process.cwd(), env });
+        this.child = child;
+        this.alive = true;
+        this.childReady = false;
+        // Phase 2 Task 13: stamp spawnTime immediately after a successful spawn.
+        // Done synchronously so the ready promise (which the caller awaits) reflects
+        // a non-epoch spawnTime by the time start() returns.
+        this.spawnTime = new Date();
+        child.on('exit', (code, signal) => {
+            if (this.child !== child)
+                return; // superseded by a restart
+            this.alive = false;
+            this.childReady = false;
+            if (this.disposed)
+                return;
+            const err = new Error(`kernel exited (code=${code ?? 'null'}, signal=${signal ?? 'null'})`);
+            this.rejectReady(err); // no-op if ready already resolved
+            this.failAllPending(err);
+        });
+        void this.readLoop(child);
+        return this.ready;
+    }
+    async readLoop(child) {
+        try {
+            for await (const raw of readNdjson(child.stdout)) {
+                if (this.child !== child)
+                    break; // superseded by a restart
+                const frame = raw;
+                if (frame.type === 'event') {
+                    if (frame.event === 'ready') {
+                        if (frame.recovery_notes)
+                            this.recoveryNotes_ = [...frame.recovery_notes];
+                        this.childReady = true;
+                        this.resolveReady();
+                    }
+                    else if (isStartupErrorEvent(frame)) {
+                        const err = new Error(frame.error.message);
+                        err.name = `startup_error/${frame.kind}`;
+                        this.rejectReady(err);
+                    }
+                    else if (isDataLoadEvent(frame))
+                        this.options.onDataLoad?.(frame.drawer);
+                    else if (isArtifactCreateEvent(frame))
+                        this.options.onArtifactCreate?.(frame.drawer);
+                    else if (isProgressEvent(frame))
+                        this.resetInactivity();
+                    continue;
+                }
+                if (isSnapshotResult(frame)) {
+                    const resolver = this.pendingSnapshots.get(frame.id);
+                    if (resolver) {
+                        this.pendingSnapshots.delete(frame.id);
+                        resolver(frame);
+                    }
+                    continue;
+                }
+                // Phase 4 Task 10: artifact RPC requests originate from the kernel and
+                // are serviced by the manager via handleArtifactCreate/Update. Handle
+                // before the result-fallthrough — these frames carry a string `id`
+                // (kernel mints `art-<pid>-<seq>`) and would otherwise be miskeyed
+                // against the numeric `pending` map.
+                if (isArtifactCreateRequest(frame)) {
+                    void this.handleArtifactCreateRpc(frame);
+                    continue;
+                }
+                if (isArtifactUpdateRequest(frame)) {
+                    void this.handleArtifactUpdateRpc(frame);
+                    continue;
+                }
+                if (frame.type !== 'result')
+                    continue; // defensive: unknown frame shape
+                const p = this.pending.get(frame.id);
+                if (!p)
+                    continue;
+                clearTimeout(p.totalTimer);
+                clearTimeout(p.inactivityTimer);
+                this.pending.delete(frame.id);
+                if (this.activeId === frame.id)
+                    this.activeId = null;
+                this.restartsSinceSuccess = 0; // a completed cell proves the kernel is healthy
+                if (frame.ok) {
+                    p.resolve({ value: frame.value, stdout: frame.stdout });
+                }
+                else {
+                    const err = new Error(frame.error.message);
+                    err.name = frame.error.name;
+                    if (frame.error.stack)
+                        err.stack = frame.error.stack;
+                    p.reject(err);
+                }
+            }
+        }
+        catch (err) {
+            this.failAllPending(err);
+        }
+    }
+    resetInactivity() {
+        if (this.activeId === null)
+            return;
+        const id = this.activeId;
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        p.inactivityWindowMs =
+            this.options.inactivityAfterProgressMs ?? DEFAULT_INACTIVITY_AFTER_PROGRESS_MS;
+        clearTimeout(p.inactivityTimer);
+        p.inactivityTimer = setTimeout(() => this.onInactivityTimeout(id), p.inactivityWindowMs);
+    }
+    onInactivityTimeout(id) {
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        clearTimeout(p.totalTimer);
+        this.pending.delete(id);
+        if (this.activeId === id)
+            this.activeId = null;
+        this.markDead();
+        p.reject(new Error(`cell ${id} timed out after ${p.inactivityWindowMs}ms of inactivity`));
+    }
+    onTotalTimeout(id, totalMs) {
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        clearTimeout(p.inactivityTimer);
+        this.pending.delete(id);
+        if (this.activeId === id)
+            this.activeId = null;
+        this.markDead();
+        p.reject(new Error(`cell ${id} timed out after ${totalMs}ms (total wall-clock)`));
+    }
+    async runCell(code) {
+        if (this.disposed)
+            throw new Error('runtime disposed');
+        if (!this.alive) {
+            if (this.restartsSinceSuccess >= MAX_RESTARTS_BEFORE_SUCCESS) {
+                throw new Error(`kernel repeatedly crashed (${this.restartsSinceSuccess} restart(s) without a successful cell); giving up`);
+            }
+            this.restartsSinceSuccess++;
+            this.spawnChild(); // start a fresh kernel; the write below waits for its ready
+        }
+        const id = this.nextId++;
+        const totalMs = this.options.cellTimeoutMs ?? DEFAULT_CELL_TIMEOUT_MS;
+        const inactivityMs = this.options.inactivityTimeoutMs ?? DEFAULT_INACTIVITY_MS;
+        const result = new Promise((resolve, reject) => {
+            const totalTimer = setTimeout(() => this.onTotalTimeout(id, totalMs), totalMs);
+            const inactivityTimer = setTimeout(() => this.onInactivityTimeout(id), inactivityMs);
+            this.pending.set(id, { resolve, reject, totalTimer, inactivityTimer, inactivityWindowMs: inactivityMs });
+        });
+        // Register the active cell synchronously so cancel()/timeouts can act on it even
+        // while a restarted kernel is still starting up. Send the code once it's ready.
+        this.activeId = id;
+        const ready = this.ready;
+        void ready
+            .then(() => {
+            const child = this.child;
+            if (child && this.pending.has(id))
+                return writeNdjson(child.stdin, { id, type: 'run', code });
+        })
+            .catch(() => {
+            // ready rejected (kernel died during startup); the exit handler/cancel rejects this cell.
+        });
+        return result;
+    }
+    async cancel() {
+        const child = this.child;
+        if (!child || !this.alive)
+            return;
+        const id = this.activeId;
+        if (!this.childReady) {
+            // The kernel is still starting (e.g. a fresh restart). SIGINT would race the
+            // child's SIG_IGN handler install and could kill it before it's installed, so
+            // escalate straight to a hard kill and reject the active cell as cancelled.
+            this.rejectActive(id, `cell ${id} cancelled`);
+            this.markDead();
+            return;
+        }
+        child.kill('SIGINT'); // child ignores SIGINT between cells; no-op for sync vm code mid-cell
+        if (id === null)
+            return; // nothing running: the gentle signal is harmless
+        await new Promise((r) => setTimeout(r, this.options.cancelGraceMs ?? DEFAULT_CANCEL_GRACE_MS));
+        const p = this.pending.get(id);
+        if (!p)
+            return; // settled within the grace window
+        clearTimeout(p.totalTimer);
+        clearTimeout(p.inactivityTimer);
+        this.pending.delete(id);
+        if (this.activeId === id)
+            this.activeId = null;
+        this.markDead(); // escalate: SIGTERM -> SIGKILL
+        p.reject(new Error(`cell ${id} cancelled`));
+    }
+    async snapshot() {
+        if (this.disposed) {
+            return { id: 0, type: 'snapshot_result', ok: false, error: { name: 'RuntimeDisposed', message: 'runtime disposed' } };
+        }
+        if (!this.alive || !this.child) {
+            return { id: 0, type: 'snapshot_result', ok: false, error: { name: 'RuntimeDead', message: 'kernel is not alive' } };
+        }
+        const id = this.nextId++;
+        const result = new Promise((resolve) => {
+            this.pendingSnapshots.set(id, resolve);
+        });
+        try {
+            await this.ready;
+            const child = this.child;
+            if (!child) {
+                this.pendingSnapshots.delete(id);
+                return { id, type: 'snapshot_result', ok: false, error: { name: 'RuntimeDead', message: 'kernel died before snapshot' } };
+            }
+            await writeNdjson(child.stdin, { id, type: 'snapshot' });
+        }
+        catch (err) {
+            this.pendingSnapshots.delete(id);
+            const e = err;
+            return { id, type: 'snapshot_result', ok: false, error: { name: e.name, message: e.message } };
+        }
+        return result;
+    }
+    /**
+     * Phase 4 Task 10: service an `artifact_create` RPC request from the kernel.
+     * Calls the manager-supplied handler (if any), serializes the result into a
+     * `{type:'response', request:'artifact_create'}` frame, and writes it back
+     * to the child's stdin. Errors are surfaced to the kernel as `ok:false`
+     * frames so the awaiting cell rejects cleanly rather than hanging.
+     */
+    async handleArtifactCreateRpc(req) {
+        const child = this.child;
+        if (!child)
+            return;
+        let resp;
+        try {
+            const handler = this.options.handleArtifactCreate;
+            if (!handler)
+                throw new Error('artifacts unavailable');
+            const result = await handler({ kind: req.kind, name: req.name });
+            resp = {
+                type: 'response',
+                request: 'artifact_create',
+                id: req.id,
+                ok: true,
+                slug: result.slug,
+                uri: result.uri,
+                primary_path: result.primary_path,
+            };
+        }
+        catch (err) {
+            const e = err;
+            resp = {
+                type: 'response',
+                request: 'artifact_create',
+                id: req.id,
+                ok: false,
+                error: e.message,
+            };
+        }
+        try {
+            await writeNdjson(child.stdin, resp);
+        }
+        catch {
+            // child died between request and response — exit handler fails pending cells.
+        }
+    }
+    /**
+     * Phase 4 Task 10: service an `artifact_update` RPC request. Mirror of
+     * handleArtifactCreateRpc for the update path.
+     */
+    async handleArtifactUpdateRpc(req) {
+        const child = this.child;
+        if (!child)
+            return;
+        let resp;
+        try {
+            const handler = this.options.handleArtifactUpdate;
+            if (!handler)
+                throw new Error('artifacts unavailable');
+            const result = await handler({ slug: req.slug, files: req.files });
+            resp = {
+                type: 'response',
+                request: 'artifact_update',
+                id: req.id,
+                ok: true,
+                files_touched: result.files_touched,
+            };
+        }
+        catch (err) {
+            const e = err;
+            resp = {
+                type: 'response',
+                request: 'artifact_update',
+                id: req.id,
+                ok: false,
+                error: e.message,
+            };
+        }
+        try {
+            await writeNdjson(child.stdin, resp);
+        }
+        catch {
+            // child died between request and response — exit handler fails pending cells.
+        }
+    }
+    rejectActive(id, message) {
+        if (id === null)
+            return;
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        clearTimeout(p.totalTimer);
+        clearTimeout(p.inactivityTimer);
+        this.pending.delete(id);
+        if (this.activeId === id)
+            this.activeId = null;
+        p.reject(new Error(message));
+    }
+    failAllPending(err) {
+        for (const p of this.pending.values()) {
+            clearTimeout(p.totalTimer);
+            clearTimeout(p.inactivityTimer);
+            p.reject(err);
+        }
+        this.pending.clear();
+        this.activeId = null;
+        for (const resolve of this.pendingSnapshots.values()) {
+            resolve({ id: 0, type: 'snapshot_result', ok: false, error: { name: err.name, message: err.message } });
+        }
+        this.pendingSnapshots.clear();
+    }
+    markDead() {
+        const child = this.child;
+        if (!child)
+            return;
+        this.alive = false;
+        this.childReady = false;
+        child.kill('SIGTERM');
+        child.kill('SIGKILL');
+        // child stays referenced until its 'exit' fires; identity guards in readLoop/exit
+        // ignore the dead child once a restart reassigns this.child.
+    }
+    get hasActiveCell() {
+        return this.activeId !== null;
+    }
+    get recoveryNotes() {
+        return this.recoveryNotes_;
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.alive = false;
+        this.childReady = false;
+        this.failAllPending(new Error('runtime disposed'));
+        const child = this.child;
+        this.child = null;
+        if (child) {
+            child.stdin.end();
+            child.kill('SIGTERM');
+        }
+    }
+}

package/packages/coworker-scratchpad/dist/collector-registry.d.ts

@@ -0,0 +1,12 @@
+import type { Collector, CollectorRegistry, DataSourceRef } from '@otto/coworker-types';
+export declare function uriMatchesPattern(uri: string, pattern: string): boolean;
+export declare class DefaultCollectorRegistry implements CollectorRegistry {
+    private readonly collectors;
+    register(collector: Collector): void;
+    list(): Collector[];
+    get(id: string): Collector | null;
+    resolve(uri: string): Promise<{
+        collector: Collector;
+        ref: DataSourceRef;
+    } | null>;
+}

package/packages/coworker-scratchpad/dist/collector-registry.js

@@ -0,0 +1,29 @@
+export function uriMatchesPattern(uri, pattern) {
+    if (pattern.endsWith('*'))
+        return uri.startsWith(pattern.slice(0, -1));
+    return uri === pattern;
+}
+export class DefaultCollectorRegistry {
+    collectors = new Map();
+    register(collector) {
+        this.collectors.set(collector.id, collector);
+    }
+    list() {
+        return [...this.collectors.values()];
+    }
+    get(id) {
+        return this.collectors.get(id) ?? null;
+    }
+    async resolve(uri) {
+        for (const collector of this.collectors.values()) {
+            const patterns = collector.describe().supports_uris;
+            if (!patterns.some((p) => uriMatchesPattern(uri, p)))
+                continue;
+            for await (const ref of collector.list()) {
+                if (ref.uri === uri)
+                    return { collector, ref };
+            }
+        }
+        return null;
+    }
+}

package/packages/coworker-scratchpad/dist/detect-kind.d.ts

@@ -0,0 +1,3 @@
+import type { DataKind } from '@otto/coworker-types';
+export declare const FILE_COLLECTOR_KINDS: readonly DataKind[];
+export declare function detectKind(pathOrUri: string): DataKind | null;

package/packages/coworker-scratchpad/dist/detect-kind.js

@@ -0,0 +1,19 @@
+const EXT_TO_KIND = {
+    '.csv': 'csv',
+    '.xlsx': 'xlsx',
+    '.json': 'json',
+    '.parquet': 'parquet',
+    '.txt': 'txt',
+    '.md': 'md',
+};
+// The six file kinds FileCollector enumerates. (DataKind also includes
+// rest/mcp-resource/acp-stream, which belong to future non-file collectors.)
+export const FILE_COLLECTOR_KINDS = ['csv', 'xlsx', 'json', 'parquet', 'txt', 'md'];
+export function detectKind(pathOrUri) {
+    const clean = pathOrUri.split('?')[0].split('#')[0];
+    const dot = clean.lastIndexOf('.');
+    if (dot === -1)
+        return null;
+    const ext = clean.slice(dot).toLowerCase();
+    return EXT_TO_KIND[ext] ?? null;
+}

package/packages/coworker-scratchpad/dist/file-collector.d.ts

@@ -0,0 +1,15 @@
+import type { Collector, CollectorCapabilities, DataSource, DataSourceRef, ListOpts, Unsubscribe } from '@otto/coworker-types';
+export interface FileCollectorOptions {
+    /** Absolute path to the workspace root. inputs/ resolves to <workspace>/.otto/inputs. */
+    workspace: string;
+}
+export declare class FileCollector implements Collector {
+    readonly id = "file";
+    readonly kind: "file";
+    private readonly inputsDir;
+    constructor(opts: FileCollectorOptions);
+    describe(): CollectorCapabilities;
+    list(opts?: ListOpts): AsyncIterable<DataSourceRef>;
+    open(ref: DataSourceRef): Promise<DataSource>;
+    watch(ref: DataSourceRef, onChange: (ref: DataSourceRef) => void): Unsubscribe;
+}

package/packages/coworker-scratchpad/dist/file-collector.js

@@ -0,0 +1,99 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { watch as chokidarWatch } from 'chokidar';
+import { detectKind, FILE_COLLECTOR_KINDS } from './detect-kind.js';
+const TEXT_KINDS = new Set(['csv', 'txt', 'md']);
+export class FileCollector {
+    id = 'file';
+    kind = 'file';
+    inputsDir;
+    constructor(opts) {
+        this.inputsDir = join(opts.workspace, '.otto', 'inputs');
+    }
+    describe() {
+        return {
+            supports_uris: ['file://*'],
+            supports_kinds: [...FILE_COLLECTOR_KINDS],
+            supports_streaming: false,
+            supports_watching: true,
+        };
+    }
+    async *list(opts) {
+        let remaining = opts?.limit ?? Number.POSITIVE_INFINITY;
+        if (remaining <= 0)
+            return;
+        const prefixDir = opts?.prefix ? join(this.inputsDir, opts.prefix) : this.inputsDir;
+        for await (const abs of walk(this.inputsDir)) {
+            if (opts?.prefix && !abs.startsWith(prefixDir))
+                continue;
+            const kind = detectKind(abs);
+            if (!kind)
+                continue;
+            const st = await stat(abs);
+            yield {
+                collector: this.id,
+                uri: pathToFileURL(abs).href,
+                kind,
+                bytes: st.size,
+                modified: st.mtime.toISOString(),
+                metadata: {},
+            };
+            remaining -= 1;
+            if (remaining <= 0)
+                return;
+        }
+    }
+    async open(ref) {
+        const abs = fileURLToPath(ref.uri);
+        const kind = ref.kind;
+        return {
+            ref,
+            async load() {
+                if (kind === 'json') {
+                    return JSON.parse(await readFile(abs, 'utf8'));
+                }
+                if (TEXT_KINDS.has(kind)) {
+                    return readFile(abs, 'utf8');
+                }
+                return readFile(abs); // Buffer for xlsx/parquet
+            },
+        };
+    }
+    watch(ref, onChange) {
+        const abs = fileURLToPath(ref.uri);
+        const watcher = chokidarWatch(abs, { ignoreInitial: true });
+        const handler = async () => {
+            try {
+                const st = await stat(abs);
+                onChange({ ...ref, bytes: st.size, modified: st.mtime.toISOString() });
+            }
+            catch {
+                onChange(ref);
+            }
+        };
+        watcher.on('change', () => void handler());
+        watcher.on('add', () => void handler());
+        return () => {
+            void watcher.close();
+        };
+    }
+}
+async function* walk(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return; // inputs/ may not exist yet — yield nothing
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            yield* walk(full);
+        }
+        else if (entry.isFile()) {
+            yield full;
+        }
+    }
+}

package/packages/coworker-scratchpad/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { detectKind, FILE_COLLECTOR_KINDS } from './detect-kind.js';
+export { FileCollector, type FileCollectorOptions } from './file-collector.js';
+export { DefaultCollectorRegistry, uriMatchesPattern } from './collector-registry.js';
+export { isDataLoadEvent, isProgressEvent, isStartupErrorEvent, isSnapshotResult, type RunRequest, type SnapshotRequest, type KernelRequest, type ResultOk, type ResultErr, type ResultResponse, type SnapshotResultOk, type SnapshotResultErr, type SnapshotResult, type SkippedKey, type RecoveryNote, type StartupErrorEvent, type DataLoadDrawer, type ArtifactCreateDrawer, type ReadyEvent, type DataLoadEvent, type ProgressEvent, type KernelEvent, type KernelFrame, } from './kernel-protocol.js';
+export { filterEnv, kernelExecArgv, resolveKernelEntry } from './kernel-spawn.js';
+export { ChildProcessRuntime, type CellResult, type ChildProcessRuntimeOptions, } from './child-process-runtime.js';
+export { ScratchpadManager, ForkKernelHangError, type ScratchpadManagerOptions, type AttachOptions, type ScratchpadInfo, } from './scratchpad-manager.js';
+export { acquireLock, releaseLock, readLock, isStaleLock, ScratchpadBusyError, type LockInfo, type AcquireOptions, } from './scratchpad-lock.js';
+export { CellArchive, CELLS_SCHEMA_VERSION, type CellEntry, type AppendInput, } from './cell-archive.js';
+export { buildDataLibBindings } from './kernel-bindings.js';
+export { NAMESPACE_SCHEMA_VERSION, encodeNamespace, decodeNamespace, type NamespaceEnvelope, type EncodeResult, type DecodeResult, } from './namespace-codec.js';
+export { projectTree, findLeaves, validateLeafId, formatTreeText, type TreeNode, type CellTree, } from './cell-tree.js';
+export { StalenessBanner, type StalenessCheck } from './staleness-banner.js';

package/packages/coworker-scratchpad/dist/index.js

@@ -0,0 +1,13 @@
+export { detectKind, FILE_COLLECTOR_KINDS } from './detect-kind.js';
+export { FileCollector } from './file-collector.js';
+export { DefaultCollectorRegistry, uriMatchesPattern } from './collector-registry.js';
+export { isDataLoadEvent, isProgressEvent, isStartupErrorEvent, isSnapshotResult, } from './kernel-protocol.js';
+export { filterEnv, kernelExecArgv, resolveKernelEntry } from './kernel-spawn.js';
+export { ChildProcessRuntime, } from './child-process-runtime.js';
+export { ScratchpadManager, ForkKernelHangError, } from './scratchpad-manager.js';
+export { acquireLock, releaseLock, readLock, isStaleLock, ScratchpadBusyError, } from './scratchpad-lock.js';
+export { CellArchive, CELLS_SCHEMA_VERSION, } from './cell-archive.js';
+export { buildDataLibBindings } from './kernel-bindings.js';
+export { NAMESPACE_SCHEMA_VERSION, encodeNamespace, decodeNamespace, } from './namespace-codec.js';
+export { projectTree, findLeaves, validateLeafId, formatTreeText, } from './cell-tree.js';
+export { StalenessBanner } from './staleness-banner.js';