@cfasim-ui/wasm 0.8.13 → 0.8.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfasim-ui/wasm",
-  "version": "0.8.13",
+  "version": "0.8.15",
   "type": "module",
   "description": "WebAssembly integration for cfasim-ui",
   "license": "Apache-2.0",
@@ -20,7 +20,7 @@
     "./vite": "./src/vitePlugin.js"
   },
   "dependencies": {
-    "@cfasim-ui/shared": "0.8.13"
+    "@cfasim-ui/shared": "0.8.15"
   },
   "peerDependencies": {
     "vue": "^3.5.0"

package/src/vitePlugin.js

@@ -1,4 +1,6 @@
 import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { basename, resolve } from "node:path";
 
 /**
@@ -7,10 +9,35 @@ import { basename, resolve } from "node:path";
  * @property {string} [name] Output name used for the wasm module (default: project directory name)
  */
 
+/** Global injected via Vite `define`; the worker appends it as `?v=` to wasm URLs. */
+export const WASM_VERSIONS_DEFINE = "__CFASIM_WASM_VERSIONS__";
+
+/**
+ * Hash the wasm-pack output for a model so its URLs change whenever the
+ * compiled module or its JS glue changes. Both are served from fixed paths
+ * under public/, so without this a CDN or browser cache can pair a new app
+ * bundle with a stale wasm build.
+ *
+ * @param {string} outDir wasm-pack output directory
+ * @param {string} name wasm module name
+ * @returns {string} 12 hex chars of sha256 over `<name>_bg.wasm` + `<name>.js`
+ */
+export function hashWasmOutput(outDir, name) {
+  const hash = createHash("sha256");
+  for (const file of [`${name}_bg.wasm`, `${name}.js`]) {
+    hash.update(readFileSync(resolve(outDir, file)));
+  }
+  return hash.digest("hex").slice(0, 12);
+}
+
 /**
  * Vite plugin that builds a Rust model to WebAssembly via wasm-pack
  * and outputs it to public/wasm/{name}/.
  *
+ * The build runs in the `config` hook so the output hash can be exposed to
+ * the app through `define` as `__CFASIM_WASM_VERSIONS__` (a map of model
+ * name to hash). Several instances merge into the same map.
+ *
  * @param {CfasimWasmOptions} [options]
  * @returns {import("vite").Plugin}
  */
@@ -24,12 +51,19 @@ export function cfasimWasm(options) {
       cwd: root,
       stdio: "pipe",
     });
+    return { name, version: hashWasmOutput(outDir, name) };
   }
 
   return {
     name: "cfasim-wasm",
-    configResolved(config) {
-      build(config.root);
+    config(userConfig) {
+      // Mirrors Vite's own root resolution, which has not happened yet.
+      const root = userConfig.root ? resolve(userConfig.root) : process.cwd();
+      const { name, version } = build(root);
+      const existing = userConfig.define?.[WASM_VERSIONS_DEFINE];
+      const versions = typeof existing === "string" ? JSON.parse(existing) : {};
+      versions[name] = version;
+      return { define: { [WASM_VERSIONS_DEFINE]: JSON.stringify(versions) } };
     },
   };
 }

