omkit 0.0.14 → 0.1.0

package/dist/output/log/LogRenderer.js

@@ -1,133 +0,0 @@
-const PREFIX = {
-    event: "⚡",
-    action: "▸",
-    run: "●",
-    snapshot: "📎",
-    assert: "⊨",
-};
-/**
- * Levels that render as their own top-level milestone line — marker-prefixed and
- * never grouped/indented. Everything else is action/proc output, which the
- * renderer groups under an `▸ <source>` header and indents.
- */
-const MILESTONE = {
-    run: "run",
-    event: "event",
-    snapshot: "snapshot",
-    assert: "assert",
-};
-/** Only runs *longer than* this collapse, so a trigger always hides a meaningful amount. */
-const COLLAPSE_THRESHOLD = 15;
-/**
- * Turns raw {@link LogEntry} records into the pretty, grouped text form.
- * Presentation lives here and nowhere else: the collector stores raw entries; the
- * live drain and `run.log` writer each construct a renderer and feed it entries in
- * order. Two modes over the same grouping rules — pick per instance, don't mix:
- *
- * - **streaming** — {@link render} returns one entry's line as it arrives (live
- *   drain, incremental `run.log`).
- * - **batch** — {@link push}/{@link end} accumulate a same-source run and collapse
- *   it when it grows past the threshold, so one proc's burst can't drown the
- *   durable `run.log` (the caller off-loads the full run to a snapshot).
- *
- * Grouping is decided against the *single merged stream* (`lastSource`), not
- * per-producer — so interleaved concurrent sources re-header correctly. A
- * milestone line breaks the current group, so the next action line re-headers.
- */
-export class LogRenderer {
-    /** Lines of a collapsed run shown inline before the pointer. */
-    static COLLAPSE_HEAD = 5;
-    /** Prefix a milestone/header line with its marker (`● run`, `▸ action`, …). */
-    static marker(kind, text) {
-        return `${PREFIX[kind]} ${text}`;
-    }
-    /**
-     * Renders a {@link CollapsedRun} as its `head` lines under the `▸ <source>`
-     * header, then a single indented `📎` pointer line to the off-loaded snapshot at
-     * `rel` reporting how many lines were hidden. Pure — `rel` is supplied by the
-     * caller after it writes the file.
-     */
-    static renderCollapsed(run, { rel, head = LogRenderer.COLLAPSE_HEAD }) {
-        const shown = run.lines.slice(0, head);
-        const lines = shown.map((message, i) => i === 0 ? `${LogRenderer.marker("action", run.source)}\n\t${message}` : `\t${message}`);
-        const hidden = run.lines.length - shown.length;
-        lines.push(`\t${LogRenderer.marker("snapshot", `… +${hidden} more lines → ${rel}`)}`);
-        return lines.join("\n");
-    }
-    // Streaming grouping state: the source of the group currently open.
-    lastSource;
-    // Batch state: the same-source run currently being accumulated.
-    run;
-    threshold;
-    constructor(threshold = COLLAPSE_THRESHOLD) {
-        this.threshold = threshold;
-    }
-    /**
-     * Streaming: render one entry to its pretty line. A milestone renders as its own
-     * marker line and breaks the group; other entries are grouped under an
-     * `▸ <source>` header (first line of a group) and indented (the rest).
-     */
-    render(entry) {
-        const milestone = MILESTONE[entry.level];
-        if (milestone) {
-            // Reset grouping: after an interjection, the next action line re-headers.
-            this.lastSource = undefined;
-            return LogRenderer.marker(milestone, entry.message);
-        }
-        if (entry.source !== this.lastSource) {
-            this.lastSource = entry.source;
-            return `${LogRenderer.marker("action", entry.source)}\n\t${entry.message}`;
-        }
-        return `\t${entry.message}`;
-    }
-    /**
-     * Batch: push an entry in order and get back the {@link DisplayItem}s that just
-     * became final (0, 1, or a whole flushed run). Only the current same-source run
-     * is held in memory, so segmenting a huge log stays bounded — the `run.log`
-     * writer feeds this straight from `run.jsonl` on disk. Output is byte-identical
-     * to {@link render} for non-collapsed runs. Pure — no filesystem.
-     */
-    push(entry) {
-        const out = [];
-        const milestone = MILESTONE[entry.level];
-        if (milestone) {
-            // A milestone breaks the current run, then renders as its own line.
-            this.flush(out);
-            out.push({ kind: "line", text: LogRenderer.marker(milestone, entry.message) });
-            return out;
-        }
-        if (this.run && this.run.source === entry.source) {
-            this.run.lines.push(entry.message);
-        }
-        else {
-            this.flush(out);
-            this.run = { source: entry.source, lines: [entry.message] };
-        }
-        return out;
-    }
-    /** Batch: flush the last pending run (call once after the final {@link push}). */
-    end() {
-        const out = [];
-        this.flush(out);
-        return out;
-    }
-    // Flush the pending run into `out`: collapse it if it ran long, else emit grouped
-    // lines exactly as `render` would (header first, indent the rest).
-    flush(out) {
-        const run = this.run;
-        if (!run)
-            return;
-        if (run.lines.length > this.threshold) {
-            out.push({ kind: "collapsed", run: { source: run.source, lines: run.lines } });
-        }
-        else {
-            run.lines.forEach((message, i) => {
-                out.push({
-                    kind: "line",
-                    text: i === 0 ? `${LogRenderer.marker("action", run.source)}\n\t${message}` : `\t${message}`,
-                });
-            });
-        }
-        this.run = undefined;
-    }
-}

