@miaskiewicz/turbo-dom 0.1.57 → 0.1.62

package/README.md

@@ -85,6 +85,37 @@ parseBuffer('<div id=a>...</div>');                // compact SoA typed-array bu
 parseFragment('<rect/>', 'svg path');              // fragment in a context element
 ```
 
+### Choosing the parser backend (native vs WASM)
+
+The runtime resolves a parser lazily on first parse: native N-API addon first, WASM
+fallback. Force it per environment or globally:
+
+```js
+import { createEnvironment, setParserMode } from '@miaskiewicz/turbo-dom/runtime';
+
+createEnvironment(html, { parser: 'wasm' });   // 'wasm' | 'native' | 'auto' (default)
+setParserMode('wasm');                          // process-global; also TURBO_DOM_PARSER=wasm
+```
+
+### Embedding in a non-Node runtime (bare V8, no Node builtins)
+
+The native addon and the `--target nodejs` WASM build both need Node. For a fully
+node-free host, instantiate the `--target web` WASM yourself and inject the binding —
+the runtime then never touches `node:module`/`fs`:
+
+```js
+import init, { initSync, parse, parseBuffer, parseFragment } from '@miaskiewicz/turbo-dom/parser-wasm';
+import { setParser, createEnvironment } from '@miaskiewicz/turbo-dom/runtime';
+
+initSync({ module: wasmBytes });                // you supply the bytes (sync, no fs)
+setParser({ parse, parseBuffer, parseFragment });
+createEnvironment('<div id=app/>');             // now runs with zero Node deps
+```
+
+`setParser` also reads `globalThis.__TURBO_DOM_PARSER__` if you prefer injection by
+global. Use `installGlobals(globalThis, { html })` (from `@miaskiewicz/turbo-dom/install`)
+to set up `document`/`window` on any global object.
+
 ## Compatibility
 
 | | turbo-dom | happy-dom | jsdom |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miaskiewicz/turbo-dom",
-  "version": "0.1.57",
+  "version": "0.1.62",
   "description": "Faster, more spec-correct DOM for test runners — native html5ever (Rust/WASM) parser + lazy copy-on-write DOM. A drop-in-style alternative to jsdom/happy-dom for vitest & jest.",
   "license": "MIT",
   "main": "index.js",
@@ -18,6 +18,16 @@
     "./environment/vitest": {
       "import": "./src/environment/vitest.mjs"
     },
+    "./environment/install": {
+      "import": "./src/environment/install.mjs"
+    },
+    "./install": {
+      "import": "./src/environment/install.mjs"
+    },
+    "./parser-wasm": {
+      "types": "./pkg-web/turbo_dom_parser.d.ts",
+      "import": "./pkg-web/turbo_dom_parser.js"
+    },
     "./jest": {
       "require": "./src/environment/jest.cjs"
     },
@@ -27,6 +37,14 @@
     "index.js",
     "index.d.ts",
     "*.node",
+    "pkg/turbo_dom_parser.js",
+    "pkg/turbo_dom_parser.d.ts",
+    "pkg/turbo_dom_parser_bg.wasm",
+    "pkg/turbo_dom_parser_bg.wasm.d.ts",
+    "pkg-web/turbo_dom_parser.js",
+    "pkg-web/turbo_dom_parser.d.ts",
+    "pkg-web/turbo_dom_parser_bg.wasm",
+    "pkg-web/turbo_dom_parser_bg.wasm.d.ts",
     "src/**/*.mjs",
     "src/**/*.cjs",
     "src/**/*.d.ts",
@@ -51,12 +69,13 @@
     }
   },
   "scripts": {
-    "build": "napi build --platform --release",
+    "build": "napi build --platform --release && npm run build:wasm:pkg && npm run build:wasm:web",
     "build:debug": "napi build --platform",
     "build:wasm": "cargo build --release --no-default-features --features wasm-bind --target wasm32-unknown-unknown",
     "build:wasm:pkg": "wasm-pack build --target nodejs --out-dir pkg --no-default-features --features wasm-bind",
+    "build:wasm:web": "wasm-pack build --target web --out-dir pkg-web --no-default-features --features wasm-bind",
     "test": "node --test 'test/*.mjs'",
-    "test:cov": "node --test --experimental-test-coverage --test-coverage-include='src/runtime/**' --test-coverage-lines=99 --test-coverage-functions=87 --test-coverage-branches=87 'test/*.mjs'",
+    "test:cov": "node --test --experimental-test-coverage --test-coverage-include='src/runtime/**' --test-coverage-lines=99 --test-coverage-functions=92 --test-coverage-branches=88 'test/*.mjs'",
     "test:rust": "cargo test --lib",
     "test:all": "npm run build && npm run test:rust && npm test",
     "prepare": "git config core.hooksPath .githooks || true",
@@ -67,7 +86,7 @@
     "bench:suite": "node bench/suite.mjs",
     "bench:wasm": "node bench/wasm.mjs",
     "bench:all": "node bench/parse.mjs && node bench/construct.mjs && node bench/suite.mjs && node bench/query.mjs && node bench/wasm.mjs",
-    "prepublishOnly": "napi build --platform --release",
+    "prepublishOnly": "napi build --platform --release && npm run build:wasm:pkg && npm run build:wasm:web",
     "test:vitest": "vitest run -c test-vitest/vitest.config.mjs",
     "test:jest": "jest -c test-jest/jest.config.cjs",
     "bench:query": "node bench/query.mjs",

package/pkg/turbo_dom_parser.d.ts

@@ -0,0 +1,11 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Same contract as the native addon, marshaled via serde → JS object.
+ */
+export function parse(html: string): any;
+
+export function parseBuffer(html: string): any;
+
+export function parseFragment(html: string, context?: string | null): any;

package/pkg/turbo_dom_parser.js

@@ -0,0 +1,197 @@
+/* @ts-self-types="./turbo_dom_parser.d.ts" */
+
+/**
+ * Same contract as the native addon, marshaled via serde → JS object.
+ * @param {string} html
+ * @returns {any}
+ */
+function parse(html) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parse(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.parse = parse;
+
+/**
+ * @param {string} html
+ * @returns {any}
+ */
+function parseBuffer(html) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseBuffer(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.parseBuffer = parseBuffer;
+
+/**
+ * @param {string} html
+ * @param {string | null} [context]
+ * @returns {any}
+ */
+function parseFragment(html, context) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(context) ? 0 : passStringToWasm0(context, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.parseFragment(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.parseFragment = parseFragment;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_d90091b82fdf5b91: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_dca99999bba88a9a: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./turbo_dom_parser_bg.js": import0,
+    };
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/turbo_dom_parser_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/pkg/turbo_dom_parser_bg.wasm.d.ts

@@ -0,0 +1,11 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const parse: (a: number, b: number) => [number, number, number];
+export const parseBuffer: (a: number, b: number) => [number, number, number];
+export const parseFragment: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/pkg-web/turbo_dom_parser.d.ts

@@ -0,0 +1,47 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Same contract as the native addon, marshaled via serde → JS object.
+ */
+export function parse(html: string): any;
+
+export function parseBuffer(html: string): any;
+
+export function parseFragment(html: string, context?: string | null): any;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly parse: (a: number, b: number) => [number, number, number];
+    readonly parseBuffer: (a: number, b: number) => [number, number, number];
+    readonly parseFragment: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/pkg-web/turbo_dom_parser.js

@@ -0,0 +1,289 @@
+/* @ts-self-types="./turbo_dom_parser.d.ts" */
+
+/**
+ * Same contract as the native addon, marshaled via serde → JS object.
+ * @param {string} html
+ * @returns {any}
+ */
+export function parse(html) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parse(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} html
+ * @returns {any}
+ */
+export function parseBuffer(html) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseBuffer(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} html
+ * @param {string | null} [context]
+ * @returns {any}
+ */
+export function parseFragment(html, context) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(context) ? 0 : passStringToWasm0(context, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.parseFragment(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_d90091b82fdf5b91: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_dca99999bba88a9a: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./turbo_dom_parser_bg.js": import0,
+    };
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('turbo_dom_parser_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/pkg-web/turbo_dom_parser_bg.wasm.d.ts

@@ -0,0 +1,11 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const parse: (a: number, b: number) => [number, number, number];
+export const parseBuffer: (a: number, b: number) => [number, number, number];
+export const parseFragment: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/src/core.rs

@@ -20,7 +20,7 @@ pub const DOCUMENT_NODE: u8 = 9;
 pub const DOCUMENT_TYPE_NODE: u8 = 10;
 pub const DOCUMENT_FRAGMENT_NODE: u8 = 11;
 
-#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize))]
+#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize), serde(rename_all = "camelCase"))]
 #[derive(Debug, Clone)]
 pub struct Attr {
     pub name: String,
@@ -30,7 +30,7 @@ pub struct Attr {
 }
 
 /// One marshaled DOM node. Nested children = complete tree, no lazy indices.
-#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize))]
+#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize), serde(rename_all = "camelCase"))]
 #[derive(Debug, Clone)]
 pub struct Node {
     /// DOM nodeType.
@@ -73,7 +73,7 @@ pub fn parse_html_document(html: &str) -> Node {
 // the arrays and inflates node objects only on access (no eager full-tree alloc).
 
 /// Index-addressed flat tree. Node index IS its id; node 0 is the document.
-#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize))]
+#[cfg_attr(feature = "wasm-bind", derive(serde::Serialize), serde(rename_all = "camelCase"))]
 #[derive(Default)]
 pub struct Soa {
     pub node_type: Vec<u8>,    // DOM nodeType

package/src/runtime/buffer.mjs

@@ -42,7 +42,27 @@ export function unpack(soa) {
     tagNames, attrNames, attrPrefixes, attrValues, strings,
   };
 }
-const STR_DECODER = new TextDecoder();
+// Decode the UTF-8 string blob. Prefer the platform TextDecoder (Node/browser);
+// fall back to a tiny inline UTF-8 decoder so turbo-dom loads in a bare V8 with no
+// web-platform globals (the native/Node path keeps using the real TextDecoder —
+// this branch is never taken there).
+export function utf8Decode(bytes) {
+  let out = '', i = 0;
+  const n = bytes.length;
+  while (i < n) {
+    const c = bytes[i++];
+    if (c < 0x80) out += String.fromCharCode(c);
+    else if (c < 0xe0) out += String.fromCharCode(((c & 0x1f) << 6) | (bytes[i++] & 0x3f));
+    else if (c < 0xf0) out += String.fromCharCode(((c & 0x0f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f));
+    else {
+      let cp = ((c & 0x07) << 18) | ((bytes[i++] & 0x3f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f);
+      cp -= 0x10000;
+      out += String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff));
+    }
+  }
+  return out;
+}
+const STR_DECODER = typeof TextDecoder !== 'undefined' ? new TextDecoder() : { decode: utf8Decode };
 
 export class Buffer {
   constructor(soa) {

package/src/runtime/cascade.mjs

@@ -111,7 +111,14 @@ function buildIndex(scope) {
   const styles = scope.getElementsByTagName('style');
   const rules = [];
   let order = 0;
-  for (let i = 0; i < styles.length; i++) order = parseStylesheet(styles[i].textContent || '', order, rules);
+  for (let i = 0; i < styles.length; i++) {
+    order = parseStylesheet(styles[i].textContent || '', order, rules);
+    // CSS-in-JS engines inject via sheet.insertRule(), which never touches
+    // textContent. Read those rules too (only present on emotion-touched <style>s;
+    // __sheet is undefined otherwise, so plain stylesheets pay nothing here).
+    const sheet = styles[i].__sheet;
+    if (sheet) for (let k = 0; k < sheet.cssRules.length; k++) order = parseStylesheet(sheet.cssRules[k].cssText, order, rules);
+  }
   return rules;
 }
 

package/src/runtime/cssom.mjs

@@ -0,0 +1,109 @@
+// Minimal CSSOM — just enough for CSS-in-JS engines (emotion / styled-components /
+// MUI) to inject rules at runtime without throwing, AND to feed those rules into
+// the partial cascade (cascade.mjs) so getComputedStyle resolves them.
+//
+// emotion's `sheetForTag` reads `tag.sheet` and `document.styleSheets`, then calls
+// `sheet.insertRule(rule, index)` per CSS rule. It only needs insertRule to not
+// throw and `cssRules.length` to be readable — but we go one cheap step further:
+// insertRule bumps Document.__version (via the owner <style>'s __touch), so the
+// version-keyed style index in cascade.mjs rebuilds and picks the rules up.
+//
+// HONEST: this is a rule STORE, not a CSS engine. No serialization normalization,
+// no @media evaluation, no specificity beyond what cascade.mjs already does. Rules
+// are kept as their raw cssText; cascade.mjs parses them the same way it parses a
+// <style>'s textContent.
+
+export class CSSStyleRule {
+  constructor(cssText) {
+    this.cssText = String(cssText);
+    this.type = 1; // CSSRule.STYLE_RULE
+  }
+  get selectorText() {
+    const i = this.cssText.indexOf('{');
+    return i < 0 ? '' : this.cssText.slice(0, i).trim();
+  }
+}
+
+// Split a stylesheet string into top-level rule strings (brace-depth aware), used
+// by replaceSync/constructor text. Mirrors cascade.mjs's depth scan but keeps the
+// braces so each piece is a self-contained cssText.
+function splitTopLevelRules(css) {
+  const out = [];
+  const n = css.length;
+  let i = 0;
+  while (i < n) {
+    let j = i;
+    while (j < n && css[j] !== '{' && css[j] !== '}') j++;
+    if (j >= n) break;
+    if (css[j] === '}') { i = j + 1; continue; }
+    let depth = 1, k = j + 1;
+    while (k < n && depth > 0) { const ch = css[k]; if (ch === '{') depth++; else if (ch === '}') depth--; k++; }
+    const piece = css.slice(i, k).trim();
+    if (piece) out.push(piece);
+    i = k;
+  }
+  return out;
+}
+
+export class CSSStyleSheet {
+  // ownerNode is the <style> element (null for constructed/adopted sheets).
+  constructor(ownerNode = null, init = {}) {
+    this.ownerNode = ownerNode;
+    this.cssRules = [];
+    this.type = 'text/css';
+    this.disabled = false;
+    this.media = init.media != null ? init.media : [];
+    this.title = init.title != null ? init.title : null;
+    this.href = null;
+    this.parentStyleSheet = null;
+    this.ownerRule = null;
+  }
+
+  // legacy alias some libraries read
+  get rules() { return this.cssRules; }
+
+  insertRule(rule, index = 0) {
+    const i = index === undefined ? 0 : index;
+    if (i < 0 || i > this.cssRules.length) throw new RangeError('insertRule: index out of bounds');
+    this.cssRules.splice(i, 0, new CSSStyleRule(rule));
+    this.#invalidate();
+    return i;
+  }
+
+  deleteRule(index) {
+    if (index < 0 || index >= this.cssRules.length) throw new RangeError('deleteRule: index out of bounds');
+    this.cssRules.splice(index, 1);
+    this.#invalidate();
+  }
+
+  // legacy IE-era APIs (some older libs still call these)
+  addRule(selector = '', style = '', index) {
+    const i = index === undefined ? this.cssRules.length : index;
+    this.insertRule(`${selector} { ${style} }`, i);
+    return -1; // spec'd legacy return
+  }
+  removeRule(index = 0) { this.deleteRule(index); }
+
+  // constructable-stylesheet API (adoptedStyleSheets); replaceSync is synchronous.
+  replaceSync(text) {
+    this.cssRules = splitTopLevelRules(String(text)).map((r) => new CSSStyleRule(r));
+    this.#invalidate();
+  }
+  replace(text) { this.replaceSync(text); return Promise.resolve(this); }
+
+  // Bump the owning Document's version so cascade.mjs's version-keyed style index
+  // (and any getComputedStyle cache) rebuilds. Constructed sheets (no ownerNode)
+  // have nothing to invalidate until adopted — a no-op, which is correct.
+  #invalidate() {
+    const n = this.ownerNode;
+    if (n && n.__touch) n.__touch();
+  }
+}
+
+// Live StyleSheetList for document.styleSheets: a plain array (indexable +
+// iterable, what emotion needs) with the spec's `item()` accessor bolted on.
+export function styleSheetList(sheets) {
+  const list = sheets.slice();
+  list.item = (i) => list[i] ?? null;
+  return list;
+}

package/src/runtime/dom.mjs

@@ -6,7 +6,7 @@
 // Mutation promotes the affected node to fully-owned (COW). Reads are transparent
 // across the boundary — a buffer-backed read and an owned read are indistinguishable.
 
-import { createRequire } from 'node:module';
+import { getParser } from './parser.mjs';
 import {
   EventTarget, Event, CustomEvent,
   UIEvent, MouseEvent, KeyboardEvent, FocusEvent,
@@ -14,6 +14,8 @@ import {
 import { liveNodeList, liveHTMLCollection } from './collections.mjs';
 import { matchesSelector, querySelector as qsel, querySelectorAll as qselAll } from './selectors.mjs';
 import { serializeInner, serializeOuter } from './html-serialize.mjs';
+import { CSSStyleSheet, styleSheetList } from './cssom.mjs';
+import { SVGAnimatedString, SVGAnimatedLength, SVGAnimatedRect, SVG_LENGTH_ATTRS } from './svg.mjs';
 
 // Per-node query-result cache keyed by (selector, document version). querySelectorAll
 // returns a STATIC list per spec, so caching is safe until the next mutation bumps
@@ -56,9 +58,6 @@ function cachedQS(node, sel) {
 import { Buffer } from './buffer.mjs';
 import { makeCanvasStub } from './stubs.mjs';
 
-const require = createRequire(import.meta.url);
-const native = require('../../index.js');
-
 export const ELEMENT_NODE = 1;
 export const TEXT_NODE = 3;
 export const COMMENT_NODE = 8;
@@ -379,6 +378,7 @@ export class Element extends Node {
     this.__qsCache = undefined;        // querySelector cache
     this.__computedStyle = undefined;  // getComputedStyle snapshot (version-keyed)
     this.__shadow = undefined;         // attached shadow root (open or closed)
+    this.__sheet = undefined;          // CSSOM CSSStyleSheet for <style> (lazy, CSS-in-JS)
   }
 
   get nodeType() { return ELEMENT_NODE; }
@@ -476,6 +476,16 @@ export class Element extends Node {
     return this.__dataset;
   }
 
+  // CSSOM seam for CSS-in-JS (emotion/styled-components/MUI): a <style> exposes a
+  // CSSStyleSheet so engines can insertRule() at runtime. Created lazily on first
+  // read (only emotion-touched <style>s ever get one), so plain documents pay
+  // nothing. Rules inserted here flow into the cascade via cascade.mjs reading
+  // this.__sheet. Non-<style> elements have no sheet (null), matching the platform.
+  get sheet() {
+    if (this.localName !== 'style') return null;
+    return this.__sheet ?? (this.__sheet = new CSSStyleSheet(this));
+  }
+
   // ---- form-control properties (on the prototype so libraries that read
   //      element.constructor.prototype descriptors — e.g. user-event — find them) ----
   get value() {
@@ -686,7 +696,7 @@ export class Element extends Node {
   // ---- innerHTML / outerHTML ----
   get innerHTML() { return serializeInner(this); }
   set innerHTML(html) {
-    const frag = native.parseFragment(String(html), this.__ns ? `${this.__ns} ${this.localName}` : this.localName);
+    const frag = getParser().parseFragment(String(html), this.__ns ? `${this.__ns} ${this.localName}` : this.localName);
     this.__kids = [];
     this.__touch();
     for (const rawChild of frag.children) {
@@ -715,7 +725,7 @@ export class Element extends Node {
   }
 
   cloneNode(deep = false) {
-    const el = new Element(this.ownerDocument, this.localName, this.__ns);
+    const el = newElement(this.ownerDocument, this.localName, this.__ns);
     el.__attrs = (this.__attrs ?? (this.__attrs = this.__buildAttrs())).map((a) => ({ ...a }));
     if (deep) {
       // build the cloned child array directly — the clone is detached, so per-child
@@ -926,6 +936,46 @@ export class Element extends Node {
 }
 
 
+// ------------------------------------------------------------- SVGElement ----
+// SVG elements expose their geometry/identity attributes as SVGAnimated{String,Length,
+// Rect} objects (el.className.baseVal, rect.width.baseVal.value, svg.viewBox.baseVal),
+// not the plain strings/numbers HTML uses. A real subclass keeps these off every HTML
+// element (zero regression, zero hot-path cost — the wrappers are built on access only).
+// Instantiated by newElement() whenever the namespace is "svg".
+export class SVGElement extends Element {
+  // className is a readonly SVGAnimatedString in the spec; we still allow assigning a
+  // string (common habit) by writing the class attribute, but reads return the wrapper.
+  get className() { return new SVGAnimatedString(this, 'class'); }
+  set className(v) { this.setAttribute('class', String(v)); }
+
+  get viewBox() { return new SVGAnimatedRect(this, 'viewBox'); }
+
+  // Honest geometry stubs (consistent with stubs.mjs — no layout engine, so zeros).
+  getBBox() { return { x: 0, y: 0, width: 0, height: 0 }; }
+  getCTM() { return null; }
+  getScreenCTM() { return null; }
+  get ownerSVGElement() {
+    let p = this.parentNode;
+    while (p && p.nodeType === ELEMENT_NODE) { if (p.localName === 'svg') return p; p = p.parentNode; }
+    return null;
+  }
+}
+// Length-valued geometry attributes → SVGAnimatedLength (built lazily per read).
+for (const attr of SVG_LENGTH_ATTRS) {
+  Object.defineProperty(SVGElement.prototype, attr, {
+    configurable: true,
+    get() { return new SVGAnimatedLength(this, attr); },
+    set(v) { this.setAttribute(attr, v != null && v.baseVal ? String(v.baseVal.value) : String(v)); },
+  });
+}
+
+// Element factory: SVG namespace → SVGElement, everything else → Element. One place so
+// every construction site (buffer inflation, innerHTML, cloneNode, createElementNS) agrees.
+function newElement(doc, tag, ns) {
+  return ns === 'svg' ? new SVGElement(doc, tag, ns) : new Element(doc, tag, ns);
+}
+
+
 // ---------------------------------------------------- DocumentFragment ----
 export class DocumentFragment extends Node {
   get nodeType() { return DOCUMENT_FRAGMENT_NODE; }
@@ -960,7 +1010,7 @@ export class ShadowRoot extends DocumentFragment {
   get nodeName() { return '#document-fragment'; }
   get innerHTML() { return serializeInner(this); }
   set innerHTML(html) {
-    const frag = native.parseFragment(String(html), ''); // empty context → body
+    const frag = getParser().parseFragment(String(html), ''); // empty context → body
     this.__kids = [];
     this.__touch();
     for (const rawChild of frag.children) {
@@ -1464,7 +1514,7 @@ export class Document extends Node {
     switch (nt) {
       case ELEMENT_NODE: {
         const tag = buf.tagName(idx); // read once (was read twice — ctor + template check)
-        node = new Element(this, tag, buf.ns(idx));
+        node = newElement(this, tag, buf.ns(idx));
         node.__idx = idx;
         node.__attrIdx = idx; // attrs lazy (constructor left __attrs undefined)
         // template content fragment: a child node typed 11 named "content"
@@ -1496,7 +1546,7 @@ export class Document extends Node {
     let node;
     switch (raw.nodeType) {
       case ELEMENT_NODE:
-        node = new Element(this, raw.name, raw.namespace || '');
+        node = newElement(this, raw.name, raw.namespace || '');
         node.__attrs = raw.attrs.map((a) => ({ name: a.name, value: a.value, prefix: a.prefix || '' }));
         if (raw.name === 'template') {
           const contentRaw = raw.children.find((c) => c.nodeType === DOCUMENT_FRAGMENT_NODE && c.name === 'content');
@@ -1543,12 +1593,22 @@ export class Document extends Node {
   get activeElement() { return this.__active || this.body || null; }
   __setActive(el) { this.__active = el; }
 
+  // Live StyleSheetList. emotion iterates this to find its own <style>'s sheet by
+  // ownerNode. Touching `.sheet` here lazily creates a CSSStyleSheet per <style>
+  // (test-time only — never on parse/query paths).
+  get styleSheets() {
+    const styles = this.getElementsByTagName('style');
+    const sheets = [];
+    for (let i = 0; i < styles.length; i++) sheets.push(styles[i].sheet);
+    return styleSheetList(sheets);
+  }
+
   // ---- factories (owned nodes, no buffer) ----
   createElement(tag) { return new Element(this, String(tag).toLowerCase(), ''); }
   createElementNS(ns, qualified) {
     const short = ns === SVG_NS ? 'svg' : ns === MATHML_NS ? 'math' : '';
     const local = qualified.includes(':') ? qualified.split(':')[1] : qualified;
-    return new Element(this, local, short);
+    return newElement(this, local, short);
   }
   createTextNode(data) { return new Text(this, String(data)); }
   createComment(data) { return new Comment(this, String(data)); }
@@ -1699,7 +1759,7 @@ export { Event, CustomEvent };
 
 // Parse an HTML string into a fresh Document over the immutable SoA buffer.
 export function parseDocument(html) {
-  const soa = native.parseBuffer(String(html));
+  const soa = getParser().parseBuffer(String(html));
   const doc = new Document();
   doc.__load(soa);
   return doc;

package/src/runtime/index.mjs

@@ -6,17 +6,18 @@
 //   env.reset();                 // Layer 5: cheap per-file reset
 //   env.reset('<body>next</body>');
 
-import { createRequire } from 'node:module';
 import { Document } from './dom.mjs';
 import { createWindow } from './window.mjs';
 import { unpack } from './buffer.mjs';
-
-const require = createRequire(import.meta.url);
-const native = require('../../index.js');
+import { getParser, setParserMode } from './parser.mjs';
 
 export { Document } from './dom.mjs';
 export * from './dom.mjs';
 
+// Parser-selection seam (public API): inject a ready binding for a node-free host,
+// or force 'wasm' | 'native' | 'auto'. See parser.mjs.
+export { setParser, setParserMode, getParser } from './parser.mjs';
+
 // Parse cache: the SoA buffer is READ-ONLY (every mutation goes to a Document's
 // own __kids/__attrs/__cache overlay, never the buffer), so the same buffer can
 // back many Documents. Test suites call setup with the SAME html per file
@@ -34,7 +35,7 @@ function parseBufferCached(html) {
     if (html !== __parseCacheMRU) { __parseCache.delete(html); __parseCache.set(html, hit); __parseCacheMRU = html; }
     return hit;
   }
-  let soa = native.parseBuffer(html);
+  let soa = getParser().parseBuffer(html);
   // Unpack the packed blob into typed-array views ONCE here, not per Document in
   // every Buffer ctor — the views are read-only over the shared immutable buffer,
   // so all Documents backed by this cached soa reuse them (no re-unpack per file).
@@ -65,6 +66,12 @@ function promoteDeclarativeShadowRoots(document) {
 }
 
 export function createEnvironment(html = '<!doctype html><html><head></head><body></body></html>', options = {}) {
+  // Optional parser selection: options.parser === 'wasm' | 'native' | 'auto'. Applied
+  // before the first parse below; process-global (the parser binding is a singleton),
+  // so the last mode set wins. Embedders wanting a fully node-free path inject a
+  // binding via setParser()/globalThis.__TURBO_DOM_PARSER__ instead.
+  if (options.parser) setParserMode(options.parser);
+
   // Layer 1: native parse → immutable SoA buffer (typed arrays, one boundary copy).
   let currentHtml = String(html);
   let soa = parseBufferCached(currentHtml);

package/src/runtime/parser.mjs

@@ -0,0 +1,68 @@
+// Parser binding registry for the whole runtime (dom.mjs, index.mjs).
+//
+// Resolution order, lazily on the FIRST parse (getParser):
+//   1. an explicitly injected binding — setParser(b) or globalThis.__TURBO_DOM_PARSER__.
+//      This is the node-free path: an embedder (e.g. a non-Node V8 host) instantiates
+//      the wasm itself and injects the {parse,parseBuffer,parseFragment} object, so
+//      NONE of the Node loaders below ever run.
+//   2. an explicit mode — setParserMode(m), the `parser` option on createEnvironment,
+//      TURBO_DOM_PARSER env, or globalThis.__TURBO_DOM_PARSER_MODE__:
+//      'wasm' loads pkg/, 'native' loads the prebuilt .node addon.
+//   3. auto (default): native addon first, wasm fallback.
+//
+// node:module is imported via GUARDED top-level await, so this module still LOADS in
+// a bare V8 with no Node builtins — provided a parser is injected before the first
+// parse, the Node `require` loaders are never reached. (Node hosts get it normally.)
+
+let _createRequire;
+try { ({ createRequire: _createRequire } = await import('node:module')); } catch { /* bare V8: parser must be injected */ }
+
+let _parser = null;
+let _mode = null; // 'wasm' | 'native' | 'auto' | null (consult env/global)
+
+function req(spec) {
+  if (!_createRequire) {
+    throw new Error(
+      'turbo-dom: no parser available — node:module is missing (bare V8) and nothing was injected. ' +
+      'Call setParser(binding) (or set globalThis.__TURBO_DOM_PARSER__) before the first parse.',
+    );
+  }
+  return _createRequire(import.meta.url)(spec);
+}
+const loadNative = () => req('../../index.js');
+const loadWasm = () => req('../../pkg/turbo_dom_parser.js');
+
+// Inject a ready parser binding ({parse, parseBuffer, parseFragment}). Pass null to
+// clear it (next getParser re-resolves). The node-free seam for embedders.
+export function setParser(binding) { _parser = binding || null; }
+
+// Force a parser mode: 'wasm' | 'native' | 'auto' (or null to consult env/global).
+// Resets the resolved parser so the next parse honors the new mode.
+export function setParserMode(mode) {
+  _mode = mode || null;
+  _parser = null;
+}
+
+function resolveMode() {
+  if (_mode) return _mode;
+  const g = typeof globalThis !== 'undefined' ? globalThis : {};
+  if (g.__TURBO_DOM_PARSER_MODE__) return g.__TURBO_DOM_PARSER_MODE__;
+  if (typeof process !== 'undefined' && process.env && process.env.TURBO_DOM_PARSER) return process.env.TURBO_DOM_PARSER;
+  return 'auto';
+}
+
+// Resolve (once) and return the active parser binding. Memoized — every call after
+// the first is a single field read, so call sites can use getParser().parseBuffer(…)
+// freely without caching it themselves.
+export function getParser() {
+  if (_parser) return _parser;
+  const g = typeof globalThis !== 'undefined' ? globalThis : {};
+  if (g.__TURBO_DOM_PARSER__) return (_parser = g.__TURBO_DOM_PARSER__);
+  const mode = resolveMode();
+  if (mode === 'wasm') return (_parser = loadWasm());
+  if (mode === 'native') return (_parser = loadNative());
+  // auto: native addon first, wasm fallback; surface the native error if both fail.
+  try { _parser = loadNative(); }
+  catch (nativeErr) { try { _parser = loadWasm(); } catch { throw nativeErr; } }
+  return _parser;
+}

package/src/runtime/svg.mjs

@@ -0,0 +1,70 @@
+// Minimal SVG DOM-property wrappers. SVG IDL attributes are not plain strings/numbers
+// like HTML reflected attributes — they're SVGAnimated{String,Length,Rect} objects with
+// .baseVal / .animVal. Component code (and the libraries that render SVG icons) reads
+// `el.className.baseVal`, `rect.width.baseVal.value`, `svg.viewBox.baseVal`, etc.; without
+// these wrappers those reads throw "Cannot read properties of undefined (reading 'baseVal')".
+//
+// HONEST + LIVE: every wrapper reads/writes the underlying attribute on demand (no cached
+// snapshot), so it always reflects the current attribute and never invents a value. There's
+// no animation engine — animVal === baseVal. Only attached to real SVGElement instances
+// (see dom.mjs), so HTML elements are completely unaffected.
+
+// SVGLength — the unit-bearing value behind an SVGAnimatedLength. valueOf() returns the
+// number so `rect.width.baseVal` used in arithmetic/comparisons coerces correctly, while
+// `rect.width.baseVal.value` reads the same number explicitly.
+export class SVGLength {
+  constructor(host, attr) { this.__host = host; this.__attr = attr; }
+  get value() { const v = parseFloat(this.__host.getAttribute(this.__attr)); return Number.isNaN(v) ? 0 : v; }
+  set value(v) { this.__host.setAttribute(this.__attr, String(v)); }
+  get valueInSpecifiedUnits() { return this.value; }
+  get unitType() { return 1; } // SVG_LENGTHTYPE_NUMBER
+  get valueAsString() { return this.__host.getAttribute(this.__attr) || '0'; }
+  set valueAsString(s) { this.__host.setAttribute(this.__attr, String(s)); }
+  valueOf() { return this.value; }
+  toString() { return this.valueAsString; }
+}
+
+export class SVGAnimatedLength {
+  constructor(host, attr) {
+    const base = new SVGLength(host, attr);
+    this.baseVal = base;
+    this.animVal = base; // no animation engine — animated value tracks the base value
+  }
+}
+
+export class SVGAnimatedString {
+  constructor(host, attr) { this.__host = host; this.__attr = attr; }
+  get baseVal() { return this.__host.getAttribute(this.__attr) || ''; }
+  set baseVal(v) { this.__host.setAttribute(this.__attr, String(v)); }
+  get animVal() { return this.baseVal; }
+}
+
+// SVGRect / SVGAnimatedRect — backs `viewBox`. Parses the four-number list lazily.
+export class SVGRect {
+  constructor(host, attr) { this.__host = host; this.__attr = attr; }
+  #nums() {
+    const raw = this.__host.getAttribute(this.__attr) || '';
+    const parts = raw.split(/[\s,]+/).map(parseFloat);
+    return [parts[0] || 0, parts[1] || 0, parts[2] || 0, parts[3] || 0];
+  }
+  get x() { return this.#nums()[0]; }
+  get y() { return this.#nums()[1]; }
+  get width() { return this.#nums()[2]; }
+  get height() { return this.#nums()[3]; }
+}
+
+export class SVGAnimatedRect {
+  constructor(host, attr) {
+    const base = new SVGRect(host, attr);
+    this.baseVal = base;
+    this.animVal = base;
+  }
+}
+
+// Attributes that surface as SVGAnimatedLength on SVG elements. Covers the common
+// geometry set (shapes, gradients, markers); any not listed still works via getAttribute.
+export const SVG_LENGTH_ATTRS = [
+  'width', 'height', 'x', 'y', 'cx', 'cy', 'r', 'rx', 'ry',
+  'x1', 'y1', 'x2', 'y2', 'dx', 'dy', 'fx', 'fy', 'refX', 'refY',
+  'markerWidth', 'markerHeight', 'startOffset', 'textLength',
+];

package/src/runtime/window.mjs

@@ -11,8 +11,9 @@ import {
   makeLocation, makeHistory,
 } from './stubs.mjs';
 import { makeGetComputedStyle } from './cascade.mjs';
+import { CSSStyleSheet } from './cssom.mjs';
 import {
-  Node, Element, Text, Comment, Document, DocumentFragment, DocumentType, Event, CustomEvent,
+  Node, Element, SVGElement, Text, Comment, Document, DocumentFragment, DocumentType, Event, CustomEvent,
   MutationObserver, DOMParser, XMLSerializer, ShadowRoot,
 } from './dom.mjs';
 import {
@@ -205,16 +206,33 @@ function performanceNow() {
   return nodePerformance.now();
 }
 
+// Resolve the host base classes ONCE, with minimal fallbacks so turbo-dom loads &
+// runs in a bare V8 lacking web-platform globals. Where the platform provides the
+// real class (Node/browser) we extend it and keep full behavior; the fallbacks are
+// only enough to not throw at load and to round-trip the few fields turbo-dom uses.
+// Embedders wanting full URL parsing / Blob semantics should still polyfill the
+// host globals — these are honest minimums, not a spec implementation.
+const URLBase = typeof URL !== 'undefined' ? URL : class URL {
+  constructor(url, base) { this.href = base ? `${base}${url}` : String(url); }
+  toString() { return this.href; }
+  get origin() { return ''; }
+};
+const BlobBase = typeof globalThis.Blob !== 'undefined' ? globalThis.Blob : class Blob {
+  constructor(parts = [], opts = {}) { this.__parts = parts; this.type = opts.type || ''; this.size = 0; }
+  async text() { return (this.__parts || []).join(''); }
+  async arrayBuffer() { return new ArrayBuffer(0); }
+  slice() { return new BlobBase(); }
+};
+
 let __objUrlSeq = 0;
 function makeURL() {
-  class TurboURL extends URL {}
+  class TurboURL extends URLBase {}
   TurboURL.createObjectURL = () => `blob:turbo-dom/${++__objUrlSeq}`;
   TurboURL.revokeObjectURL = () => {};
   return TurboURL;
 }
 function makeFile() {
-  const B = globalThis.Blob;
-  return class File extends B {
+  return class File extends BlobBase {
     constructor(bits = [], name = 'file', opts = {}) { super(bits, opts); this.name = String(name); this.lastModified = opts.lastModified || 0; }
   };
 }
@@ -264,7 +282,7 @@ const STATIC_BASE = {
   DataTransfer,
   // every element is a plain Element → `el instanceof HTMLElement` is true.
   // Tag-specific interfaces match by localName via Symbol.hasInstance.
-  HTMLElement: Element, SVGElement: Element,
+  HTMLElement: Element, SVGElement,
   // SVG interface globals. Libs (and test setup mocks) do
   // `Object.defineProperty(SVGSVGElement.prototype, 'viewBox', …)` and
   // `el instanceof SVGSVGElement`; an undefined global is a hard ReferenceError.
@@ -317,9 +335,9 @@ const STATIC_BASE = {
   HTMLDataElement: tagClass('data'), HTMLTimeElement: tagClass('time'),
   HTMLSlotElement: tagClass('slot'), HTMLMenuElement: tagClass('menu'),
   HTMLDocument: Document,
-  MutationObserver, DOMParser, XMLSerializer,
-  URL: TURBO_URL, URLSearchParams,
-  Blob: globalThis.Blob, File: TURBO_FILE, FileReader,
+  MutationObserver, DOMParser, XMLSerializer, CSSStyleSheet,
+  URL: TURBO_URL, URLSearchParams: typeof URLSearchParams !== 'undefined' ? URLSearchParams : undefined,
+  Blob: BlobBase, File: TURBO_FILE, FileReader,
   AbortController: globalThis.AbortController, AbortSignal: globalThis.AbortSignal,
   TextEncoder: globalThis.TextEncoder, TextDecoder: globalThis.TextDecoder,
   fetch: globalThis.fetch ? (...a) => globalThis.fetch(...a) : undefined,