querysub 0.356.0 → 0.357.0

package/src/wat/watGrammar.pegjs

@@ -0,0 +1,93 @@
+// WebAssembly Text Format (WAT) Grammar
+// This grammar captures the basic S-expression structure of WAT
+
+{
+    function makeNode(type, data) {
+        return { type, ...data };
+    }
+}
+
+Start
+    = _ items:SExpr* _ { 
+        return makeNode('module', { items }); 
+    }
+
+// S-Expression (parenthesized form)
+SExpr
+    = "(" _ keyword:Keyword attrs:(_ MemoryAttribute)* items:(_ (SExpr / Literal / Identifier / TypeName))* _ ")" {
+        return makeNode('sexpr', { keyword, attributes: attrs.map(a => a[1]), items: items.map(i => i[1]) });
+    }
+
+// Memory operation attributes (offset=N, align=N)
+MemoryAttribute
+    = name:$("offset" / "align") "=" value:$([0-9]+) {
+        return makeNode('attribute', { name, value: parseInt(value, 10) });
+    }
+
+// Type names (i32, i64, f32, f64, etc.)
+TypeName
+    = name:$("i32" / "i64" / "f32" / "f64" / "v128" / "funcref" / "externref" / "anyref") {
+        return makeNode('identifier', { name });
+    }
+
+// Keywords (instructions, directives, etc.)
+Keyword
+    = keyword:$([a-z_][a-z0-9_\.]*) {
+        return keyword;
+    }
+
+// Identifiers (e.g., $funcName, $varName)
+Identifier
+    = "$" name:$([a-zA-Z0-9_\.]+) {
+        return makeNode('identifier', { name: '$' + name });
+    }
+    / name:$([0-9]+) {
+        return makeNode('index', { value: parseInt(name, 10) });
+    }
+
+// Literals
+Literal
+    = NumberLiteral
+    / StringLiteral
+
+NumberLiteral
+    = sign:"-"? value:$(
+        "0x" [0-9a-fA-F_]+
+        / [0-9]+ "." [0-9]+ ([eE] [+-]? [0-9]+)?
+        / [0-9]+ ([eE] [+-]? [0-9]+)?
+    ) {
+        let fullValue = (sign || '') + value.replace(/_/g, '');
+        return makeNode('number', { value: fullValue });
+    }
+
+StringLiteral
+    = '"' chars:DoubleStringChar* '"' {
+        return makeNode('string', { value: chars.join('') });
+    }
+
+DoubleStringChar
+    = !'"' !"\\" char:. { return char; }
+    / "\\" escape:EscapeSequence { return escape; }
+
+EscapeSequence
+    = "n" { return "\n"; }
+    / "r" { return "\r"; }
+    / "t" { return "\t"; }
+    / "\\" { return "\\"; }
+    / '"' { return '"'; }
+    / "x" hex:$([0-9a-fA-F][0-9a-fA-F]) {
+        return String.fromCharCode(parseInt(hex, 16));
+    }
+
+// Whitespace and comments
+_
+    = (Whitespace / LineComment / BlockComment)*
+
+Whitespace
+    = [ \t\r\n]+
+
+LineComment
+    = ";;" [^\r\n]*
+
+BlockComment
+    = "(;" (!";" .)* ";)"

package/src/wat/watHandler.ts

