@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/shell/signals.d.ts

@@ -0,0 +1,11 @@
+export type SignalAbortReason = {
+    kind: 'signal';
+    signal: string;
+    exitCode: number;
+};
+export declare function parseSignalName(raw: string): string | null;
+export declare function formatSignalList(): string;
+export declare function exitCodeForSignal(signal?: string): number;
+export declare function signalAbortReason(signal?: string): SignalAbortReason;
+export declare function exitCodeForAbortSignal(signal: AbortSignal, fallback?: number): number;
+//# sourceMappingURL=signals.d.ts.map

package/dist/substrate/lifo/shell/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/signals.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO1D;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAKzC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAYzD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAIpE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,SAAM,GAAG,MAAM,CAElF"}

package/dist/substrate/lifo/shell/signals.js

@@ -0,0 +1,57 @@
+const SIGNAL_NUMBERS = new Map([
+    ['HUP', 1],
+    ['INT', 2],
+    ['QUIT', 3],
+    ['KILL', 9],
+    ['TERM', 15],
+    ['STOP', 19],
+    ['TSTP', 20],
+    ['CONT', 18],
+]);
+const SIGNAL_NAMES = new Map(Array.from(SIGNAL_NUMBERS.entries()).map(([name, number]) => [number, name]));
+export function parseSignalName(raw) {
+    const normalized = raw.trim().toUpperCase().replace(/^SIG/, '');
+    if (SIGNAL_NUMBERS.has(normalized))
+        return normalized;
+    const number = Number.parseInt(normalized, 10);
+    if (Number.isNaN(number))
+        return null;
+    return SIGNAL_NAMES.get(number) ?? null;
+}
+export function formatSignalList() {
+    return Array.from(SIGNAL_NAMES.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([number, name]) => `${String(number).padStart(2, ' ')}) ${name}`)
+        .join('\n') + '\n';
+}
+export function exitCodeForSignal(signal) {
+    switch (signal) {
+        case 'HUP': return 129;
+        case 'INT': return 130;
+        case 'QUIT': return 131;
+        case 'KILL': return 137;
+        case 'TERM':
+        case undefined:
+            return 143;
+        default:
+            return 128;
+    }
+}
+export function signalAbortReason(signal) {
+    const normalized = signal ? parseSignalName(signal) : 'TERM';
+    const name = normalized ?? 'TERM';
+    return { kind: 'signal', signal: name, exitCode: exitCodeForSignal(name) };
+}
+export function exitCodeForAbortSignal(signal, fallback = 130) {
+    return isSignalAbortReason(signal.reason) ? signal.reason.exitCode : fallback;
+}
+function isSignalAbortReason(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const kind = Object.getOwnPropertyDescriptor(value, 'kind')?.value;
+    const signal = Object.getOwnPropertyDescriptor(value, 'signal')?.value;
+    const exitCode = Object.getOwnPropertyDescriptor(value, 'exitCode')?.value;
+    return kind === 'signal'
+        && typeof signal === 'string'
+        && typeof exitCode === 'number';
+}

package/dist/substrate/lifo/shell/terminal-stdin.d.ts

@@ -0,0 +1,28 @@
+import type { TerminalInputStream } from '../commands/types.js';
+/**
+ * A bridge between terminal keyboard input and command stdin.
+ * The Shell feeds lines in via feed(), commands consume via read()/readAll().
+ */
+export declare class TerminalStdin implements TerminalInputStream {
+    private buffer;
+    private closed;
+    private resolvers;
+    private _rawMode;
+    /** True when a command has called read() and is waiting for input. */
+    get isWaiting(): boolean;
+    /** When true, the shell should bypass line editing and feed raw keypresses. */
+    get rawMode(): boolean;
+    set rawMode(value: boolean);
+    /** Shell calls this on Enter (with line + '\n'). */
+    feed(text: string): void;
+    /** Shell calls this on Ctrl+D to signal EOF. */
+    close(): void;
+    /** Commands consume input. Returns null on EOF. */
+    read(): Promise<string | null>;
+    readLine(): Promise<string | null>;
+    readBytes(maxLength: number): Promise<string | null>;
+    /** Read all remaining input until EOF, joined together. */
+    readAll(): Promise<string>;
+    private deliver;
+}
+//# sourceMappingURL=terminal-stdin.d.ts.map

