nanocodex-vite 0.6.0

package/scripts/wasm-memory-views.mjs

@@ -0,0 +1,39 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Normalize wasm-bindgen's byte views without changing the Rust/WASM ABI. */
+export function rewriteWasmMemoryViews(source) {
+  // V8 subarray() checks its begin offset against the embedder's maximum
+  // ArrayBuffer allocation (128 MiB on Cloudflare). WASM memory.grow can exceed
+  // that address, so even a tiny, valid string then throws RangeError. A direct
+  // view checks the requested length and the actual memory bounds instead.
+  const replacements = [
+    ["getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len)",
+      "new Uint8Array(wasm.memory.buffer, ptr, len)"],
+    ["getUint8ArrayMemory0().subarray(ptr, ptr + len)",
+      "new Uint8Array(wasm.memory.buffer, ptr, len)"],
+    ["getUint8ArrayMemory0().subarray(ptr, ptr + buf.length)",
+      "new Uint8Array(wasm.memory.buffer, ptr, buf.length)"],
+    ["getUint8ArrayMemory0().subarray(ptr + offset, ptr + len)",
+      "new Uint8Array(wasm.memory.buffer, ptr + offset, len - offset)"],
+  ];
+  for (const [before, after] of replacements) {
+    if (source.split(before).length !== 2) {
+      throw new Error(`unsupported wasm-bindgen memory view: expected exactly one ${before}`);
+    }
+    source = source.replace(before, after);
+  }
+  if (source.includes("getUint8ArrayMemory0().subarray(")) {
+    throw new Error("unsupported wasm-bindgen memory view remains");
+  }
+  return source;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const paths = process.argv.slice(2);
+  if (paths.length === 0) throw new Error("expected generated wasm-bindgen JavaScript paths");
+  // Validate all targets before writing any, so generator drift fails the build.
+  const outputs = await Promise.all(paths.map(async (path) => [path, rewriteWasmMemoryViews(await readFile(path, "utf8"))]));
+  await Promise.all(outputs.map(([path, source]) => writeFile(path, source)));
+}

package/tools.d.mts

@@ -0,0 +1,8 @@
+export type NanocodexToolsVitePlugin = Readonly<{
+  name: "nanocodex-tools";
+  enforce: "pre";
+  resolveId(source: string, importer?: string): string | null;
+}>;
+
+/** Keeps unreachable Node-only SSH fallbacks out of browser and Worker bundles. */
+export function nanocodexTools(): NanocodexToolsVitePlugin;

package/tools.mjs

@@ -0,0 +1,38 @@
+import { fileURLToPath } from "node:url";
+
+const browserTools = new URL(import.meta.resolve("nanocodex/tools/browser"));
+const browserSsh = fileURLToPath(
+  new URL("./devTunnelsSshBrowser.mjs", browserTools),
+);
+const unsupportedNodeRsa = fileURLToPath(
+  new URL("./unsupportedNodeRsa.mjs", browserTools),
+);
+const browserSprintf = fileURLToPath(
+  new URL("./browserSprintf.mjs", browserTools),
+);
+const browserZlib = fileURLToPath(
+  new URL("./browserZlib.mjs", browserTools),
+);
+
+/**
+ * Keeps unreachable Node-only SSH fallbacks out of browser and Worker bundles.
+ * Add this before framework plugins so nested Worker builds inherit it.
+ */
+export function nanocodexTools() {
+  return {
+    name: "nanocodex-tools",
+    enforce: "pre",
+    resolveId(source, importer) {
+      if (source === "@microsoft/dev-tunnels-ssh") return browserSsh;
+      if (source === "node-rsa") return unsupportedNodeRsa;
+      if (source === "node:zlib") return browserZlib;
+      // Let the compatibility module's own default import reach Vite's normal
+      // CommonJS transform; every external named import resolves to this ESM
+      // boundary instead of relying on consumer optimizeDeps configuration.
+      if (source === "sprintf-js" && importer?.split("?", 1)[0] !== browserSprintf) {
+        return browserSprintf;
+      }
+      return null;
+    },
+  };
+}