@loomcli/core 0.1.1 → 0.3.0

package/dist/signals.d.ts

@@ -0,0 +1,52 @@
+/** The signals a plugin may claim, which is the closed set core installs process listeners for. */
+type ProcessSignal = 'SIGINT' | 'SIGTERM';
+/**
+ * What aborted one run's private controller. Core owns this value, so a middleware reads `source`
+ * and never infers a signal name; `cause` carries the caller's own `signal.reason` when a caller
+ * aborted. The first cause to abort fixes the reason and the code, and a later cause changes
+ * neither.
+ */
+interface CancellationReason {
+    source: ProcessSignal | 'caller';
+    cause?: unknown;
+}
+/** The status each cause resolves. A script that saw 0 after an interrupt would carry on. */
+declare const codes: {
+    readonly SIGINT: 130;
+    readonly SIGTERM: 143;
+    readonly caller: 130;
+};
+/** The status one cancelled run resolves, which is the part of `ExitCode` a signal decides. */
+type CancellationCode = (typeof codes)[CancellationReason['source']];
+/** Whether one declared value names a signal core installs a listener for. */
+declare function isProcessSignal(value: unknown): value is ProcessSignal;
+/** The status one cancelled run resolves, which the first cause to abort fixed. */
+declare function cancellationCode(reason: CancellationReason): CancellationCode;
+/**
+ * Whether one thrown value is the cancellation the run already reports: the reason core aborted
+ * with, which an API that rejects with `signal.reason` throws back, or an error every runtime
+ * names `AbortError`. The chain wraps an unexpected throw, so the wrapped cause reads the same.
+ */
+declare function isCancellationEcho(thrown: unknown, reason: unknown): boolean;
+/**
+ * The process listeners one run holds, and the caller subscription it opened at run entry. Install
+ * and removal sit together so the bracket a run keeps is readable in one place.
+ */
+interface SignalBracket {
+    /** Installs one listener per claimed signal, once the graph has built and validated. */
+    install: (owned: readonly ProcessSignal[]) => void;
+    /** The reason the first cause fixed, or `undefined` while nothing has aborted the run. */
+    reason: () => CancellationReason | undefined;
+    /** Removes every listener this run holds. Called on the run's last exit path. */
+    finish: () => void;
+}
+/**
+ * The bracket for one run. Core subscribes to a caller's signal at run entry, and installs its own
+ * process listeners only for the plugin that owns the signals slot, only after the graph has built,
+ * and only until the run resolves. A process signal that arrives once the run is already cancelled
+ * is the force path: core removes its own listeners and re-raises, so the default disposition ends
+ * the process when no other listener remains. Core does not own the process.
+ */
+declare function bracketRun(controller: AbortController, caller: AbortSignal | undefined): SignalBracket;
+export type { CancellationCode, CancellationReason, ProcessSignal, SignalBracket };
+export { bracketRun, cancellationCode, isCancellationEcho, isProcessSignal };

package/dist/signals.js

@@ -0,0 +1,85 @@
+import { InternalError } from './errors.js';
+/** The status each cause resolves. A script that saw 0 after an interrupt would carry on. */
+const codes = { SIGINT: 130, SIGTERM: 143, caller: 130 };
+/** The closed set a claim is drawn from, as the values a runtime signal name may take. */
+const claimable = new Set(['SIGINT', 'SIGTERM']);
+/** Whether one declared value names a signal core installs a listener for. */
+function isProcessSignal(value) {
+    return typeof value === 'string' && claimable.has(value);
+}
+/** The status one cancelled run resolves, which the first cause to abort fixed. */
+function cancellationCode(reason) {
+    return codes[reason.source];
+}
+/**
+ * Whether one thrown value is the cancellation the run already reports: the reason core aborted
+ * with, which an API that rejects with `signal.reason` throws back, or an error every runtime
+ * names `AbortError`. The chain wraps an unexpected throw, so the wrapped cause reads the same.
+ */
+function isCancellationEcho(thrown, reason) {
+    if (thrown === reason) {
+        return true;
+    }
+    if (thrown instanceof Error && thrown.name === 'AbortError') {
+        return true;
+    }
+    return thrown instanceof InternalError && isCancellationEcho(thrown.cause, reason);
+}
+/**
+ * The bracket for one run. Core subscribes to a caller's signal at run entry, and installs its own
+ * process listeners only for the plugin that owns the signals slot, only after the graph has built,
+ * and only until the run resolves. A process signal that arrives once the run is already cancelled
+ * is the force path: core removes its own listeners and re-raises, so the default disposition ends
+ * the process when no other listener remains. Core does not own the process.
+ */
+function bracketRun(controller, caller) {
+    let reason = undefined;
+    let held = [];
+    const release = () => {
+        for (const entry of held) {
+            process.off(entry.signal, entry.handler);
+        }
+        held = [];
+    };
+    const cancel = (next) => {
+        if (reason) {
+            return;
+        }
+        reason = next;
+        controller.abort(next);
+    };
+    const received = (signal) => {
+        if (reason) {
+            release();
+            process.kill(process.pid, signal);
+            return;
+        }
+        cancel({ source: signal });
+    };
+    const aborted = () => {
+        cancel({ cause: caller?.reason, source: 'caller' });
+    };
+    if (caller?.aborted === true) {
+        aborted();
+    }
+    else {
+        caller?.addEventListener('abort', aborted);
+    }
+    return {
+        finish: () => {
+            release();
+            caller?.removeEventListener('abort', aborted);
+        },
+        install: (owned) => {
+            for (const signal of owned) {
+                const handler = () => {
+                    received(signal);
+                };
+                process.on(signal, handler);
+                held.push({ handler, signal });
+            }
+        },
+        reason: () => reason,
+    };
+}
+export { bracketRun, cancellationCode, isCancellationEcho, isProcessSignal };