package/dist/substrate/lifo/shell/terminal-stdin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-stdin.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/terminal-stdin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE;;;GAGG;AACH,qBAAa,aAAc,YAAW,mBAAmB;IACvD,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,QAAQ,CAAS;IAEzB,sEAAsE;IACtE,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,+EAA+E;IAC/E,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAEzB;IAED,oDAAoD;IACpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAMxB,gDAAgD;IAChD,KAAK,IAAI,IAAI;IAUb,mDAAmD;IAC7C,IAAI,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAY9B,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAiBlC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAW1D,2DAA2D;IACrD,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAUhC,OAAO,CAAC,OAAO;CAYhB"}

package/dist/substrate/lifo/shell/terminal-stdin.js

@@ -0,0 +1,100 @@
+/**
+ * A bridge between terminal keyboard input and command stdin.
+ * The Shell feeds lines in via feed(), commands consume via read()/readAll().
+ */
+export class TerminalStdin {
+    buffer = [];
+    closed = false;
+    resolvers = [];
+    _rawMode = false;
+    /** True when a command has called read() and is waiting for input. */
+    get isWaiting() {
+        return this.resolvers.length > 0;
+    }
+    /** When true, the shell should bypass line editing and feed raw keypresses. */
+    get rawMode() {
+        return this._rawMode;
+    }
+    set rawMode(value) {
+        this._rawMode = value;
+    }
+    /** Shell calls this on Enter (with line + '\n'). */
+    feed(text) {
+        if (this.closed)
+            return;
+        this.deliver(text, 'back');
+    }
+    /** Shell calls this on Ctrl+D to signal EOF. */
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve(null);
+        }
+    }
+    /** Commands consume input. Returns null on EOF. */
+    async read() {
+        if (this.buffer.length > 0) {
+            return this.buffer.shift();
+        }
+        if (this.closed) {
+            return null;
+        }
+        return new Promise((resolve) => {
+            this.resolvers.push(resolve);
+        });
+    }
+    async readLine() {
+        let line = '';
+        while (true) {
+            const chunk = await this.read();
+            if (chunk === null)
+                return line.length > 0 ? line : null;
+            const newline = chunk.indexOf('\n');
+            if (newline >= 0) {
+                const rest = chunk.slice(newline + 1);
+                if (rest.length > 0)
+                    this.deliver(rest, 'front');
+                return line + chunk.slice(0, newline);
+            }
+            line += chunk;
+        }
+    }
+    async readBytes(maxLength) {
+        if (maxLength <= 0)
+            return '';
+        const chunk = await this.read();
+        if (chunk === null)
+            return null;
+        if (chunk.length <= maxLength)
+            return chunk;
+        this.deliver(chunk.slice(maxLength), 'front');
+        return chunk.slice(0, maxLength);
+    }
+    /** Read all remaining input until EOF, joined together. */
+    async readAll() {
+        const parts = [];
+        while (true) {
+            const chunk = await this.read();
+            if (chunk === null)
+                break;
+            parts.push(chunk);
+        }
+        return parts.join('');
+    }
+    deliver(text, position) {
+        if (text.length === 0)
+            return;
+        if (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve(text);
+            return;
+        }
+        if (position === 'front')
+            this.buffer.unshift(text);
+        else
+            this.buffer.push(text);
+    }
+}

package/dist/substrate/lifo/shell/test-builtin.d.ts

@@ -0,0 +1,16 @@
+import type { VFS } from '../kernel/vfs/index.js';
+import type { CommandOutputStream } from '../commands/types.js';
+import type { BuiltinExecutionContext } from './interpreter.js';
+import type { WordPart } from './types.js';
+import { type ExpandContext } from './expander.js';
+/**
+ * Implementation of the `test` / `[` shell builtin.
+ * Evaluates conditional expressions.
+ */
+export declare function evaluateTest(args: string[], vfs: VFS, stderr: CommandOutputStream, context?: BuiltinExecutionContext): Promise<number>;
+/**
+ * `[[ ... ]]`, whose operands are expanded only when the expression actually
+ * reaches them: `[[ $# = 2 && $2 = x ]]` must not touch `$2` under `set -u`.
+ */
+export declare function evaluateDoubleBracketWords(words: WordPart[][], expandCtx: ExpandContext, vfs: VFS, stderr: CommandOutputStream, context?: BuiltinExecutionContext): Promise<number>;
+//# sourceMappingURL=test-builtin.d.ts.map