package/dist/output/log/LogsCollector.d.ts

@@ -1,79 +0,0 @@
-export interface LogEntry {
-    sequence: number;
-    timestamp: number;
-    /**
-     * Who emitted this line — an action/proc name, or `"event"`/`"run"`/`"snapshot"`.
-     * Retained so the structured log can be filtered and correlated by origin.
-     */
-    source: string;
-    level: string;
-    message: string;
-}
-/** Input to a logger. `source` drives the header line and is retained on the entry. */
-export interface LogInput {
-    source: string;
-    level: string;
-    message: string;
-}
-export interface SubscribeOptions {
-    /**
-     * Replay the buffered history before live entries, so a late subscriber sees
-     * everything logged so far. Default: false (live entries only).
-     */
-    replay?: boolean;
-}
-/**
- * What actions and the `proc` primitive log into: a raw append-only store. It
- * keeps no presentation — grouping headers and indentation are applied at read
- * time by the renderer (see `render.ts`), so every entry stays raw and queryable.
- */
-export interface Logger {
-    /** Streams a raw text/byte source into the log, split into lines. */
-    attach(stream: AsyncIterable<unknown>, source: string, level: string): void;
-    /** Appends a single entry. */
-    append(entry: LogInput): void;
-    /** Subscribes to entries, optionally replaying history first. */
-    subscribe(options?: SubscribeOptions): AsyncIterable<LogEntry>;
-}
-export declare class LogsCollector implements Logger {
-    private sequence;
-    private readonly history;
-    private readonly maxHistory;
-    private readonly trimHistoryTo;
-    private readonly subscribers;
-    private ended;
-    /**
-     * Streams a raw text/byte source (e.g. a child process's stdout) into the
-     * collector: splits it into lines and appends each under the given
-     * `source`/`level`. Partial lines are buffered across chunks and a non-empty
-     * trailing fragment is flushed when the stream ends.
-     */
-    attach(stream: AsyncIterable<unknown>, source: string, level: string): void;
-    /** Raw store: records the line verbatim, source included; presentation is the renderer's job. */
-    append(entry: LogInput): void;
-    /**
-     * End the log: every subscription returns and no new one is accepted. Called
-     * once at run finalize — *after* the last entry (e.g. `finished`) is appended —
-     * so `streamLog` captures the whole run before its stream closes. Kept separate
-     * from teardown so entries logged *during* teardown still stream/drain live.
-     */
-    close(): void;
-    /** EOF for readers: end every live subscription and refuse to register new ones. */
-    private closeAll;
-    subscribe({ replay }?: SubscribeOptions): AsyncIterable<LogEntry>;
-    snapshot(): readonly LogEntry[];
-}
-/**
- * A {@link Logger} decorator that prefixes every entry's `source` with a fixed path
- * (` › `-joined), forwarding to a base logger. Handed to a **child** action (and its
- * `proc`) so all of its output is attributed to its ancestry — `parent › child ›
- * <source>` — while the underlying store stays the run's one log.
- */
-export declare class ScopedLogger implements Logger {
-    private readonly base;
-    private readonly prefix;
-    constructor(base: Logger, path: string);
-    attach(stream: AsyncIterable<unknown>, source: string, level: string): void;
-    append(entry: LogInput): void;
-    subscribe(options?: SubscribeOptions): AsyncIterable<LogEntry>;
-}

