@preference-sl/pref-configurator-sdk 0.1.2-beta.2 → 0.2.0-beta.1

package/js/sdk-init.js

@@ -0,0 +1,227 @@
+// PrefConfigurator WASM SDK — main-thread entry.
+//
+// init(env, opts?) spawns sdk-worker.js as a module Worker and returns a Proxy that
+// forwards every method call to the worker over postMessage. The Proxy mirrors
+// BoundApi<JsInteropApiRaw> from prefconfigurator-api.d.ts: it stringifies object
+// args for the methods that need it and unwraps OperationResult<T> via ensureOk.
+//
+// All bundler-aware URL resolution lives here in the main thread, never in the
+// worker — Next.js + webpack 5 does not reliably bundle a worker chunk's transitive
+// imports, so the worker is kept leaf and we hand it pre-resolved URLs over the init
+// message. See docs/wasm-worker-init.md.
+
+import { ensureOk } from "./prefconfigurator-api.js";
+import { FRAMEWORK_ASSETS } from "./sdk-framework-assets.js";
+
+// new URL(literal, import.meta.url) is the bundler-recognized pattern; webpack 5 / Vite /
+// esbuild rewrite each of these into asset emits and substitute the runtime URL. Any
+// expression chained off the URL (e.g. .href) defeats the AST matcher in webpack 5,
+// so we keep these expressions unchained and call String(...) at the use site below.
+//
+// We coerce with String(...) (not .href) because webpack 5 may produce URL-like wrappers
+// whose .href is a getter that returns the URL instance itself or otherwise carries
+// non-cloneable own properties. String(...) goes through .toString() which is guaranteed
+// to return a primitive string and survives postMessage's structured clone.
+const GLTF_STORAGE_URL = new URL("./gltf-storage.js", import.meta.url);
+const GLTF_MERGER_URL = new URL("./gltf-merger.js", import.meta.url);
+const PREF_GLTF_MERGER_WASM_URL = new URL("./PrefGltfMergerWasm.js", import.meta.url);
+// PrefGltfMergerWasm.js is an Emscripten module that loads its companion .wasm
+// at runtime via Module.locateFile. We MUST also resolve the .wasm here so the
+// bundler emits both files; without this declaration webpack/Vite/etc. ignore
+// the .wasm and Emscripten's default sibling-by-name lookup gets a 404 because
+// the consumer's bundler hashed the .js to a different filename. The worker then
+// passes both URLs to gltf-merger.js so locateFile can return the right one.
+const PREF_GLTF_MERGER_WASM_BIN_URL = new URL("./PrefGltfMergerWasm.wasm", import.meta.url);
+
+// Per-method arg adapters: equivalent to the typed shims in prefconfigurator-api.ts
+// that today only exist in the .ts and not in the runtime .js, forcing consumers to
+// reimplement them. Centralizing them here means npm consumers get the typed DX
+// without a custom Proxy on their side.
+const ARG_ADAPTERS = {
+    UpdateOptions: ([optionList, changedOptionNames]) => [
+        JSON.stringify(optionList),
+        JSON.stringify(changedOptionNames ?? []),
+    ],
+    SetDimensions: ([modelId, updates]) => [modelId, JSON.stringify(updates)],
+    SetOptions: ([modelId, updates]) => [modelId, JSON.stringify(updates)],
+    GetModelImage: ([modelId, config, sceneName, optionList]) => [
+        modelId,
+        JSON.stringify(config),
+        sceneName ?? null,
+        optionList != null ? JSON.stringify(optionList) : null,
+    ],
+    GetUsdImages: ([request, optionList]) => [
+        JSON.stringify(request),
+        optionList != null ? JSON.stringify(optionList) : null,
+    ],
+    GetUsdImagesHcStatus: ([request, optionList]) => [
+        JSON.stringify(request),
+        JSON.stringify(optionList ?? null),
+    ],
+    GetModelImageHcStatus: ([modelId, config]) => [modelId, JSON.stringify(config)],
+};
+
+// InitializeFromEnvJson is implicit — init() runs it during boot and the Proxy hides it.
+const HIDDEN_METHODS = new Set(["InitializeFromEnvJson"]);
+
+// String properties that must NOT be intercepted as remote method calls.
+//
+// The Promise resolution algorithm probes any returned value for `then` to
+// decide whether it is a thenable; if our Proxy returns a function for `then`,
+// JavaScript will call it with native (resolve, reject) callbacks, which are
+// not structured-cloneable and crash postMessage with DataCloneError. Returning
+// undefined makes the Proxy look like a plain object to the Promise machinery.
+//
+// `catch` / `finally` are kept here for the same reason in long Promise chains.
+// `__esModule` is webpack's interop marker — if our Proxy returned an async
+// function for it, dynamic imports could mis-classify the module.
+//
+// All Symbol-keyed probes (Symbol.toPrimitive / Symbol.iterator / Symbol.asyncIterator
+// / Symbol.toStringTag / Symbol.dispose / etc.) are filtered earlier by the
+// `typeof prop === "symbol"` check in the get trap, so they don't appear here.
+const NON_REMOTE_KEYS = new Set([
+    "then",
+    "catch",
+    "finally",
+    "constructor",
+    "toJSON",
+    "toString",
+    "valueOf",
+    "__esModule",
+]);
+
+function rebuildError(serialized) {
+    const message = serialized?.message ?? "Unknown SDK error";
+    const err = new Error(message);
+    if (serialized?.name) err.name = serialized.name;
+    if (serialized?.stack) err.stack = serialized.stack;
+    if (serialized?.code !== undefined) err.code = serialized.code;
+    if (serialized?.source !== undefined) err.source = serialized.source;
+    if (serialized?.httpStatus !== undefined) err.httpStatus = serialized.httpStatus;
+    if (serialized?.requestId !== undefined) err.requestId = serialized.requestId;
+    if (serialized?.correlationId !== undefined) err.correlationId = serialized.correlationId;
+    if (serialized?.traceParent !== undefined) err.traceParent = serialized.traceParent;
+    if (serialized?.detail !== undefined) err.detail = serialized.detail;
+    if (serialized?.callId !== undefined) err.callId = serialized.callId;
+    if (serialized?.result !== undefined) err.result = serialized.result;
+    return err;
+}
+
+function makeRpc(worker) {
+    let nextId = 1;
+    const pending = new Map();
+    let terminated = false;
+
+    worker.addEventListener("message", (ev) => {
+        const msg = ev?.data;
+        if (!msg || typeof msg !== "object" || msg.id === undefined) return;
+        const ctl = pending.get(msg.id);
+        if (!ctl) return;
+        pending.delete(msg.id);
+        if (msg.type === "result" || msg.type === "init-result") ctl.resolve(msg);
+        else if (msg.type === "error" || msg.type === "init-error") ctl.reject(rebuildError(msg.error));
+    });
+
+    worker.addEventListener("error", (ev) => {
+        const err = new Error(ev?.message ?? "PrefConfigurator worker crashed");
+        for (const ctl of pending.values()) ctl.reject(err);
+        pending.clear();
+    });
+
+    function send(message) {
+        if (terminated) return Promise.reject(new Error("PrefConfigurator SDK has been disposed."));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            worker.postMessage({ ...message, id });
+        });
+    }
+
+    function dispose() {
+        terminated = true;
+        const err = new Error("PrefConfigurator SDK has been disposed.");
+        for (const ctl of pending.values()) ctl.reject(err);
+        pending.clear();
+        worker.terminate();
+    }
+
+    return { send, dispose };
+}
+
+/**
+ * Boots the SDK runtime in a Web Worker and returns a proxy that mirrors the
+ * BoundApi shape exported by the SDK's TypeScript declarations.
+ *
+ * @param {object|string} env  EnvJson object (or pre-serialized JSON string).
+ * @param {object} [opts]
+ * @param {URL|string} [opts.workerUrl]     Override the worker URL (tests, custom hosting).
+ * @param {boolean} [opts.diagnosticTracing] Forwarded to dotnet.withDiagnosticTracing.
+ * @returns {Promise<object>} a proxy whose methods unwrap OperationResult<T> via ensureOk.
+ */
+export async function init(env, opts) {
+    if (typeof Worker === "undefined") {
+        throw new Error("PrefConfigurator SDK requires a browser/worker environment with Worker support.");
+    }
+    const options = opts ?? {};
+    const workerUrl = options.workerUrl ?? new URL("./sdk-worker.js", import.meta.url);
+    const worker = new Worker(workerUrl, { type: "module" });
+    const rpc = makeRpc(worker);
+
+    const envJson = typeof env === "string" ? env : JSON.stringify(env);
+
+    // Build a plain { name: string } map. We force each value through String(...) and
+    // copy with Object.assign-style key iteration so the postMessage clone never sees a
+    // URL instance, a webpack wrapper, a getter, or any non-cloneable native function.
+    const frameworkAssets = {};
+    for (const name of Object.keys(FRAMEWORK_ASSETS)) {
+        frameworkAssets[name] = String(FRAMEWORK_ASSETS[name]);
+    }
+
+    try {
+        await rpc.send({
+            type: "init",
+            envJson,
+            diagnosticTracing: !!options.diagnosticTracing,
+            frameworkAssets,
+            gltfStorageUrl: String(GLTF_STORAGE_URL),
+            gltfMergerUrl: String(GLTF_MERGER_URL),
+            prefGltfMergerWasmUrl: String(PREF_GLTF_MERGER_WASM_URL),
+            prefGltfMergerWasmBinUrl: String(PREF_GLTF_MERGER_WASM_BIN_URL),
+        });
+    } catch (err) {
+        rpc.dispose();
+        throw err;
+    }
+
+    const proxy = new Proxy(
+        {},
+        {
+            get(_target, prop) {
+                if (prop === "dispose" || prop === "terminate" || prop === Symbol.dispose) {
+                    return () => rpc.dispose();
+                }
+                // Hide thenable / iterator / serialization probes from the Promise and
+                // host runtimes — see NON_REMOTE_KEYS for the rationale.
+                if (typeof prop === "symbol") return undefined;
+                if (NON_REMOTE_KEYS.has(prop)) return undefined;
+                if (typeof prop !== "string") return undefined;
+                if (HIDDEN_METHODS.has(prop)) {
+                    return () => {
+                        throw new Error(
+                            `${prop} is invoked implicitly by init() and is not callable on the SDK proxy.`,
+                        );
+                    };
+                }
+
+                return async (...args) => {
+                    const adapter = ARG_ADAPTERS[prop];
+                    const finalArgs = adapter ? adapter(args) : args;
+                    const res = await rpc.send({ type: "call", method: prop, args: finalArgs });
+                    return ensureOk(res.value);
+                };
+            },
+        },
+    );
+
+    return proxy;
+}