package/dist/style-ansi.d.ts

@@ -0,0 +1,13 @@
+import type { Capabilities } from './rendering.js';
+import type { Attributes } from './style-state.js';
+import type { Boundary, ParsedText } from './style-wire.js';
+interface TextUnit {
+    kind: 'text' | 'control' | 'hyperlink' | 'sgr';
+    text: string;
+    attributes: Attributes;
+}
+type Unit = TextUnit | Boundary;
+/** Scans the full decoded stream before emitting padding or generated terminal bytes. */
+declare function scanAnsi(parsed: ParsedText, caps: Capabilities): Unit[];
+export type { TextUnit, Unit };
+export { scanAnsi };

package/dist/style-ansi.js

@@ -0,0 +1,306 @@
+import { applyOperations, emptyAttributes } from './style-state.js';
+import { colors, isColorName } from './style.js';
+/** Control strings are opaque through their terminator; payload bytes are never rescanned. */
+function controlString(text, start, osc) {
+    for (let cursor = start; cursor < text.length; cursor += 1) {
+        const character = text.charCodeAt(cursor);
+        if ((osc && character === 7) || character === 156) {
+            return { body: text.slice(start, cursor), end: cursor + 1, kind: osc ? 'osc' : 'control' };
+        }
+        if (character === 27 && text[cursor + 1] === '\\') {
+            return { body: text.slice(start, cursor), end: cursor + 2, kind: osc ? 'osc' : 'control' };
+        }
+    }
+    return { body: '', end: text.length, kind: 'incomplete' };
+}
+function csi(text, start) {
+    for (let cursor = start; cursor < text.length; cursor += 1) {
+        const character = text.charCodeAt(cursor);
+        if (character >= 64 && character <= 126) {
+            return {
+                body: text.slice(start, cursor),
+                end: cursor + 1,
+                kind: character === 109 ? 'sgr' : 'control',
+            };
+        }
+        if (character < 32 || character > 63) {
+            return { body: '', end: cursor, kind: 'incomplete' };
+        }
+    }
+    return { body: '', end: text.length, kind: 'incomplete' };
+}
+function command(text, cursor) {
+    const code = text.charCodeAt(cursor);
+    if (code === 27) {
+        const next = text[cursor + 1];
+        if (next === '[') {
+            return csi(text, cursor + 2);
+        }
+        if (next === ']') {
+            return controlString(text, cursor + 2, true);
+        }
+        if (next === 'P' || next === 'X' || next === '^' || next === '_') {
+            return controlString(text, cursor + 2, false);
+        }
+        for (let end = cursor + 1; end < text.length; end += 1) {
+            const value = text.charCodeAt(end);
+            if (value >= 48 && value <= 126) {
+                return { body: '', end: end + 1, kind: 'control' };
+            }
+            if (value < 32 || value > 47) {
+                return { body: '', end, kind: 'incomplete' };
+            }
+        }
+        return { body: '', end: text.length, kind: 'incomplete' };
+    }
+    if (code === 155) {
+        return csi(text, cursor + 1);
+    }
+    if (code === 157) {
+        return controlString(text, cursor + 1, true);
+    }
+    if (code === 144 || code === 152 || code === 158 || code === 159) {
+        return controlString(text, cursor + 1, false);
+    }
+    if ((code < 32 && code !== 9 && code !== 10 && !(code === 13 && text[cursor + 1] === '\n')) ||
+        (code >= 127 && code <= 159)) {
+        return { body: '', end: cursor + 1, kind: 'control' };
+    }
+    return undefined;
+}
+const enableModifiers = new Map([
+    [1, 'bold'],
+    [2, 'faint'],
+    [3, 'italic'],
+    [4, 'underline'],
+    [7, 'inverse'],
+    [8, 'hidden'],
+    [9, 'strikethrough'],
+    [53, 'overline'],
+]);
+const disableModifiers = new Map([
+    [22, ['bold', 'faint']],
+    [23, ['italic']],
+    [24, ['underline']],
+    [27, ['inverse']],
+    [28, ['hidden']],
+    [29, ['strikethrough']],
+    [55, ['overline']],
+]);
+/** Raw ANSI overrides participate in Loom's scoped attributes, and resets restore their base. */
+class AnsiState {
+    base = emptyAttributes;
+    foreground;
+    background;
+    modifiers = new Map();
+    scope;
+    computed;
+    saved = new WeakMap();
+    palette;
+    constructor(root, palette) {
+        this.palette = palette;
+        this.scope = root;
+        this.saved.set(root, emptyAttributes);
+    }
+    sync(scope) {
+        if (scope === this.scope) {
+            return;
+        }
+        this.saved.set(this.scope, this.attributes());
+        const entering = [];
+        let ancestor = scope;
+        while (ancestor && !this.saved.has(ancestor)) {
+            entering.push(ancestor);
+            ancestor = ancestor.parent;
+        }
+        let effective = ancestor ? (this.saved.get(ancestor) ?? emptyAttributes) : emptyAttributes;
+        for (let index = entering.length - 1; index >= 0; index -= 1) {
+            const next = entering[index];
+            if (next) {
+                effective = applyOperations(effective, next.operations, this.palette);
+                this.saved.set(next, effective);
+            }
+        }
+        this.scope = scope;
+        this.base = scope.attributes;
+        this.foreground = effective.foreground;
+        this.background = effective.background;
+        this.modifiers.clear();
+        for (const key of this.base.modifiers) {
+            this.modifiers.set(key, false);
+        }
+        for (const key of effective.modifiers) {
+            this.modifiers.set(key, true);
+        }
+        this.computed = undefined;
+    }
+    attributes() {
+        if (this.computed !== undefined) {
+            return this.computed;
+        }
+        if (this.foreground === undefined &&
+            this.background === undefined &&
+            this.modifiers.size === 0) {
+            return this.base;
+        }
+        const modifiers = new Set(this.base.modifiers);
+        for (const [name, on] of this.modifiers) {
+            if (on) {
+                modifiers.add(name);
+            }
+            else {
+                modifiers.delete(name);
+            }
+        }
+        this.computed = {
+            background: this.background ?? this.base.background,
+            foreground: this.foreground ?? this.base.foreground,
+            modifiers,
+        };
+        return this.computed;
+    }
+    sgr(body) {
+        this.computed = undefined;
+        if (!/^[\d;:]*$/u.test(body)) {
+            return '';
+        }
+        const parameters = body.split(';');
+        const unknown = [];
+        for (let index = 0; index < parameters.length; index += 1) {
+            const raw = parameters[index] ?? '';
+            const colon = raw.split(':');
+            const code = Number(colon[0]);
+            if (code === 0) {
+                this.foreground = undefined;
+                this.background = undefined;
+                this.modifiers.clear();
+                continue;
+            }
+            if (code === 39 || code === 49) {
+                this[code === 39 ? 'foreground' : 'background'] = undefined;
+                continue;
+            }
+            const enabled = enableModifiers.get(code);
+            if (enabled) {
+                this.modifiers.set(enabled, true);
+                continue;
+            }
+            const disabled = disableModifiers.get(code);
+            if (disabled) {
+                for (const name of disabled) {
+                    this.modifiers.delete(name);
+                }
+                continue;
+            }
+            const background = (code >= 40 && code <= 47) || (code >= 100 && code <= 107) || code === 48;
+            const paletteIndex = code >= 30 && code <= 47
+                ? code - (background ? 40 : 30)
+                : code - (background ? 100 : 90) + 8;
+            if ((code >= 30 && code <= 37) ||
+                (code >= 40 && code <= 47) ||
+                (code >= 90 && code <= 97) ||
+                (code >= 100 && code <= 107)) {
+                const name = Object.keys(colors).find((key) => isColorName(key) && colors[key] === paletteIndex);
+                if (isColorName(name)) {
+                    this[background ? 'background' : 'foreground'] = name;
+                }
+                continue;
+            }
+            if (code === 38 || code === 48) {
+                const mode = Number(colon.length > 1 ? colon[1] : parameters[index + 1]);
+                let count = 0;
+                if (mode === 2) {
+                    count = 3;
+                }
+                else if (mode === 5) {
+                    count = 1;
+                }
+                const values = colon.length > 1
+                    ? colon.slice(colon.length - count).map(Number)
+                    : parameters.slice(index + 2, index + 2 + count).map(Number);
+                if (colon.length === 1) {
+                    index += 1 + count;
+                }
+                if (values.length !== count ||
+                    !values.every((value) => Number.isInteger(value) && value >= 0 && value <= 255)) {
+                    continue;
+                }
+                const [red, green, blue] = values;
+                let color = undefined;
+                if (mode === 5 && red !== undefined) {
+                    color = ['ansi256', red];
+                }
+                else if (mode === 2 && red !== undefined && green !== undefined && blue !== undefined) {
+                    color = ['rgb', red, green, blue];
+                }
+                if (color !== undefined) {
+                    this[background ? 'background' : 'foreground'] = color;
+                }
+                continue;
+            }
+            unknown.push(raw);
+        }
+        return unknown.length ? `\u001b[${unknown.join(';')}m` : '';
+    }
+}
+/** Scans the full decoded stream before emitting padding or generated terminal bytes. */
+function scanAnsi(parsed, caps) {
+    const result = [];
+    const state = new AnsiState(parsed.root, parsed.palette);
+    let hyperlinkOpen = false;
+    function boundaries(start, end) {
+        for (let cursor = start; cursor < end; cursor += 1) {
+            for (const boundary of parsed.boundaries.get(cursor) ?? []) {
+                if (boundary.kind === 'open') {
+                    state.sync(boundary.scope);
+                    result.push({ ...boundary, attributes: state.attributes() });
+                }
+                else {
+                    result.push(boundary);
+                }
+            }
+        }
+    }
+    for (let cursor = 0; cursor < parsed.text.length;) {
+        state.sync(parsed.scopes[cursor] ?? parsed.root);
+        const found = command(parsed.text, cursor);
+        if (found) {
+            boundaries(cursor, found.end);
+            state.sync(parsed.scopes[found.end - 1] ?? parsed.root);
+            const raw = parsed.text.slice(cursor, found.end);
+            if (found.kind === 'sgr') {
+                const unknown = state.sgr(found.body);
+                if (caps.terminalControls && unknown) {
+                    result.push({ attributes: state.attributes(), kind: 'sgr', text: unknown });
+                }
+            }
+            else if (found.kind === 'osc' && found.body.startsWith('8;')) {
+                const separator = found.body.indexOf(';', 2);
+                if (separator !== -1 && caps.hyperlinks) {
+                    hyperlinkOpen = found.body.slice(separator + 1) !== '';
+                    result.push({ attributes: state.attributes(), kind: 'hyperlink', text: raw });
+                }
+            }
+            else if (found.kind !== 'incomplete' && caps.terminalControls) {
+                result.push({ attributes: state.attributes(), kind: 'control', text: raw });
+            }
+            cursor = found.end;
+            continue;
+        }
+        boundaries(cursor, cursor + 1);
+        state.sync(parsed.scopes[cursor] ?? parsed.root);
+        const character = parsed.text[cursor] ?? '';
+        // The LF owns the complete line-ending atom, so deferred spaces cannot split CRLF.
+        if (!(character === '\r' && parsed.text[cursor + 1] === '\n')) {
+            const text = character === '\n' && parsed.text[cursor - 1] === '\r' ? '\r\n' : character;
+            result.push({ attributes: state.attributes(), kind: 'text', text });
+        }
+        cursor += 1;
+    }
+    boundaries(parsed.text.length, parsed.text.length + 1);
+    if (hyperlinkOpen) {
+        result.push({ attributes: emptyAttributes, kind: 'hyperlink', text: '\u001b]8;;\u001b\\' });
+    }
+    return result;
+}
+export { scanAnsi };

package/dist/style-layout.d.ts

@@ -0,0 +1,29 @@
+import type { TextUnit, Unit } from './style-ansi.js';
+/** Width at each tab-stop offset composes without rescanning nested text. */
+interface Metrics {
+    advance: readonly number[];
+    tabs: boolean;
+    text: boolean;
+}
+type Rope = ({
+    kind: 'leaf';
+    unit: TextUnit;
+    tab: boolean;
+} | {
+    kind: 'join';
+    children: readonly Rope[];
+}) & Metrics;
+interface Line {
+    content: Rope;
+    ending: readonly TextUnit[];
+}
+interface Block {
+    lines: readonly Line[];
+    minimum: number;
+    tabs: boolean;
+}
+/** Nested padding resolves inside outward; unchanged content retains its rope and analysis. */
+declare function layout(units: readonly Unit[]): Block;
+declare function renderedUnits(block: Block): Generator<TextUnit>;
+declare function blockWidth(block: Block): number;
+export { blockWidth, layout, renderedUnits };