package/dist/output/log/LogsCollector.js

@@ -1,141 +0,0 @@
-import { AsyncQueue } from "../../utils/AsyncQueue.js";
-export class LogsCollector {
-    sequence = 0;
-    // Recent entries retained in memory, only to replay to late subscribers. The
-    // *complete* record is streamed to run.jsonl on disk, so this is capped — an
-    // indefinite run (dev servers, tailing big logs) must not grow without bound.
-    history = [];
-    // Cap and the size we trim back to when it's exceeded (trimming in batches keeps
-    // append amortized O(1) instead of O(n) per line once full).
-    maxHistory = 100_000;
-    trimHistoryTo = 90_000;
-    subscribers = new Set();
-    // Set once the bound signal aborts: the log has reached EOF for readers.
-    ended = false;
-    /**
-     * Streams a raw text/byte source (e.g. a child process's stdout) into the
-     * collector: splits it into lines and appends each under the given
-     * `source`/`level`. Partial lines are buffered across chunks and a non-empty
-     * trailing fragment is flushed when the stream ends.
-     */
-    attach(stream, source, level) {
-        void splitLines(stream, (message) => this.append({ source, level, message }));
-    }
-    /** Raw store: records the line verbatim, source included; presentation is the renderer's job. */
-    append(entry) {
-        const log = {
-            source: entry.source,
-            level: entry.level,
-            message: entry.message,
-            sequence: ++this.sequence,
-            timestamp: Date.now(),
-        };
-        this.history.push(log);
-        // Cap the in-memory history — the durable copy is already on disk (run.jsonl).
-        if (this.history.length > this.maxHistory) {
-            this.history.splice(0, this.history.length - this.trimHistoryTo);
-        }
-        for (const subscriber of this.subscribers) {
-            // push the log into the queue for every subscriber to receive
-            subscriber.push(log);
-        }
-    }
-    /**
-     * End the log: every subscription returns and no new one is accepted. Called
-     * once at run finalize — *after* the last entry (e.g. `finished`) is appended —
-     * so `streamLog` captures the whole run before its stream closes. Kept separate
-     * from teardown so entries logged *during* teardown still stream/drain live.
-     */
-    close() {
-        this.closeAll();
-    }
-    /** EOF for readers: end every live subscription and refuse to register new ones. */
-    closeAll() {
-        this.ended = true;
-        for (const queue of this.subscribers)
-            queue.close();
-        this.subscribers.clear();
-    }
-    subscribe({ replay = false } = {}) {
-        // create a log queue for the new subscriber
-        const queue = new AsyncQueue();
-        // Optionally replay buffered history before live entries. Synchronous, so no
-        // append can interleave between the replay and registration — a late
-        // subscriber sees every entry, with no gap and no duplicate.
-        if (replay)
-            for (const entry of this.history)
-                queue.push(entry);
-        // If the run has already ended, this subscription is EOF after the replay —
-        // don't register it for entries that will never come. Otherwise, fan it in.
-        if (this.ended)
-            queue.close();
-        else
-            this.subscribers.add(queue);
-        const { subscribers } = this;
-        // logs queue for the current subscriber
-        const inner = queue[Symbol.asyncIterator]();
-        return {
-            [Symbol.asyncIterator]() {
-                return {
-                    // iterates the subscriber's log queue
-                    next: () => inner.next(),
-                    // Unsubscribe on early exit (break/return), so a consumer that stops
-                    // reading (e.g. waitForLog on a match) doesn't leave a dead queue that
-                    // append keeps pushing into forever.
-                    return: () => {
-                        subscribers.delete(queue);
-                        queue.close();
-                        return Promise.resolve({ done: true, value: undefined });
-                    },
-                };
-            },
-        };
-    }
-    snapshot() {
-        return this.history;
-    }
-}
-/**
- * A {@link Logger} decorator that prefixes every entry's `source` with a fixed path
- * (` › `-joined), forwarding to a base logger. Handed to a **child** action (and its
- * `proc`) so all of its output is attributed to its ancestry — `parent › child ›
- * <source>` — while the underlying store stays the run's one log.
- */
-export class ScopedLogger {
-    base;
-    prefix;
-    constructor(base, path) {
-        this.base = base;
-        this.prefix = `${path} › `;
-    }
-    attach(stream, source, level) {
-        this.base.attach(stream, this.prefix + source, level);
-    }
-    append(entry) {
-        this.base.append({ ...entry, source: this.prefix + entry.source });
-    }
-    subscribe(options) {
-        return this.base.subscribe(options);
-    }
-}
-/**
- * Splits a byte/string stream into lines, calling `onLine` for each. Partial
- * lines are buffered across chunks and a non-empty trailing fragment is flushed
- * when the stream ends.
- */
-async function splitLines(stream, onLine) {
-    let buffer = "";
-    for await (const chunk of stream) {
-        buffer += String(chunk);
-        let newline;
-        while ((newline = buffer.indexOf("\n")) !== -1) {
-            const line = buffer.slice(0, newline).replace(/\r$/, "");
-            buffer = buffer.slice(newline + 1);
-            if (line)
-                onLine(line);
-        }
-    }
-    const tail = buffer.replace(/\r$/, "");
-    if (tail)
-        onLine(tail);
-}