package/src/vitePlugin.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import {
+  cfasimWasm,
+  hashWasmOutput,
+  WASM_VERSIONS_DEFINE,
+} from "./vitePlugin.js";
+
+vi.mock("node:child_process", () => ({ execSync: vi.fn() }));
+
+let root: string;
+
+function writeOutput(name: string, wasm: string, js: string) {
+  const dir = resolve(root, "public", "wasm", name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(resolve(dir, `${name}_bg.wasm`), wasm);
+  writeFileSync(resolve(dir, `${name}.js`), js);
+  return dir;
+}
+
+function runConfig(
+  plugin: ReturnType<typeof cfasimWasm>,
+  userConfig: Record<string, unknown>,
+): Record<string, string> {
+  const hook = plugin.config as (c: unknown) => {
+    define: Record<string, string>;
+  };
+  return JSON.parse(hook(userConfig).define[WASM_VERSIONS_DEFINE]);
+}
+
+beforeEach(() => {
+  root = mkdtempSync(resolve(tmpdir(), "cfasim-wasm-"));
+  vi.mocked(execSync).mockClear();
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("hashWasmOutput", () => {
+  it("changes when either the wasm or the glue changes", () => {
+    const dir = writeOutput("m", "wasm-a", "js-a");
+    const base = hashWasmOutput(dir, "m");
+    expect(base).toMatch(/^[0-9a-f]{12}$/);
+    expect(hashWasmOutput(dir, "m")).toBe(base);
+
+    writeOutput("m", "wasm-b", "js-a");
+    const wasmChanged = hashWasmOutput(dir, "m");
+    expect(wasmChanged).not.toBe(base);
+
+    writeOutput("m", "wasm-b", "js-b");
+    expect(hashWasmOutput(dir, "m")).not.toBe(wasmChanged);
+  });
+});
+
+describe("cfasimWasm", () => {
+  it("builds with wasm-pack and defines the output hash by model name", () => {
+    const dir = writeOutput("my_sim", "wasm", "js");
+    const versions = runConfig(cfasimWasm({ model: "..", name: "my-sim" }), {
+      root,
+    });
+    expect(versions).toEqual({ my_sim: hashWasmOutput(dir, "my_sim") });
+    expect(execSync).toHaveBeenCalledWith(
+      `wasm-pack build .. --target web --out-dir ${dir}`,
+      expect.objectContaining({ cwd: root }),
+    );
+  });
+
+  it("merges into a versions map defined by an earlier instance", () => {
+    const a = writeOutput("a", "wasm-a", "js-a");
+    const b = writeOutput("b", "wasm-b", "js-b");
+    const first = runConfig(cfasimWasm({ name: "a" }), { root });
+    const second = runConfig(cfasimWasm({ name: "b" }), {
+      root,
+      define: { [WASM_VERSIONS_DEFINE]: JSON.stringify(first) },
+    });
+    expect(second).toEqual({
+      a: hashWasmOutput(a, "a"),
+      b: hashWasmOutput(b, "b"),
+    });
+  });
+});

package/src/wasm.worker.ts

@@ -10,13 +10,31 @@ const modulePromises = new Map<string, Promise<Record<string, any>>>();
 
 const baseUrl = import.meta.env.BASE_URL ?? "/";
 
+// Injected by the `cfasimWasm` Vite plugin (model name -> hash of the
+// wasm-pack output). Absent when an app ships prebuilt wasm without it.
+declare const __CFASIM_WASM_VERSIONS__: Record<string, string> | undefined;
+
+function wasmVersion(model: string): string | undefined {
+  if (typeof __CFASIM_WASM_VERSIONS__ === "undefined") return undefined;
+  return __CFASIM_WASM_VERSIONS__?.[model];
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function ensureModule(model: string): Promise<Record<string, any>> {
   if (!modulePromises.has(model)) {
     const promise = (async () => {
-      const url = `${self.location.origin}${baseUrl}wasm/${model}/${model}.js`;
-      const mod = await import(/* @vite-ignore */ url);
-      await mod.default();
+      const dir = `${self.location.origin}${baseUrl}wasm/${model}/`;
+      const version = wasmVersion(model);
+      const query = version ? `?v=${version}` : "";
+      const mod = await import(/* @vite-ignore */ `${dir}${model}.js${query}`);
+      // The glue resolves `<model>_bg.wasm` against its own URL, which drops
+      // the query, so the wasm path is passed explicitly when versioned.
+      // The object form needs wasm-bindgen >= 0.2.93.
+      if (version) {
+        await mod.default({ module_or_path: `${dir}${model}_bg.wasm${query}` });
+      } else {
+        await mod.default();
+      }
       return mod;
     })();
     promise.catch(() => {