package/js/sdk-worker.d.ts

@@ -0,0 +1,3 @@
+// Worker entry has no public exports — it communicates exclusively via postMessage.
+// This stub keeps TypeScript consumers happy when the file ships next to typed modules.
+export {};

package/js/sdk-worker.js

@@ -0,0 +1,138 @@
+// PrefConfigurator WASM SDK — Web Worker entry.
+//
+// This module is intentionally LEAF: it has no static imports of SDK assets. The main
+// thread (sdk-init.js) resolves every bundler-emitted URL with new URL(literal,
+// import.meta.url), pushes the resulting map down via the init message, and the worker
+// dynamic-imports each one at runtime. Keeping the worker leaf lets bundlers (webpack 5,
+// Vite, esbuild, Rollup) treat sdk-worker.js as a self-contained file: they don't have
+// to follow imports across the worker boundary, which Next.js + webpack 5 in particular
+// does not do reliably as of 16.x.
+
+let api = null;
+let bootPromise = null;
+
+async function bootDotnet({ envJson, diagnosticTracing, frameworkAssets, gltfStorageUrl, gltfMergerUrl, prefGltfMergerWasmUrl, prefGltfMergerWasmBinUrl }) {
+    const dotnetUrl = frameworkAssets["dotnet.js"];
+    if (!dotnetUrl) throw new Error("Framework asset manifest missing 'dotnet.js'.");
+
+    // gltf-merger.js consults these globals to locate its Emscripten module at runtime:
+    //   __PREF_GLTF_MERGER_WASM_PATH     → URL of PrefGltfMergerWasm.js (the loader)
+    //   __PREF_GLTF_MERGER_WASM_BIN_PATH → URL of PrefGltfMergerWasm.wasm (the binary)
+    // Both are needed because the consumer's bundler hashes them independently and
+    // Emscripten's default sibling-by-filename lookup fails when the hashes differ.
+    self.__PREF_GLTF_MERGER_WASM_PATH = prefGltfMergerWasmUrl;
+    self.__PREF_GLTF_MERGER_WASM_BIN_PATH = prefGltfMergerWasmBinUrl;
+
+    // All three URLs (dotnet, gltf-storage, gltf-merger) are already resolved by the
+    // consumer's bundler at build time. webpackIgnore / @vite-ignore keep both bundlers
+    // from re-analyzing these dynamic imports.
+    const dotnetMod = await import(/* @vite-ignore */ /* webpackIgnore: true */ dotnetUrl);
+    const dotnet = dotnetMod.dotnet ?? dotnetMod.default?.dotnet ?? dotnetMod.default;
+    if (!dotnet) throw new Error("dotnet.js loaded but its 'dotnet' export is missing.");
+
+    const builder = dotnet
+        .withResourceLoader((_type, name, defaultUri /*, _hash, _behavior */) => {
+            const url = frameworkAssets[name];
+            return url ?? defaultUri;
+        })
+        .withApplicationArguments("start");
+
+    if (diagnosticTracing) builder.withDiagnosticTracing(true);
+
+    const runtime = await builder.create();
+    const { getConfig, getAssemblyExports, setModuleImports, runMain } = runtime;
+    if (typeof setModuleImports !== "function") {
+        throw new Error("dotnet runtime does not expose setModuleImports — required by the SDK.");
+    }
+
+    // Register [JSImport] target modules. Replaces JSHost.ImportAsync from the C# side.
+    const [gltfStorage, gltfMerger] = await Promise.all([
+        import(/* @vite-ignore */ /* webpackIgnore: true */ gltfStorageUrl),
+        import(/* @vite-ignore */ /* webpackIgnore: true */ gltfMergerUrl),
+    ]);
+    setModuleImports("gltf-storage", gltfStorage);
+    setModuleImports("gltf-merger", gltfMerger);
+
+    const cfg = getConfig();
+    const mainAssembly = cfg.mainAssemblyName;
+    if (!mainAssembly) throw new Error("dotnet.js config missing mainAssemblyName.");
+
+    const exportsAsm = await getAssemblyExports(mainAssembly);
+    const ns = exportsAsm?.PrefConfigurator?.Wasm?.JsInteropApi;
+    if (!ns) throw new Error("PrefConfigurator.Wasm.JsInteropApi is not exported by the assembly.");
+    api = ns;
+
+    await api.InitializeFromEnvJson(envJson);
+
+    // Fire Program.Main() so JsInteropApi.Initialize(host.Services) sets _services and
+    // the long-running host.RunAsync stays alive. Yield once so its synchronous prologue
+    // completes before the main thread starts dispatching calls.
+    void runMain();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function serializeError(err) {
+    if (err && typeof err === "object") {
+        return {
+            name: err.name ?? "Error",
+            message: err.message ?? String(err),
+            stack: err.stack,
+            // Custom fields populated by ensureOk on the main side; pass them through so
+            // the rebuilt Error keeps its diagnostic shape.
+            code: err.code,
+            source: err.source,
+            httpStatus: err.httpStatus,
+            requestId: err.requestId,
+            correlationId: err.correlationId,
+            traceParent: err.traceParent,
+            detail: err.detail,
+            callId: err.callId,
+            result: err.result,
+        };
+    }
+    return { name: "Error", message: String(err) };
+}
+
+self.addEventListener("message", async (ev) => {
+    const msg = ev?.data;
+    if (!msg || typeof msg !== "object") return;
+
+    if (msg.type === "init") {
+        try {
+            if (!bootPromise) bootPromise = bootDotnet(msg);
+            await bootPromise;
+            const methods = Object.keys(api).filter((k) => typeof api[k] === "function");
+            self.postMessage({ id: msg.id, type: "init-result", methods });
+        } catch (err) {
+            bootPromise = null;
+            self.postMessage({ id: msg.id, type: "init-error", error: serializeError(err) });
+        }
+        return;
+    }
+
+    if (msg.type === "call") {
+        if (!api) {
+            self.postMessage({
+                id: msg.id,
+                type: "error",
+                error: serializeError(new Error("PrefConfigurator SDK is not initialized.")),
+            });
+            return;
+        }
+        const fn = api[msg.method];
+        if (typeof fn !== "function") {
+            self.postMessage({
+                id: msg.id,
+                type: "error",
+                error: serializeError(new Error(`Unknown SDK method: ${msg.method}`)),
+            });
+            return;
+        }
+        try {
+            const value = await fn(...(msg.args ?? []));
+            self.postMessage({ id: msg.id, type: "result", value });
+        } catch (err) {
+            self.postMessage({ id: msg.id, type: "error", error: serializeError(err) });
+        }
+    }
+});

package/package.json

@@ -1,7 +1,36 @@
 {
+  "version": "0.2.0-beta.1",
+  "name": "@preference-sl/pref-configurator-sdk",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    "./js/prefconfigurator-api": {
+      "types": "./js/prefconfigurator-api.d.ts",
+      "default": "./js/prefconfigurator-api.js"
+    },
+    "./js/sdk-init": {
+      "types": "./js/sdk-init.d.ts",
+      "default": "./js/sdk-init.js"
+    },
+    "./js/sdk-worker": "./js/sdk-worker.js",
+    "./index.html": "./index.html",
+    "./js/*": {
+      "types": "./js/*.d.ts",
+      "default": "./js/*.js"
+    },
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./_framework/*": "./_framework/*"
+  },
+  "private": false,
+  "types": "index.d.ts",
+  "module": "index.js",
   "description": ".NET WebAssembly SDK that embeds Preference's business logic for building product configurators (windows, doors, joinery) in browser-based ecommerce platforms.",
-  "main": "main.js",
-  "version": "0.1.2-beta.2",
+  "author": "Alex Moreno Palacio <amoreno@preference.es>",
+  "sideEffects": false,
   "files": [
     "_framework/**",
     "**/*.js",
@@ -10,24 +39,5 @@
     "index.html",
     "README.md"
   ],
-  "license": "MIT",
-  "private": false,
-  "name": "@preference-sl/pref-configurator-sdk",
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js"
-  },
-  "author": "Alex Moreno Palacio <amoreno@preference.es>",
-  "exports": {
-    ".": {
-      "types": "./main.d.ts",
-      "default": "./main.js"
-    },
-    "./package.json": "./package.json",
-    "./index.html": "./index.html",
-    "./js/prefconfigurator-api": {
-      "types": "./js/prefconfigurator-api.d.ts",
-      "default": "./js/prefconfigurator-api.js"
-    }
-  },
-  "types": "main.d.ts"
+  "type": "module"
 }