package/dist/output/log/RunLog.d.ts

@@ -1,47 +0,0 @@
-import type { LogsCollector } from "./LogsCollector.ts";
-import type { RunFolder } from "../folder/RunFolder.ts";
-import type { SnapshotStore } from "../snapshot/SnapshotStore.ts";
-/**
- * Writes the run's two log files: `run.jsonl` (the complete, authoritative record,
- * streamed live so it survives a hard kill) and `run.log` (the human timeline).
- *
- * Two phases: {@link stream} runs for the whole run, appending each entry to both
- * files as it arrives; {@link write} runs once at finalize, re-rendering `run.log`
- * from the finished `run.jsonl` in collapsed form. Depends on a {@link RunFolder}
- * (where the files land) and a {@link SnapshotStore} (to off-load collapsed runs).
- */
-export declare class RunLog {
-    private readonly folder;
-    private readonly snapshots;
-    private assertionsPath;
-    constructor(folder: RunFolder, snapshots: SnapshotStore);
-    /** The `assertions.log` path if any assertion was logged this run, else `undefined`. */
-    get assertionsLog(): string | undefined;
-    /**
-     * Streams every log entry to `run.jsonl` (the complete, authoritative record) and a
-     * live `run.log` incrementally as they arrive, so output survives a hard kill or lost
-     * SIGINT. The log is closed once at finalize, after which {@link write} re-renders
-     * `run.log` from `run.jsonl` in collapsed form.
-     *
-     * Subscribes **synchronously, before any `await`** — so a fast synchronous producer
-     * that appends (and trims the in-memory history) before the file setup finishes still
-     * has its entries buffered on the subscription queue rather than lost. `replay: true`
-     * covers anything already logged when this is called.
-     */
-    stream(logs: LogsCollector): Promise<void>;
-    /**
-     * Renders the final, collapsed `run.log` from the authoritative `run.jsonl` (the
-     * complete record {@link stream} wrote), **streaming** it line by line so the whole
-     * run is never held in memory. Grouping/indentation is applied here so the stored
-     * `run.jsonl` stays presentation-free; large same-source runs are collapsed —
-     * off-loaded to a text snapshot and replaced inline by their head plus a pointer — so
-     * one proc's burst can't drown the timeline. `run.jsonl` is left as-is. Returns the
-     * `run.log` path (surfaced to the terminal).
-     *
-     * Call only after {@link stream} has closed (the run's log is ended), so `run.jsonl`
-     * is complete and no longer being written.
-     */
-    write(): Promise<string>;
-    /** A compact header block for the top of run.log — legend + run identity. */
-    private header;
-}

