sh-ast 0.0.0 → 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Shell dialect (mvdan/sh `LangVariant`) to parse against. Mapped to
+ * `LangVariant` by string name via `LangVariant.Set()` — never by numeric
+ * value, since the bit-flag encoding of `LangVariant` is not a stable
+ * contract across mvdan/sh versions. See design/ARCHITECTURE.md, "Parse
+ * errors and dialects".
+ *
+ * @public
+ */
+export type ShellDialect = 'bash' | 'posix' | 'mksh' | 'bats' | 'zsh';
+/**
+ * Options accepted by {@link parseSync}.
+ *
+ * @public
+ */
+export interface ParseOptions {
+    /**
+     * The shell dialect to parse against.
+     * @defaultValue `"bash"`
+     */
+    readonly dialect?: ShellDialect;
+    /**
+     * Filename used only to annotate error messages and positions; the source
+     * is never read from disk.
+     * @defaultValue `"input.sh"`
+     */
+    readonly filename?: string;
+}
+/**
+ * A 1-based line/column position. Columns are UTF-16 code units, matching
+ * JavaScript string indexing (see {@link ShNode.range}).
+ *
+ * @public
+ */
+export interface Position {
+    readonly line: number;
+    readonly column: number;
+}
+/**
+ * A normalized AST node produced by {@link parseSync}.
+ *
+ * `range` and `loc` are expressed in UTF-16 code units, so
+ * `code.slice(node.range[0], node.range[1])` reproduces the node's exact
+ * source text — even though mvdan/sh itself reports byte offsets and
+ * byte-counting columns internally (see design/ARCHITECTURE.md's
+ * "Serialization contract"). Every other field copied over from mvdan/sh's
+ * typedjson tree keeps its original value but with the field name
+ * lowercased (`Stmts` becomes `stmts`, `CondLast` becomes `condlast`, etc.).
+ *
+ * @public
+ */
+export interface ShNode {
+    readonly type: string;
+    readonly range: readonly [number, number];
+    readonly loc: {
+        readonly start: Position;
+        readonly end: Position;
+    };
+    [field: string]: unknown;
+}
+/**
+ * The root node of a parsed shell script.
+ *
+ * @public
+ */
+export interface ShFile extends ShNode {
+    readonly type: 'File';
+    readonly stmts: readonly ShNode[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,GAAG,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;QAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC;IACnE,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAO,SAAQ,MAAM;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/visitor-keys.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Maps each normalized node `type` to the field names (lowercased, matching
+ * the normalized node shape produced by `normalize`) whose values hold child
+ * nodes.
+ *
+ * Generated from mvdan/sh's `syntax` package struct definitions by
+ * `tools/gen-visitor-keys` (see design/ARCHITECTURE.md, "The schema table is
+ * generated, not hand-written") — this module only re-exports the generated
+ * table under the public name, frozen. {@link walk} does not depend on this
+ * table for correctness — it discovers children structurally — so any gap
+ * here (there shouldn't be one; the kitchen-sink golden test guards it)
+ * affects only external consumers that choose to traverse via this table.
+ *
+ * Frozen (including each per-type field-name array) so immutability of this
+ * shared, module-scoped table is a contract, not just a convention any
+ * importer happens to honor.
+ *
+ * @public
+ */
+export declare const visitorKeys: Readonly<Record<string, readonly string[]>>;
+//# sourceMappingURL=visitor-keys.d.ts.map

package/dist/visitor-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-keys.d.ts","sourceRoot":"","sources":["../src/visitor-keys.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAClC,CAAC"}

package/dist/visitor-keys.js

@@ -0,0 +1,23 @@
+import { deepFreeze } from './deep-freeze.js';
+import { visitorKeys as generatedVisitorKeys } from '../generated/visitor-keys.js';
+/**
+ * Maps each normalized node `type` to the field names (lowercased, matching
+ * the normalized node shape produced by `normalize`) whose values hold child
+ * nodes.
+ *
+ * Generated from mvdan/sh's `syntax` package struct definitions by
+ * `tools/gen-visitor-keys` (see design/ARCHITECTURE.md, "The schema table is
+ * generated, not hand-written") — this module only re-exports the generated
+ * table under the public name, frozen. {@link walk} does not depend on this
+ * table for correctness — it discovers children structurally — so any gap
+ * here (there shouldn't be one; the kitchen-sink golden test guards it)
+ * affects only external consumers that choose to traverse via this table.
+ *
+ * Frozen (including each per-type field-name array) so immutability of this
+ * shared, module-scoped table is a contract, not just a convention any
+ * importer happens to honor.
+ *
+ * @public
+ */
+export const visitorKeys = deepFreeze(generatedVisitorKeys);
+//# sourceMappingURL=visitor-keys.js.map

package/dist/visitor-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-keys.js","sourceRoot":"","sources":["../src/visitor-keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEnF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,UAAU,CAAC,oBAAoB,CAAC,CAAC"}

package/dist/walk.d.ts

@@ -0,0 +1,18 @@
+import type { ShNode } from './types.js';
+/**
+ * Visits every node in a normalized tree, pre-order (parent before
+ * children), starting at `node`.
+ *
+ * Children are discovered structurally: any field on a visited node whose
+ * value is itself a normalized node (or an array of normalized nodes) is
+ * treated as a child. This is deliberately not driven off {@link
+ * visitorKeys} — the spike's hand-written visitor-keys table missed
+ * `DeclClause.Variant` (see design/ARCHITECTURE.md) and silently
+ * under-walked the tree, and `visitorKeys` remains hand-maintained pending a
+ * schema generator (tracked separately). Walking structurally means this
+ * function's completeness never depends on that table's accuracy.
+ *
+ * @public
+ */
+export declare function walk(node: ShNode, visit: (node: ShNode, parent: ShNode | null) => void): void;
+//# sourceMappingURL=walk.d.ts.map

package/dist/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AA6BzC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAE7F"}

package/dist/walk.js

@@ -0,0 +1,40 @@
+function isShNode(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.type === 'string' &&
+        Array.isArray(value.range));
+}
+function walkNode(node, parent, visit) {
+    visit(node, parent);
+    for (const value of Object.values(node)) {
+        if (isShNode(value)) {
+            walkNode(value, node, visit);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                if (isShNode(item))
+                    walkNode(item, node, visit);
+            }
+        }
+    }
+}
+/**
+ * Visits every node in a normalized tree, pre-order (parent before
+ * children), starting at `node`.
+ *
+ * Children are discovered structurally: any field on a visited node whose
+ * value is itself a normalized node (or an array of normalized nodes) is
+ * treated as a child. This is deliberately not driven off {@link
+ * visitorKeys} — the spike's hand-written visitor-keys table missed
+ * `DeclClause.Variant` (see design/ARCHITECTURE.md) and silently
+ * under-walked the tree, and `visitorKeys` remains hand-maintained pending a
+ * schema generator (tracked separately). Walking structurally means this
+ * function's completeness never depends on that table's accuracy.
+ *
+ * @public
+ */
+export function walk(node, visit) {
+    walkNode(node, null, visit);
+}
+//# sourceMappingURL=walk.js.map

package/dist/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.js","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAEA,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACrB,OAAQ,KAA4B,CAAC,IAAI,KAAK,QAAQ;QACtD,KAAK,CAAC,OAAO,CAAE,KAA6B,CAAC,KAAK,CAAC,CACpD,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CACf,IAAY,EACZ,MAAqB,EACrB,KAAoD;IAEpD,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACpB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACpB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,KAAkB,EAAE,CAAC;gBACtC,IAAI,QAAQ,CAAC,IAAI,CAAC;oBAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,KAAoD;IACrF,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AAC9B,CAAC"}

package/dist/wasm-instance.d.ts

@@ -0,0 +1,13 @@
+import '../shim/wasm_exec.js';
+/**
+ * Calls into the WASM shim's `process` export, instantiating the shim on
+ * first use. Encodes `text`/`dialect`/`filename` into shim-owned linear
+ * memory, reads the NUL-terminated JSON result back via `TextDecoder`
+ * (rather than syscall/js's `js.ValueOf(string)`, which dominated the parse
+ * cost — see design/ARCHITECTURE.md's "Performance"), and frees every buffer
+ * the call allocated.
+ *
+ * @internal
+ */
+export declare function callParse(text: string, dialect: string, filename: string): string;
+//# sourceMappingURL=wasm-instance.d.ts.map

package/dist/wasm-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-instance.d.ts","sourceRoot":"","sources":["../src/wasm-instance.ts"],"names":[],"mappings":"AAGA,OAAO,sBAAsB,CAAC;AA2F9B;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuBjF"}

package/dist/wasm-instance.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import '../shim/wasm_exec.js';
+import { ShBridgeInternalError } from './errors.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+// `shim/` is a sibling of both `src/` (test-time) and `dist/` (build-time).
+const wasmPath = path.join(here, '..', 'shim', 'sh-ast.wasm');
+function isShimExports(value) {
+    const candidate = value;
+    return (candidate.mem instanceof WebAssembly.Memory &&
+        typeof candidate.alloc === 'function' &&
+        typeof candidate.free === 'function' &&
+        typeof candidate.process === 'function');
+}
+let wasmModule;
+let shimExports;
+/**
+ * Instantiates the WASM shim synchronously in Node, exactly once, and
+ * reuses the instance across parses (see design/ARCHITECTURE.md,
+ * "Synchronous parse: solved, two mechanisms"). Node imposes no size limit
+ * on synchronous `WebAssembly.Module` compilation — that restriction is
+ * browser-main-thread-only.
+ */
+function ensureInstance() {
+    if (shimExports)
+        return shimExports;
+    wasmModule ??= new WebAssembly.Module(fs.readFileSync(wasmPath));
+    const go = new Go();
+    const instance = new WebAssembly.Instance(wasmModule, go.importObject);
+    void go.run(instance);
+    if (!isShimExports(instance.exports)) {
+        throw new ShBridgeInternalError('bridge: WASM shim did not export the expected alloc/process/free/mem linear-memory ABI');
+    }
+    shimExports = instance.exports;
+    return shimExports;
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * Writes `text` (UTF-8 encoded) into a freshly `alloc`ed buffer and returns
+ * its (pointer, length). The caller owns the buffer and must `free` it once
+ * `process` has consumed it.
+ */
+function writeString(exports, text) {
+    const bytes = encoder.encode(text);
+    const ptr = exports.alloc(bytes.length);
+    // `exports.mem.buffer` is re-read here rather than cached across calls:
+    // a Go-side allocation can grow WASM linear memory, which detaches any
+    // previously created `ArrayBuffer` view (see `callParse` below for the
+    // same reasoning on the read side).
+    new Uint8Array(exports.mem.buffer, ptr, bytes.length).set(bytes);
+    return { ptr, len: bytes.length };
+}
+/**
+ * Calls into the WASM shim's `process` export, instantiating the shim on
+ * first use. Encodes `text`/`dialect`/`filename` into shim-owned linear
+ * memory, reads the NUL-terminated JSON result back via `TextDecoder`
+ * (rather than syscall/js's `js.ValueOf(string)`, which dominated the parse
+ * cost — see design/ARCHITECTURE.md's "Performance"), and frees every buffer
+ * the call allocated.
+ *
+ * @internal
+ */
+export function callParse(text, dialect, filename) {
+    const exports = ensureInstance();
+    const t = writeString(exports, text);
+    const d = writeString(exports, dialect);
+    const f = writeString(exports, filename);
+    const resultPtr = exports.process(t.ptr, t.len, d.ptr, d.len, f.ptr, f.len);
+    exports.free(t.ptr);
+    exports.free(d.ptr);
+    exports.free(f.ptr);
+    if (resultPtr === 0) {
+        throw new ShBridgeInternalError('bridge: WASM shim returned a null result pointer');
+    }
+    // Re-read `mem.buffer` fresh (see `writeString`'s comment) and scan for the
+    // shim's NUL sentinel — valid JSON from Go's encoding/json never contains
+    // a raw 0x00 byte, since every control character is \u-escaped.
+    const memory = new Uint8Array(exports.mem.buffer);
+    let end = resultPtr;
+    while (memory[end] !== 0)
+        end++;
+    const json = decoder.decode(memory.subarray(resultPtr, end));
+    exports.free(resultPtr);
+    return json;
+}
+//# sourceMappingURL=wasm-instance.js.map

package/dist/wasm-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-instance.js","sourceRoot":"","sources":["../src/wasm-instance.ts"],"names":[],"mappings":"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"}

package/generated/child-type-schema.d.ts

@@ -0,0 +1,14 @@
+// Code generated by tools/gen-visitor-keys from mvdan.cc/sh/v3 v3.13.1. DO NOT EDIT.
+// See design/ARCHITECTURE.md, "The schema table is generated, not hand-written".
+/**
+ * `(parentType, fieldName) -> childType` for node fields whose static Go
+ * type is a concrete struct rather than an interface — typedjson only
+ * emits a "Type" discriminator for interface-typed fields, so these need
+ * the child type injected during normalization. A `null` value means the
+ * field's static type is a Node-derived interface (already
+ * self-discriminating). See design/ARCHITECTURE.md, "The schema table is
+ * generated, not hand-written".
+ *
+ * @internal
+ */
+export declare const CHILD_TYPE_SCHEMA: Record<string, Record<string, string | null>>;

package/generated/child-type-schema.js

@@ -0,0 +1,188 @@
+// Code generated by tools/gen-visitor-keys from mvdan.cc/sh/v3 v3.13.1. DO NOT EDIT.
+// See design/ARCHITECTURE.md, "The schema table is generated, not hand-written".
+export const CHILD_TYPE_SCHEMA = {
+  ArithmCmd: {
+    X: null,
+  },
+  ArithmExp: {
+    X: null,
+  },
+  ArrayElem: {
+    Comments: 'Comment',
+    Index: null,
+    Value: 'Word',
+  },
+  ArrayExpr: {
+    Elems: 'ArrayElem',
+    Last: 'Comment',
+  },
+  Assign: {
+    Array: 'ArrayExpr',
+    Index: null,
+    Name: 'Lit',
+    Value: 'Word',
+  },
+  BinaryArithm: {
+    X: null,
+    Y: null,
+  },
+  BinaryCmd: {
+    X: 'Stmt',
+    Y: 'Stmt',
+  },
+  BinaryTest: {
+    X: null,
+    Y: null,
+  },
+  Block: {
+    Last: 'Comment',
+    Stmts: 'Stmt',
+  },
+  BraceExp: {
+    Elems: 'Word',
+  },
+  CStyleLoop: {
+    Cond: null,
+    Init: null,
+    Post: null,
+  },
+  CallExpr: {
+    Args: 'Word',
+    Assigns: 'Assign',
+  },
+  CaseClause: {
+    Items: 'CaseItem',
+    Last: 'Comment',
+    Word: 'Word',
+  },
+  CaseItem: {
+    Comments: 'Comment',
+    Last: 'Comment',
+    Patterns: 'Word',
+    Stmts: 'Stmt',
+  },
+  CmdSubst: {
+    Last: 'Comment',
+    Stmts: 'Stmt',
+  },
+  Comment: {},
+  CoprocClause: {
+    Name: 'Word',
+    Stmt: 'Stmt',
+  },
+  DblQuoted: {
+    Parts: null,
+  },
+  DeclClause: {
+    Args: 'Assign',
+    Variant: 'Lit',
+  },
+  Expansion: {
+    Word: 'Word',
+  },
+  ExtGlob: {
+    Pattern: 'Lit',
+  },
+  File: {
+    Last: 'Comment',
+    Stmts: 'Stmt',
+  },
+  FlagsArithm: {
+    Flags: 'Lit',
+    X: null,
+  },
+  ForClause: {
+    Do: 'Stmt',
+    DoLast: 'Comment',
+    Loop: null,
+  },
+  FuncDecl: {
+    Body: 'Stmt',
+    Name: 'Lit',
+    Names: 'Lit',
+  },
+  IfClause: {
+    Cond: 'Stmt',
+    CondLast: 'Comment',
+    Else: 'IfClause',
+    Last: 'Comment',
+    Then: 'Stmt',
+    ThenLast: 'Comment',
+  },
+  LetClause: {
+    Exprs: null,
+  },
+  Lit: {},
+  ParamExp: {
+    Exp: 'Expansion',
+    Flags: 'Lit',
+    Index: null,
+    Modifiers: 'Lit',
+    NestedParam: null,
+    Param: 'Lit',
+    Repl: 'Replace',
+    Slice: 'Slice',
+  },
+  ParenArithm: {
+    X: null,
+  },
+  ParenTest: {
+    X: null,
+  },
+  ProcSubst: {
+    Last: 'Comment',
+    Stmts: 'Stmt',
+  },
+  Redirect: {
+    Hdoc: 'Word',
+    N: 'Lit',
+    Word: 'Word',
+  },
+  Replace: {
+    Orig: 'Word',
+    With: 'Word',
+  },
+  SglQuoted: {},
+  Slice: {
+    Length: null,
+    Offset: null,
+  },
+  Stmt: {
+    Cmd: null,
+    Comments: 'Comment',
+    Redirs: 'Redirect',
+  },
+  Subshell: {
+    Last: 'Comment',
+    Stmts: 'Stmt',
+  },
+  TestClause: {
+    X: null,
+  },
+  TestDecl: {
+    Body: 'Stmt',
+    Description: 'Word',
+  },
+  TimeClause: {
+    Stmt: 'Stmt',
+  },
+  UnaryArithm: {
+    X: null,
+  },
+  UnaryTest: {
+    X: null,
+  },
+  WhileClause: {
+    Cond: 'Stmt',
+    CondLast: 'Comment',
+    Do: 'Stmt',
+    DoLast: 'Comment',
+  },
+  Word: {
+    Parts: null,
+  },
+  WordIter: {
+    Items: 'Word',
+    Name: 'Lit',
+  },
+};