package/main.d.ts

@@ -1,4 +0,0 @@
-declare const runtimeInfo: {
-  frameworkPath: string;
-};
-export = runtimeInfo;

package/main.js

@@ -1,2 +0,0 @@
-const path = require("path");
-module.exports = { frameworkPath: path.join(__dirname, "_framework") };

package/scripts/postinstall.js

@@ -1,128 +0,0 @@
-"use strict";
-/* eslint-disable no-console */
-const fs = require("fs");
-const path = require("path");
-
-/* ---------- utils ---------- */
-function walk(root, cb) {
-    const st = [root];
-    while (st.length) {
-        const d = st.pop();
-        let entries;
-        try { entries = fs.readdirSync(d, { withFileTypes: true }); }
-        catch { continue; }
-        for (const e of entries) {
-            const abs = path.join(d, e.name);
-            if (e.isDirectory()) st.push(abs);
-            else if (e.isFile()) cb(abs);
-        }
-    }
-}
-
-function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
-function ensureDirForFile(filePath) { ensureDir(path.dirname(filePath)); }
-
-function rmrf(p) {
-    try { fs.rmSync(p, { recursive: true, force: true }); } catch { }
-}
-
-function copyDirRecursive(src, dst) {
-    if (!fs.existsSync(src)) return;
-    ensureDir(dst);
-    for (const e of fs.readdirSync(src, { withFileTypes: true })) {
-        const s = path.join(src, e.name);
-        const d = path.join(dst, e.name);
-        if (e.isDirectory()) copyDirRecursive(s, d);
-        else if (e.isFile()) fs.copyFileSync(s, d);
-    }
-}
-
-function resolvePackageName(pkgRoot) {
-    if (process.env.npm_package_name) {
-        return String(process.env.npm_package_name).replace(/^@[^/]+\//, "").toLowerCase();
-    }
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
-        if (pkg && pkg.name) return String(pkg.name).replace(/^@[^/]+\//, "").toLowerCase();
-    } catch { }
-    try { return path.basename(pkgRoot).toLowerCase(); } catch { }
-    return "package";
-}
-
-/* ---------- main ---------- */
-try {
-    // package root (we are in .../scripts)
-    const pkgRoot = path.resolve(__dirname, "..");
-    const pkgName = resolvePackageName(pkgRoot);
-
-    const srcFramework = path.join(pkgRoot, "_framework");
-    const srcMain = path.join(pkgRoot, "main.js");
-    const srcIndex = path.join(pkgRoot, "index.html");
-
-    // consumer public dir
-    const consumerRoot = process.env.INIT_CWD || process.env.npm_config_local_prefix || process.cwd();
-    const candidates = [process.env.PUBLIC_DIR, "public", "wwwroot", path.join("src", "assets")].filter(Boolean);
-
-    let targetPublic = null;
-    for (const c of candidates) {
-        const abs = path.isAbsolute(c) ? c : path.resolve(consumerRoot, c);
-        if (fs.existsSync(abs)) { targetPublic = abs; break; }
-    }
-    if (!targetPublic) targetPublic = path.resolve(consumerRoot, "public");
-
-    const ns = "preference-sl";
-    const destRoot = path.join(targetPublic, ns, pkgName);
-
-    // ALWAYS start fresh: remove destination completely
-    rmrf(destRoot);
-    ensureDir(destRoot);
-
-    // 1) Copy runtime (_framework) — overwrite
-    const wasmSubdir = process.env.WASM_SUBDIR || "_framework";
-    const destFramework = path.join(destRoot, wasmSubdir);
-    copyDirRecursive(srcFramework, destFramework);
-    console.log(`[${pkgName}] Copied WASM → ${destFramework}`);
-
-    // 2) main.js — overwrite
-    if (fs.existsSync(srcMain)) {
-        const destMain = path.join(destRoot, "main.js");
-        ensureDirForFile(destMain);
-        fs.copyFileSync(srcMain, destMain);
-        console.log(`[${pkgName}] Installed main.js at ${destMain}`);
-    }
-
-    // 3) index.html → index.demo.html — overwrite
-    if (fs.existsSync(srcIndex)) {
-        const destDemo = path.join(destRoot, "index.demo.html");
-        ensureDirForFile(destDemo);
-        fs.copyFileSync(srcIndex, destDemo);
-        console.log(`[${pkgName}] Installed index.demo.html at ${destDemo}`);
-    }
-
-    // 4) Extra JS / WASM / source maps outside _framework — overwrite
-    //    Includes PrefGltfMergerWasm.js and .wasm so the consumer doesn't need
-    //    a separate npm package for the GLTF merger.
-    console.log(`[${pkgName}] Copying extra JS/WASM → ${destRoot}`);
-    const frameworkRoot = path.resolve(path.join(pkgRoot, "_framework"));
-    const exclude = new Set([
-        path.resolve(path.join(pkgRoot, "scripts", "postinstall.js")),
-    ]);
-    // Source maps and symbols are intentionally not shipped (see Pack-Wasm.ps1).
-    const copyableExtensions = [".js", ".d.ts", ".wasm"];
-
-    walk(pkgRoot, (abs0) => {
-        const abs = path.resolve(abs0);
-        const lower = abs.toLowerCase();
-        if (!copyableExtensions.some((ext) => lower.endsWith(ext))) return;
-        if (abs.startsWith(frameworkRoot)) return;        // skip _framework
-        if (exclude.has(abs)) return;                     // skip postinstall itself
-
-        const rel = path.relative(pkgRoot, abs);          // e.g., "js/foo.js" or "js/PrefGltfMergerWasm.wasm"
-        const dest = path.join(destRoot, rel);
-        ensureDirForFile(dest);
-        fs.copyFileSync(abs, dest);                       // OVERWRITE
-    });
-
-} catch (err) {
-    console.warn(`[postinstall] Warning: copy failed: ${err && (err.message || err)}`);
-}