package/dist/substrate/lifo/shell/test-builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-builtin.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/test-builtin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAI/D;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,QAAQ,EAAE,EAAE,EACnB,SAAS,EAAE,aAAa,EACxB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,MAAM,CAAC,CAmBjB"}

package/dist/substrate/lifo/shell/test-builtin.js

@@ -0,0 +1,237 @@
+import { expandWord } from './expander.js';
+import { globMatch } from '../utils/glob.js';
+import { resolve } from '../utils/path.js';
+/**
+ * Implementation of the `test` / `[` shell builtin.
+ * Evaluates conditional expressions.
+ */
+export async function evaluateTest(args, vfs, stderr, context) {
+    // `[` requires a closing `]`
+    const operands = args.length > 0 && args[args.length - 1] === ']' ? args.slice(0, -1) : args;
+    return evaluateTestExpression(literalOperands(operands), vfs, stderr, context, 'test');
+}
+/**
+ * `[[ ... ]]`, whose operands are expanded only when the expression actually
+ * reaches them: `[[ $# = 2 && $2 = x ]]` must not touch `$2` under `set -u`.
+ */
+export async function evaluateDoubleBracketWords(words, expandCtx, vfs, stderr, context) {
+    const expanded = new Map();
+    const operands = {
+        length: words.length,
+        literal: (i) => operatorTextOf(words[i]),
+        value: async (i) => {
+            const cached = expanded.get(i);
+            if (cached !== undefined)
+                return cached;
+            const word = words[i] ?? [];
+            const value = await expandWord(word, expandCtx);
+            const arg = {
+                value,
+                canUseAsPattern: hasUnquotedPart(word) && hasPatternSyntax(value),
+            };
+            expanded.set(i, arg);
+            return arg;
+        },
+    };
+    return evaluateTestExpression(operands, vfs, stderr, context, 'double-bracket');
+}
+function literalOperands(args) {
+    return {
+        length: args.length,
+        literal: (i) => args[i],
+        value: async (i) => literalArg(args[i] ?? ''),
+    };
+}
+/** `[[` recognises an operator only when it is written literally. */
+function operatorTextOf(word) {
+    if (word === undefined || word.length !== 1)
+        return undefined;
+    const part = word[0];
+    if (part.quoted !== 'none' || part.commandSubstitution !== undefined)
+        return undefined;
+    if (part.text.includes('$'))
+        return undefined;
+    return part.text;
+}
+async function evaluateTestExpression(operands, vfs, stderr, context, mode) {
+    if (operands.length === 0) {
+        return 1; // false
+    }
+    try {
+        const result = await parseOr(operands, 0, vfs, context, mode, true);
+        if (result.pos !== operands.length) {
+            stderr.write('test: too many arguments\n');
+            return 2;
+        }
+        return result.value ? 0 : 1;
+    }
+    catch (e) {
+        stderr.write(`test: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 2;
+    }
+}
+/**
+ * `evaluate` is false once a short-circuit has decided the result: the walk
+ * still advances over the remaining operands (their positions are fixed by the
+ * literal operators alone) but never expands them.
+ */
+async function parseOr(ops, pos, vfs, context, mode, evaluate) {
+    let left = await parseAnd(ops, pos, vfs, context, mode, evaluate);
+    while (left.pos < ops.length && isOrOperator(ops.literal(left.pos), mode)) {
+        const right = await parseAnd(ops, left.pos + 1, vfs, context, mode, evaluate && !left.value);
+        left = { value: left.value || right.value, pos: right.pos };
+    }
+    return left;
+}
+async function parseAnd(ops, pos, vfs, context, mode, evaluate) {
+    let left = await parsePrimary(ops, pos, vfs, context, mode, evaluate);
+    while (left.pos < ops.length && isAndOperator(ops.literal(left.pos), mode)) {
+        const right = await parsePrimary(ops, left.pos + 1, vfs, context, mode, evaluate && left.value);
+        left = { value: left.value && right.value, pos: right.pos };
+    }
+    return left;
+}
+async function parsePrimary(ops, pos, vfs, context, mode, evaluate) {
+    if (pos >= ops.length) {
+        return { value: false, pos };
+    }
+    const arg = ops.literal(pos) ?? '';
+    const valueAt = async (index) => (evaluate ? (await ops.value(index)).value : '');
+    // Negation
+    if (arg === '!') {
+        const result = await parsePrimary(ops, pos + 1, vfs, context, mode, evaluate);
+        return { value: !result.value, pos: result.pos };
+    }
+    // Parenthesized expression
+    if (arg === '(') {
+        const result = await parseOr(ops, pos + 1, vfs, context, mode, evaluate);
+        if (result.pos >= ops.length || ops.literal(result.pos) !== ')') {
+            throw new Error('missing )');
+        }
+        return { value: result.value, pos: result.pos + 1 };
+    }
+    // Unary string tests
+    if (arg === '-z' && pos + 1 < ops.length) {
+        return { value: (await valueAt(pos + 1)).length === 0, pos: pos + 2 };
+    }
+    if (arg === '-n' && pos + 1 < ops.length) {
+        return { value: (await valueAt(pos + 1)).length > 0, pos: pos + 2 };
+    }
+    if (arg === '-t' && pos + 1 < ops.length) {
+        return {
+            value: context?.isFdTerminal(toInt(await valueAt(pos + 1))) ?? false,
+            pos: pos + 2,
+        };
+    }
+    // Unary file tests
+    if (arg.startsWith('-') && arg.length === 2 && pos + 1 < ops.length && isFileTestFlag(arg[1])) {
+        const fileResult = evaluate
+            ? evaluateFileTest(arg[1], await valueAt(pos + 1), vfs, context?.cwd)
+            : false;
+        return { value: fileResult, pos: pos + 2 };
+    }
+    // Binary operators: check if there's an operator at pos+1
+    if (pos + 2 <= ops.length) {
+        const op = ops.literal(pos + 1);
+        if (op !== undefined) {
+            // String comparisons
+            if (op === '=' || op === '==' || op === '!=') {
+                const equal = evaluate
+                    ? stringCompare(await ops.value(pos), await ops.value(pos + 2), mode)
+                    : false;
+                return { value: op === '!=' ? !equal : equal, pos: pos + 3 };
+            }
+            if (op === '<') {
+                return { value: (await valueAt(pos)) < (await valueAt(pos + 2)), pos: pos + 3 };
+            }
+            if (op === '>') {
+                return { value: (await valueAt(pos)) > (await valueAt(pos + 2)), pos: pos + 3 };
+            }
+            // Integer comparisons
+            const integerCompare = INTEGER_COMPARISONS[op];
+            if (integerCompare !== undefined) {
+                const value = evaluate
+                    && integerCompare(toInt(await valueAt(pos)), toInt(await valueAt(pos + 2)));
+                return { value, pos: pos + 3 };
+            }
+        }
+    }
+    // Single string argument -- true if non-empty
+    return { value: (await valueAt(pos)).length > 0, pos: pos + 1 };
+}
+const INTEGER_COMPARISONS = {
+    '-eq': (a, b) => a === b,
+    '-ne': (a, b) => a !== b,
+    '-lt': (a, b) => a < b,
+    '-le': (a, b) => a <= b,
+    '-gt': (a, b) => a > b,
+    '-ge': (a, b) => a >= b,
+};
+const FILE_TEST_FLAGS = 'efdsrwx';
+function isFileTestFlag(flag) {
+    return FILE_TEST_FLAGS.includes(flag);
+}
+function isOrOperator(value, mode) {
+    return value === '-o' || (mode === 'double-bracket' && value === '||');
+}
+function isAndOperator(value, mode) {
+    return value === '-a' || (mode === 'double-bracket' && value === '&&');
+}
+function stringCompare(left, right, mode) {
+    if (mode === 'double-bracket' && right.canUseAsPattern) {
+        return globMatch(right.value, left.value);
+    }
+    return left.value === right.value;
+}
+function literalArg(value) {
+    return { value, canUseAsPattern: false };
+}
+function hasUnquotedPart(word) {
+    return word.some((part) => part.quoted === 'none');
+}
+function hasPatternSyntax(value) {
+    return value.includes('*') || value.includes('?') || value.includes('[');
+}
+/**
+ * File tests resolve their operand against the working directory, the way
+ * every other command does. Handing the VFS a bare `config.json` asked it
+ * about a path at the root, so `[ -f config.json ]` was false for a file
+ * sitting right there — silently taking the wrong branch rather than failing.
+ */
+function evaluateFileTest(flag, operand, vfs, cwd) {
+    const path = cwd === undefined ? operand : resolve(cwd, operand);
+    switch (flag) {
+        case 'e':
+            return statOf(vfs, path) !== null;
+        case 'f':
+            return statOf(vfs, path)?.type === 'file';
+        case 'd':
+            return statOf(vfs, path)?.type === 'directory';
+        case 's': {
+            const stat = statOf(vfs, path);
+            return stat !== null && stat.type === 'file' && stat.size > 0;
+        }
+        default: {
+            const mode = flag === 'r' ? 0o4 : flag === 'w' ? 0o2 : 0o1;
+            try {
+                vfs.access(path, mode);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+}
+function statOf(vfs, path) {
+    try {
+        return vfs.stat(path);
+    }
+    catch {
+        return null;
+    }
+}
+function toInt(s) {
+    const n = parseInt(s, 10);
+    return isNaN(n) ? 0 : n;
+}

package/dist/substrate/lifo/shell/types.d.ts

@@ -0,0 +1,140 @@
+export declare enum TokenKind {
+    Word = 0,
+    Pipe = 1,// |
+    And = 2,// &&
+    Or = 3,// ||
+    Semi = 4,// ;
+    Amp = 5,// &
+    RedirectOut = 6,// >
+    RedirectAppend = 7,// >>
+    RedirectIn = 8,// <
+    RedirectReadWrite = 9,// <>
+    Heredoc = 10,// <<
+    HeredocStripTabs = 11,// <<-
+    HeredocBody = 12,
+    RedirectErr = 13,// 2>
+    RedirectErrAppend = 14,// 2>>
+    RedirectAll = 15,// &>
+    DoubleSemi = 16,// ;;
+    LParen = 17,// (
+    RParen = 18,// )
+    Newline = 19,// \n
+    EOF = 20
+}
+export interface WordPart {
+    text: string;
+    quoted: 'none' | 'single' | 'double';
+    commandSubstitution?: string;
+}
+export interface Token {
+    kind: TokenKind;
+    value: string;
+    pos: number;
+    fd?: number;
+    heredocQuoted?: boolean;
+    parts?: WordPart[];
+}
+export interface ScriptNode {
+    type: 'script';
+    lists: ListNode[];
+}
+export interface ListNode {
+    type: 'list';
+    entries: Array<{
+        pipeline: PipelineNode;
+        connector: '&&' | '||' | null;
+    }>;
+    background: boolean;
+}
+export interface PipelineNode {
+    type: 'pipeline';
+    commands: CompoundCommandNode[];
+    negated: boolean;
+}
+export interface AssignmentNode {
+    name: string;
+    /** The scalar right-hand side. Empty when `elements` carries the value. */
+    value: WordPart[];
+    /** `name=(word …)` — each element is one word, expanded like an argument. */
+    elements?: WordPart[][];
+    /** `name[expr]=` — raw subscript text, expanded and evaluated at run time. */
+    subscript?: string;
+    /** `name+=` — append to the scalar, or to the end of the array. */
+    append?: boolean;
+}
+export interface SimpleCommandNode {
+    type: 'simple_command';
+    assignments: AssignmentNode[];
+    words: WordPart[][];
+    redirections: RedirectionNode[];
+}
+export interface RedirectionNode {
+    operator: 'write' | 'append' | 'read' | 'readWrite' | 'writeAll' | 'dupOutput' | 'dupInput' | 'heredoc';
+    fd: number | null;
+    target: WordPart[];
+    heredoc?: {
+        body: string;
+        quoted: boolean;
+        stripTabs: boolean;
+    };
+}
+export interface IfNode {
+    type: 'if';
+    clauses: Array<{
+        condition: ListNode[];
+        body: ListNode[];
+    }>;
+    elseBody: ListNode[] | null;
+    redirections: RedirectionNode[];
+}
+export interface ForNode {
+    type: 'for';
+    variable: string;
+    words: WordPart[][] | null;
+    body: ListNode[];
+    redirections: RedirectionNode[];
+}
+export interface WhileNode {
+    type: 'while';
+    condition: ListNode[];
+    body: ListNode[];
+    redirections: RedirectionNode[];
+}
+export interface UntilNode {
+    type: 'until';
+    condition: ListNode[];
+    body: ListNode[];
+    redirections: RedirectionNode[];
+}
+export interface CaseNode {
+    type: 'case';
+    word: WordPart[];
+    items: Array<{
+        patterns: WordPart[][];
+        body: ListNode[];
+    }>;
+    redirections: RedirectionNode[];
+}
+export interface FunctionDefNode {
+    type: 'function_def';
+    name: string;
+    body: CompoundCommandNode;
+}
+export interface GroupNode {
+    type: 'group';
+    body: ListNode[];
+    redirections: RedirectionNode[];
+}
+export interface SubshellNode {
+    type: 'subshell';
+    body: ListNode[];
+    redirections: RedirectionNode[];
+}
+export interface DoubleBracketNode {
+    type: 'double_bracket';
+    words: WordPart[][];
+    redirections: RedirectionNode[];
+}
+export type CompoundCommandNode = SimpleCommandNode | DoubleBracketNode | IfNode | ForNode | WhileNode | UntilNode | CaseNode | GroupNode | SubshellNode | FunctionDefNode;
+export type ASTNode = ScriptNode | ListNode | PipelineNode | CompoundCommandNode;
+//# sourceMappingURL=types.d.ts.map

package/dist/substrate/lifo/shell/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/types.ts"],"names":[],"mappings":"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"}

package/dist/substrate/lifo/shell/types.js

@@ -0,0 +1,25 @@
+// ─── Token types ───
+export var TokenKind;
+(function (TokenKind) {
+    TokenKind[TokenKind["Word"] = 0] = "Word";
+    TokenKind[TokenKind["Pipe"] = 1] = "Pipe";
+    TokenKind[TokenKind["And"] = 2] = "And";
+    TokenKind[TokenKind["Or"] = 3] = "Or";
+    TokenKind[TokenKind["Semi"] = 4] = "Semi";
+    TokenKind[TokenKind["Amp"] = 5] = "Amp";
+    TokenKind[TokenKind["RedirectOut"] = 6] = "RedirectOut";
+    TokenKind[TokenKind["RedirectAppend"] = 7] = "RedirectAppend";
+    TokenKind[TokenKind["RedirectIn"] = 8] = "RedirectIn";
+    TokenKind[TokenKind["RedirectReadWrite"] = 9] = "RedirectReadWrite";
+    TokenKind[TokenKind["Heredoc"] = 10] = "Heredoc";
+    TokenKind[TokenKind["HeredocStripTabs"] = 11] = "HeredocStripTabs";
+    TokenKind[TokenKind["HeredocBody"] = 12] = "HeredocBody";
+    TokenKind[TokenKind["RedirectErr"] = 13] = "RedirectErr";
+    TokenKind[TokenKind["RedirectErrAppend"] = 14] = "RedirectErrAppend";
+    TokenKind[TokenKind["RedirectAll"] = 15] = "RedirectAll";
+    TokenKind[TokenKind["DoubleSemi"] = 16] = "DoubleSemi";
+    TokenKind[TokenKind["LParen"] = 17] = "LParen";
+    TokenKind[TokenKind["RParen"] = 18] = "RParen";
+    TokenKind[TokenKind["Newline"] = 19] = "Newline";
+    TokenKind[TokenKind["EOF"] = 20] = "EOF";
+})(TokenKind || (TokenKind = {}));

package/dist/substrate/lifo/terminal/ITerminal.d.ts

@@ -0,0 +1,10 @@
+export interface ITerminal {
+    write(data: string): void;
+    writeln(data: string): void;
+    onData(callback: (data: string) => void): void;
+    readonly cols: number;
+    readonly rows: number;
+    focus(): void;
+    clear(): void;
+}
+//# sourceMappingURL=ITerminal.d.ts.map

package/dist/substrate/lifo/terminal/ITerminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITerminal.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/terminal/ITerminal.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/substrate/lifo/terminal/ITerminal.js

@@ -0,0 +1 @@
+export {};