package/dist/output/log/RunLog.js

@@ -1,142 +0,0 @@
-import { createReadStream, createWriteStream } from "node:fs";
-import { createInterface } from "node:readline";
-import { LogRenderer } from "./LogRenderer.js";
-import { closeStream } from "../../system/fs/streams.js";
-import { ymd, hms } from "../../utils/format.js";
-/**
- * Writes the run's two log files: `run.jsonl` (the complete, authoritative record,
- * streamed live so it survives a hard kill) and `run.log` (the human timeline).
- *
- * Two phases: {@link stream} runs for the whole run, appending each entry to both
- * files as it arrives; {@link write} runs once at finalize, re-rendering `run.log`
- * from the finished `run.jsonl` in collapsed form. Depends on a {@link RunFolder}
- * (where the files land) and a {@link SnapshotStore} (to off-load collapsed runs).
- */
-export class RunLog {
-    folder;
-    snapshots;
-    // Path of `assertions.log`, set the first time an assertion is streamed (lazily
-    // created). Stays `undefined` for a run with no assertions, so the finalize step
-    // links it only when it exists. See {@link assertionsLog}.
-    assertionsPath;
-    constructor(folder, snapshots) {
-        this.folder = folder;
-        this.snapshots = snapshots;
-    }
-    /** The `assertions.log` path if any assertion was logged this run, else `undefined`. */
-    get assertionsLog() {
-        return this.assertionsPath;
-    }
-    /**
-     * Streams every log entry to `run.jsonl` (the complete, authoritative record) and a
-     * live `run.log` incrementally as they arrive, so output survives a hard kill or lost
-     * SIGINT. The log is closed once at finalize, after which {@link write} re-renders
-     * `run.log` from `run.jsonl` in collapsed form.
-     *
-     * Subscribes **synchronously, before any `await`** — so a fast synchronous producer
-     * that appends (and trims the in-memory history) before the file setup finishes still
-     * has its entries buffered on the subscription queue rather than lost. `replay: true`
-     * covers anything already logged when this is called.
-     */
-    async stream(logs) {
-        const entries = logs.subscribe({ replay: true });
-        await this.folder.ensure();
-        const jsonl = createWriteStream(this.folder.resolve("run.jsonl"));
-        const pretty = createWriteStream(this.folder.resolve("run.log"));
-        const renderer = new LogRenderer();
-        pretty.write(this.header() + "\n");
-        // The dedicated assertions file is a filtered projection of the same stream:
-        // opened lazily on the first `assert` entry (so runs with none produce no file),
-        // one `⊨ …` line each. Assertions still ride the main run.jsonl / run.log too.
-        let assertions;
-        try {
-            for await (const entry of entries) {
-                jsonl.write(JSON.stringify(entry) + "\n");
-                pretty.write(renderer.render(entry) + "\n");
-                if (entry.level === "assert") {
-                    if (!assertions) {
-                        this.assertionsPath = this.folder.resolve("assertions.log");
-                        assertions = createWriteStream(this.assertionsPath);
-                    }
-                    assertions.write(LogRenderer.marker("assert", entry.message) + "\n");
-                }
-            }
-        }
-        finally {
-            // End AND wait for both streams to fully close before resolving. {@link write}
-            // re-renders run.log at finalize (from this run.jsonl); if a buffered chunk from
-            // this stream landed *after* write() truncated run.log, the OS would zero-fill the
-            // gap — a multi-MB run of NUL bytes. `run` awaits this promise before calling
-            // write(), so this writer is guaranteed done first (and run.jsonl is complete).
-            await Promise.all([
-                closeStream(jsonl),
-                closeStream(pretty),
-                ...(assertions ? [closeStream(assertions)] : []),
-            ]);
-        }
-    }
-    /**
-     * Renders the final, collapsed `run.log` from the authoritative `run.jsonl` (the
-     * complete record {@link stream} wrote), **streaming** it line by line so the whole
-     * run is never held in memory. Grouping/indentation is applied here so the stored
-     * `run.jsonl` stays presentation-free; large same-source runs are collapsed —
-     * off-loaded to a text snapshot and replaced inline by their head plus a pointer — so
-     * one proc's burst can't drown the timeline. `run.jsonl` is left as-is. Returns the
-     * `run.log` path (surfaced to the terminal).
-     *
-     * Call only after {@link stream} has closed (the run's log is ended), so `run.jsonl`
-     * is complete and no longer being written.
-     */
-    async write() {
-        await this.folder.ensure();
-        const jsonlFile = this.folder.resolve("run.jsonl");
-        const file = this.folder.resolve("run.log");
-        const out = createWriteStream(file);
-        out.write(this.header());
-        const renderer = new LogRenderer();
-        const writes = [];
-        const emit = (item) => {
-            if (item.kind === "line") {
-                out.write(item.text + "\n");
-            }
-            else {
-                const snap = this.snapshots.captureText(`output-${item.run.source}`, item.run.lines);
-                writes.push(snap.written);
-                out.write(LogRenderer.renderCollapsed(item.run, { rel: snap.rel }) + "\n");
-            }
-        };
-        try {
-            const rl = createInterface({ input: createReadStream(jsonlFile), crlfDelay: Infinity });
-            for await (const line of rl) {
-                if (!line)
-                    continue;
-                let entry;
-                try {
-                    entry = JSON.parse(line);
-                }
-                catch {
-                    continue; // a torn final line (dirty exit) — skip it
-                }
-                for (const item of renderer.push(entry))
-                    emit(item);
-            }
-        }
-        catch {
-            // run.jsonl missing/unreadable (e.g. a very early crash) — write what we have.
-        }
-        for (const item of renderer.end())
-            emit(item);
-        await closeStream(out); // flush + close run.log before reporting it written
-        await Promise.all(writes); // ensure every off-loaded run is on disk
-        return file;
-    }
-    /** A compact header block for the top of run.log — legend + run identity. */
-    header() {
-        const now = new Date();
-        return [
-            `─── ${this.folder.name()} · ${ymd(now)} ${hms(now)} ───`,
-            `● run  ⚡ event  ▸ action  📎 snapshot  ⇥ output  ⊨ assert`,
-            "",
-        ].join("\n");
-    }
-}