@@ -0,0 +1,179 @@
+import { sha256 } from "js-sha256";
+import { addAdditionalExtensions, compileTransform2 } from "../../../typenode";
+import { compileWAT } from "./watCompiler";
+import fs from "fs";
+
+let injected = false;
+
+export function watHandler(): void {
+    if (injected) return;
+    injected = true;
+    addAdditionalExtensions([".wat"]);
+
+    let watFileContents = fs.readFileSync(__dirname + "/watCompiler.ts", "utf8");
+
+    compileTransform2({
+        matches: [/\.wat$/],
+        additionalCacheKey: sha256(watFileContents),
+        transform: (contents: string, path: string, module: NodeJS.Module): string => {
+            const wasmBuffer = compileWAT(contents);
+            const base64 = Buffer.from(wasmBuffer).toString("base64");
+            console.log(base64.slice(0, 200));
+            let maxPages = MAX_TOTAL_BYTES / WASM_PAGE_SIZE;
+            return `
+                const wasmBuffer = Buffer.from("${base64}", "base64");
+                const wasmModule = new WebAssembly.Module(wasmBuffer);
+                
+                // If in node, and < node 24, throw
+                if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+                    const nodeMajorVersion = parseInt(process.versions.node.split('.')[0], 10);
+                    if (nodeMajorVersion < 24) {
+                        throw new Error(\`WebAssembly memory64 requires Node.js 24 or later. Current version: \${process.versions.node}\`);
+                    }
+                }
+                
+                const memory = new WebAssembly.Memory({
+                    initial: 1n,
+                    maximum: ${maxPages}n,
+                    address: 'i64'
+                });
+                
+                const wasmInstance = new WebAssembly.Instance(wasmModule, {
+                    env: { memory }
+                });
+                
+                // Export both the instance exports and the memory
+                module.exports = {
+                    ...wasmInstance.exports,
+                    memory
+                };
+            `;
+        },
+    });
+}
+
+// ─── Memory allocation support ────────────────────────────────────────────────
+
+const WASM_PAGE_SIZE = 65536; // 64 KiB per WebAssembly spec
+const MAX_TOTAL_BYTES = 16 * 1024 * 1024 * 1024; // 16 GiB hard ceiling
+const ALIGNMENT = 8; // align all allocations to 8-byte boundaries
+
+/** Running total of all pages ever grown across every WAT module instance. */
+let totalGrownBytes = 0;
+
+interface ModuleMemoryState {
+    /** Byte offset of the next free allocation slot (always ALIGNMENT-aligned). */
+    nextOffset: number;
+}
+
+const memoryStateMap = new WeakMap<WebAssembly.Memory, ModuleMemoryState>();
+
+/**
+ * Describes the exports a WAT module must provide to support memory allocation.
+ *
+ * Required:
+ *   - `memory`       — the module's exported WebAssembly.Memory
+ *
+ * Optional:
+ *   - `__heap_base`  — an exported i32 global whose value is the first byte
+ *                      after any static data; the allocator starts here.
+ *                      If absent, allocations start from byte 0.
+ *
+ * Example WAT:
+ *   (memory (export "memory") 1)
+ *   (global (export "__heap_base") i32 (i32.const 0))
+ */
+export interface WatModuleExports {
+    memory: WebAssembly.Memory;
+    __heap_base?: WebAssembly.Global;
+    [key: string]: unknown;
+}
+
+/**
+ * A stable handle to a region of WebAssembly linear memory.
+ *
+ * Because `WebAssembly.Memory.grow()` detaches and replaces the underlying
+ * ArrayBuffer, any raw Uint8Array taken before a grow becomes invalid.
+ * WatBuffer solves this: access `.view` or `.dataView` each time you need
+ * to read or write, and you always get a fresh view from the current buffer.
+ *
+ * Allocate once per logical scratch region; reuse the handle for every call.
+ */
+export class WatBuffer {
+    private readonly _memory: WebAssembly.Memory;
+    /** Byte offset of this region within the module's linear memory. */
+    readonly offset: number;
+    /** Size of this region in bytes (as requested, before alignment padding). */
+    readonly byteLength: number;
+
+    constructor(memory: WebAssembly.Memory, offset: number, byteLength: number) {
+        this._memory = memory;
+        this.offset = offset;
+        this.byteLength = byteLength;
+    }
+
+    /** A Uint8Array view into the current memory buffer for this region.
+     *  Re-read after any call that may grow the module's memory. */
+    get view(): Uint8Array {
+        return new Uint8Array(this._memory.buffer, this.offset, this.byteLength);
+    }
+
+    /** A DataView into the current memory buffer for this region.
+     *  Re-read after any call that may grow the module's memory. */
+    get dataView(): DataView {
+        return new DataView(this._memory.buffer, this.offset, this.byteLength);
+    }
+}
+
+function alignUp(value: number, alignment: number): number {
+    return Math.ceil(value / alignment) * alignment;
+}
+
+/**
+ * Allocates `byteLength` bytes in a WAT module's linear memory and returns
+ * a `WatBuffer` handle for that region.
+ *
+ * - Memory is grown (in 64 KiB pages) as needed to satisfy the request.
+ * - Allocations are never freed; callers should allocate once and reuse.
+ * - Cumulative grown memory across *all* modules must not exceed 16 GiB;
+ *   exceeding this throws an error.
+ *
+ * The module's exports must satisfy `WatModuleExports` (export `memory`,
+ * and optionally `__heap_base` to skip over any static data section).
+ */
+export function allocateBuffer(exports: WatModuleExports, byteLength: number): WatBuffer {
+    const memory = exports.memory;
+
+    let state = memoryStateMap.get(memory);
+    if (!state) {
+        const heapBase = exports.__heap_base !== undefined
+            ? (exports.__heap_base.value as number)
+            : 0;
+        state = { nextOffset: alignUp(heapBase, ALIGNMENT) };
+        memoryStateMap.set(memory, state);
+    }
+
+    const startOffset = state.nextOffset;
+    const endOffset = alignUp(startOffset + byteLength, ALIGNMENT);
+
+    const currentBytes = memory.buffer.byteLength;
+    if (endOffset > currentBytes) {
+        const needed = endOffset - currentBytes;
+        const pages = Math.ceil(needed / WASM_PAGE_SIZE);
+        const newBytes = pages * WASM_PAGE_SIZE;
+
+        if (totalGrownBytes + newBytes > MAX_TOTAL_BYTES) {
+            throw new Error(
+                `WAT memory allocation would exceed 16 GiB limit. ` +
+                `Already grown ${totalGrownBytes} bytes, trying to grow by ${newBytes} bytes` +
+                `(${pages} page(s)) to satisfy request of ${byteLength} bytes at offset ${startOffset}.`
+            );
+        }
+
+        memory.grow(BigInt(pages) as any);
+        totalGrownBytes += newBytes;
+    }
+
+    state.nextOffset = endOffset;
+    return new WatBuffer(memory, startOffset, byteLength);
+}