package/dist/output/log/console-capture.d.ts

@@ -1,24 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { Logger } from "./LogsCollector.ts";
-/**
- * The path of the action whose async context is currently executing (e.g.
- * "Build", "Dev › Server"). `SpinHost.launch` wraps each action's `start` in
- * `actionScope.run(path, …)`, so any `console.*` call inside that action's
- * (a)synchronous body reads its path here. No store → the call ran outside any
- * action (the spin body, top-level, a third-party module init).
- */
-export declare const actionScope: AsyncLocalStorage<string>;
-/**
- * Patch `console.log/info/debug/warn/error` so each call appends into `logs`
- * instead of writing to the terminal, attributing every line to the current
- * action via {@link actionScope}. Returns a `restore()` that reinstalls the
- * methods that were installed when this ran — so sequential runs nest cleanly
- * (save-current / restore-saved).
- *
- * The patched methods do **not** echo to the terminal: their output reaches it
- * through the run's log renderer (the caller keeps the original `console.log`
- * for the renderer's own writes). Args are rendered with `util.format` (exact
- * console semantics), split on newlines, and appended line-by-line; an empty
- * render is skipped.
- */
-export declare function captureConsole(logs: Logger): () => void;

package/dist/output/log/console-capture.js

@@ -1,53 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { format } from "node:util";
-/**
- * The path of the action whose async context is currently executing (e.g.
- * "Build", "Dev › Server"). `SpinHost.launch` wraps each action's `start` in
- * `actionScope.run(path, …)`, so any `console.*` call inside that action's
- * (a)synchronous body reads its path here. No store → the call ran outside any
- * action (the spin body, top-level, a third-party module init).
- */
-export const actionScope = new AsyncLocalStorage();
-/** The console methods we fold into the log, each mapped to its log level. */
-const LEVELS = {
-    log: "info",
-    info: "info",
-    debug: "debug",
-    warn: "warn",
-    error: "error",
-};
-/**
- * Patch `console.log/info/debug/warn/error` so each call appends into `logs`
- * instead of writing to the terminal, attributing every line to the current
- * action via {@link actionScope}. Returns a `restore()` that reinstalls the
- * methods that were installed when this ran — so sequential runs nest cleanly
- * (save-current / restore-saved).
- *
- * The patched methods do **not** echo to the terminal: their output reaches it
- * through the run's log renderer (the caller keeps the original `console.log`
- * for the renderer's own writes). Args are rendered with `util.format` (exact
- * console semantics), split on newlines, and appended line-by-line; an empty
- * render is skipped.
- */
-export function captureConsole(logs) {
-    const c = console;
-    const saved = {};
-    const methods = Object.keys(LEVELS);
-    for (const method of methods) {
-        saved[method] = c[method];
-        const level = LEVELS[method];
-        c[method] = (...args) => {
-            const path = actionScope.getStore();
-            const source = path ? `${path} › console` : "console";
-            const text = format(...args);
-            for (const line of text.split("\n")) {
-                if (line)
-                    logs.append({ source, level, message: line });
-            }
-        };
-    }
-    return () => {
-        for (const method of methods)
-            c[method] = saved[method];
-    };
-}

package/dist/system/fs/streams.d.ts

@@ -1,11 +0,0 @@
-import type { createWriteStream } from "node:fs";
-/**
- * Flush and close a write stream, resolving once its file descriptor is released.
- *
- * Resolves on `close` *or* `error` — a stream error still frees the file, and a
- * caller waiting to re-read or truncate that file must not hang because the write
- * end failed. The one shared fs primitive behind both `run.jsonl` and `run.log`
- * writers, where "the bytes are on disk and the fd is closed" is the exact barrier
- * the finalize step waits on.
- */
-export declare const closeStream: (stream: ReturnType<typeof createWriteStream>) => Promise<void>;

package/dist/system/fs/streams.js

@@ -1,14 +0,0 @@
-/**
- * Flush and close a write stream, resolving once its file descriptor is released.
- *
- * Resolves on `close` *or* `error` — a stream error still frees the file, and a
- * caller waiting to re-read or truncate that file must not hang because the write
- * end failed. The one shared fs primitive behind both `run.jsonl` and `run.log`
- * writers, where "the bytes are on disk and the fd is closed" is the exact barrier
- * the finalize step waits on.
- */
-export const closeStream = (stream) => new Promise((resolve) => {
-    stream.on("close", () => resolve());
-    stream.on("error", () => resolve()); // a stream error still frees the file; don't hang
-    stream.end();
-});