@miden-sdk/create-para-react 0.0.0-bootstrap → 0.16.0-rc.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,10 +1,20 @@
 # @miden-sdk/create-para-react
 
-**Placeholder — do not install.**
+`npm create @miden-sdk/para-react@latest my-app` scaffolds the latest Vite `react-ts` starter, overwrites it with this repo's `vite.config.ts`, swaps in a Para + Miden-ready `App.tsx`, and adds the deps needed to run it out of the box. The scaffold always runs `create-vite` with `--yes --no-install` and pipes "no" to the install prompt to prevent upstream installs from overwriting the template before we patch it.
 
-npm requires a package to exist before a trusted publisher can be attached to it, so this
-`0.0.0-bootstrap` version exists only to reserve the name and let `0xMiden/web-sdk` be
-registered as its trusted publisher.
+## What it does
+- Runs `npm create vite@latest <target> -- --template react-ts` so you always start from the upstream default.
+- Replaces `vite.config.ts` with the Para + Miden-friendly config (dedupe/exclude and WASM asset handling).
+- Replaces `src/App.tsx` with a `ParaSignerProvider` + `MidenProvider` starter that reports wallet, account ID, and client readiness.
+- Adds Para/Miden deps: `@miden-sdk/para`, `@miden-sdk/react`, `@getpara/react-sdk-lite`, `@getpara/evm-wallet-connectors`, `@miden-sdk/miden-sdk`, plus dev plugins `vite-plugin-node-polyfills`, `vite-plugin-wasm`, and `vite-plugin-top-level-await`.
+- Installs dependencies using your detected package manager (`pnpm`, `yarn`, `bun`, or falls back to `npm`); `create-vite` is invoked with `--yes --no-install` and auto-answers "no" to install prompts to avoid reverting the patched files.
+- Writes `.npmrc` with `legacy-peer-deps=true` for peer dependency resolution.
+- Adds `src/polyfills.ts` and injects it into `src/main.tsx` to provide `Buffer`/`process` in the browser.
 
-It is published under the `bootstrap` dist-tag, not `latest`, and is deprecated. Real
-releases will ship from `0xMiden/web-sdk` with OIDC provenance.
+## Usage
+- Standard: `npm create @miden-sdk/para-react@latest my-new-app`
+- Skip install: add `--skip-install` if you want to install later.
+- Set `VITE_PARA_API_KEY` in a `.env.local` (or similar) file so the generated `App.tsx` can initialize Para. **Production deployments require a Para production API key.**
+- Recommended next steps: `cd my-new-app && npm install && npm run dev` (`.npmrc` opts into legacy peer deps so npm works).
+
+Publish from this folder with `npm publish --access public` when you're ready. For local testing, run `node ./packages/create-miden-para-react/bin/create-miden-para-react.mjs my-app`.

package/bin/create-miden-para-react.mjs

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const templateConfigPath = resolve(
+  __dirname,
+  "..",
+  "template",
+  "vite.config.ts"
+);
+const templateAppPath = resolve(__dirname, "..", "template", "src", "App.tsx");
+const templatePolyfillsPath = resolve(
+  __dirname,
+  "..",
+  "template",
+  "src",
+  "polyfills.ts"
+);
+const templateOptionalConnectorsPath = resolve(
+  __dirname,
+  "..",
+  "template",
+  "src",
+  "optional-connectors.ts"
+);
+const repoRoot = resolve(__dirname, "..", "..", "..");
+const localMidenParaPath =
+  process.env.MIDEN_PARA_LOCAL_MIDEN_PARA_PATH ?? repoRoot;
+const localUseMidenParaReactPath =
+  process.env.MIDEN_PARA_LOCAL_USE_MIDEN_PARA_REACT_PATH ??
+  join(repoRoot, "packages", "use-miden-para-react");
+const useLocalDeps = process.env.MIDEN_PARA_LOCAL_DEPS === "1";
+
+const args = process.argv.slice(2);
+const target =
+  args.find((arg) => !arg.startsWith("-")) ?? "miden-para-react-app";
+const skipInstall = args.some(
+  (flag) => flag === "--skip-install" || flag === "--no-install"
+);
+const skipScaffold =
+  args.some((flag) => flag === "--skip-scaffold" || flag === "--no-scaffold") ||
+  process.env.MIDEN_PARA_TEST_MODE === "1";
+const targetDir = resolve(process.cwd(), target);
+const targetParent = dirname(targetDir);
+const targetName = basename(targetDir);
+const baseEnv = {
+  ...process.env,
+  CI: process.env.CI ?? "true",
+  npm_config_yes: process.env.npm_config_yes ?? "true",
+};
+
+ensureTargetParent();
+if (skipScaffold) {
+  scaffoldMinimalProject(targetDir, targetName);
+} else {
+  runCreateVite(targetName);
+}
+overrideViteConfig(targetDir);
+overrideApp(targetDir);
+ensurePolyfills(targetDir);
+ensureOptionalConnectorsShim(targetDir);
+ensurePolyfillDependency(targetDir);
+ensureMidenParaDependencies(targetDir);
+ensureViteConfigTsconfig(targetDir);
+ensureNpmRc(targetDir);
+logEnvReminder(targetName);
+
+if (!skipInstall) {
+  installDependencies(targetDir);
+} else {
+  logStep("Skipped dependency installation (--skip-install)");
+}
+
+function ensureTargetParent() {
+  mkdirSync(targetParent, { recursive: true });
+}
+
+function runCreateVite(targetArg) {
+  const scaffoldArgs = [
+    "create",
+    "vite@latest",
+    targetArg,
+    "--",
+    "--template",
+    "react-ts",
+    "--yes", // avoid interactive prompts that might install/revert files
+    "--no-install", // we handle installs after patching package.json
+  ];
+  runOrExit("npm", scaffoldArgs, targetParent, baseEnv, "n\n");
+}
+
+function scaffoldMinimalProject(targetRoot, name) {
+  mkdirSync(targetRoot, { recursive: true });
+  const pkgPath = join(targetRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    const pkg = {
+      name,
+      private: true,
+      version: "0.0.0",
+      type: "module",
+      scripts: {
+        dev: "vite",
+        build: "vite build",
+        preview: "vite preview",
+      },
+      dependencies: {
+        react: "^18.2.0",
+        "react-dom": "^18.2.0",
+      },
+      devDependencies: {
+        "@types/react": "^18.2.0",
+        "@types/react-dom": "^18.2.0",
+        "@vitejs/plugin-react": "^4.2.0",
+        typescript: "^5.2.2",
+        vite: "^5.2.0",
+      },
+    };
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  }
+
+  const srcDir = join(targetRoot, "src");
+  mkdirSync(srcDir, { recursive: true });
+  const mainPath = join(srcDir, "main.tsx");
+  if (!existsSync(mainPath)) {
+    writeFileSync(
+      mainPath,
+      `import React from "react";\nimport ReactDOM from "react-dom/client";\nimport App from "./App";\n\nReactDOM.createRoot(document.getElementById("root")!).render(<App />);\n`
+    );
+  }
+  const appPath = join(srcDir, "App.tsx");
+  if (!existsSync(appPath)) {
+    writeFileSync(appPath, "export default function App() { return null; }\n");
+  }
+}
+
+function overrideViteConfig(targetRoot) {
+  const dest = join(targetRoot, "vite.config.ts");
+  copyFileSync(templateConfigPath, dest);
+}
+
+function overrideApp(targetRoot) {
+  const dest = join(targetRoot, "src", "App.tsx");
+  mkdirSync(join(targetRoot, "src"), { recursive: true });
+  logStep(`Replacing App.tsx with Para + Miden starter at ${dest}`);
+  copyFileSync(templateAppPath, dest);
+}
+
+function ensurePolyfills(targetRoot) {
+  const dest = join(targetRoot, "src", "polyfills.ts");
+  mkdirSync(join(targetRoot, "src"), { recursive: true });
+  copyFileSync(templatePolyfillsPath, dest);
+
+  const mainPath = join(targetRoot, "src", "main.tsx");
+  if (existsSync(mainPath)) {
+    const main = readFileSync(mainPath, "utf8");
+    if (!main.includes("./polyfills") && !main.includes("./polyfills")) {
+      writeFileSync(mainPath, `import "./polyfills";\n${main}`);
+      logStep(`Injected polyfills import into ${mainPath}`);
+    }
+  }
+}
+
+function ensureOptionalConnectorsShim(targetRoot) {
+  const dest = join(targetRoot, "src", "optional-connectors.ts");
+  mkdirSync(join(targetRoot, "src"), { recursive: true });
+  copyFileSync(templateOptionalConnectorsPath, dest);
+}
+
+function ensurePolyfillDependency(targetRoot) {
+  const pkgPath = join(targetRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    logStep("No package.json found after scaffolding; nothing to patch");
+    return;
+  }
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  pkg.devDependencies = pkg.devDependencies ?? {};
+  pkg.devDependencies["vite-plugin-node-polyfills"] ??= "^0.24.0";
+  pkg.devDependencies["vite-plugin-wasm"] ??= "^3.5.0";
+  pkg.devDependencies["vite-plugin-top-level-await"] ??= "^1.6.0";
+  // vite-plugin-top-level-await does `require("rollup")` / `require("esbuild")`
+  // but doesn't declare them as dependencies. Vite 8 switched to rolldown and
+  // no longer installs either transitively, so pin them explicitly.
+  pkg.devDependencies["rollup"] ??= "^4.0.0";
+  pkg.devDependencies["esbuild"] ??= "^0.27.0";
+  // vite-plugin-top-level-await depends on `@swc/core: ^1.12.14` and drives it
+  // through the AST printer. swc 1.16 changed that AST's schema, so the caret
+  // range resolves to a version the plugin cannot use and the build fails at
+  // `generateBundle` with `Error: missing field \`type\``. Hold it on 1.15.x
+  // until the plugin catches up.
+  pkg.devDependencies["@swc/core"] ??= "~1.15.47";
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  logStep("Added Vite plugin deps (polyfills/wasm/top-level-await)");
+}
+
+function ensureViteConfigTsconfig(targetRoot) {
+  // create-vite scaffolds `tsconfig.node.json` (the project that compiles
+  // vite.config.ts) with `"module": "nodenext"`. Under nodenext, TypeScript
+  // decides a dependency's .d.ts is CJS or ESM from that package's own
+  // `type` field — and vite-plugin-wasm / vite-plugin-top-level-await ship
+  // ESM-only `dist/*.d.ts` without declaring `"type": "module"`. Both are
+  // therefore read as CJS, so `import wasm from "vite-plugin-wasm"` resolves
+  // to the module namespace rather than the default export and the build
+  // dies with `TS2349: This expression is not callable`.
+  //
+  // Bundler resolution is what actually matches how Vite loads its own
+  // config, and it does not apply that CJS/ESM detection. Patch it back.
+  const tsconfigPath = join(targetRoot, "tsconfig.node.json");
+  if (!existsSync(tsconfigPath)) {
+    logStep("No tsconfig.node.json found after scaffolding; nothing to patch");
+    return;
+  }
+
+  const raw = readFileSync(tsconfigPath, "utf8");
+  let tsconfig;
+  try {
+    tsconfig = JSON.parse(stripJsonComments(raw));
+  } catch {
+    logStep("Could not parse tsconfig.node.json; leaving it untouched");
+    return;
+  }
+
+  const options = tsconfig.compilerOptions ?? {};
+  if (options.moduleResolution === "bundler" && options.module === "esnext") {
+    logStep("tsconfig.node.json already uses bundler resolution");
+    return;
+  }
+
+  options.module = "esnext";
+  options.moduleResolution = "bundler";
+  tsconfig.compilerOptions = options;
+  writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}\n`);
+  logStep("Set bundler module resolution for vite.config.ts");
+}
+
+// tsconfig files scaffolded by create-vite carry `/* ... */` comments, which
+// JSON.parse rejects. Strip them rather than pulling in a dependency.
+function stripJsonComments(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+
+function ensureNpmRc(targetRoot) {
+  const npmrcPath = join(targetRoot, ".npmrc");
+  const line = "legacy-peer-deps=true";
+  if (existsSync(npmrcPath)) {
+    const contents = readFileSync(npmrcPath, "utf8");
+    if (contents.includes(line)) {
+      logStep("Existing .npmrc already opts into legacy-peer-deps");
+      return;
+    }
+    writeFileSync(npmrcPath, `${contents.trim()}\n${line}\n`);
+    logStep("Updated .npmrc to include legacy-peer-deps");
+    return;
+  }
+  writeFileSync(npmrcPath, `${line}\n`);
+  logStep("Created .npmrc with legacy-peer-deps=true");
+}
+
+function ensureMidenParaDependencies(targetRoot) {
+  const pkgPath = join(targetRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    logStep("No package.json found after scaffolding; cannot add dependencies");
+    return;
+  }
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  pkg.dependencies = pkg.dependencies ?? {};
+  pkg.devDependencies = pkg.devDependencies ?? {};
+  pkg.resolutions = pkg.resolutions ?? {};
+  pkg.scripts = pkg.scripts ?? {};
+  const midenParaVersion = useLocalDeps
+    ? `file:${localMidenParaPath}`
+    : "0.15.1";
+  const useMidenParaReactVersion = useLocalDeps
+    ? `file:${localUseMidenParaReactPath}`
+    : "^0.15.1";
+  // Align with examples/react-signer so Para SDK connector peers are satisfied
+  Object.assign(pkg.dependencies, {
+    ...pkg.dependencies,
+    "@getpara/react-sdk-lite": "^2.2.0",
+    "@getpara/evm-wallet-connectors": "^2.2.0",
+    "@miden-sdk/miden-sdk": "^0.15.1",
+    "@miden-sdk/para": midenParaVersion,
+    "@miden-sdk/para-react": useMidenParaReactVersion,
+    "@miden-sdk/react": "^0.15.1",
+    "@tanstack/react-query": "^5.0.0",
+  });
+
+  Object.assign(pkg.devDependencies, {
+    ...pkg.devDependencies,
+    "vite-plugin-node-polyfills": "^0.24.0",
+    "vite-plugin-wasm": "^3.5.0",
+    "vite-plugin-top-level-await": "^1.6.0",
+    // See ensurePolyfillDependency() — vite 8 dropped rollup/esbuild, so the
+    // top-level-await plugin's implicit requires need explicit pins.
+    rollup: "^4.0.0",
+    esbuild: "^0.27.0",
+  });
+
+  Object.assign(pkg.resolutions, {
+    "@getpara/react-sdk": "2.0.0-alpha.73",
+    "@getpara/web-sdk": "2.0.0-alpha.73",
+  });
+
+  Object.assign(pkg.scripts, {
+    ...pkg.scripts,
+    postinstall: "setup-para",
+  });
+
+  delete pkg.peerDependencies;
+
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  logStep("Added Para + Miden starter dependencies");
+}
+
+function installDependencies(targetRoot) {
+  const pm = detectPackageManager();
+  logStep(`Installing dependencies with ${pm.command}`);
+  runOrExit(pm.command, pm.args, targetRoot);
+}
+
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent || "";
+  if (ua.startsWith("pnpm")) return { command: "pnpm", args: ["install"] };
+  if (ua.startsWith("yarn")) return { command: "yarn", args: [] };
+  if (ua.startsWith("bun")) return { command: "bun", args: ["install"] };
+  return { command: "npm", args: ["install"] };
+}
+
+function runOrExit(command, args, cwd, env, input) {
+  const result = spawnSync(command, args, {
+    stdio: input ? ["pipe", "inherit", "inherit"] : "inherit",
+    input,
+    cwd,
+    env,
+  });
+
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function logStep(message) {
+  console.log(`\n> ${message}`);
+}
+
+function logEnvReminder(dirName) {
+  logStep(
+    `Remember to use VITE_PARA_API_KEY like this:\n  cd ${dirName}\n  VITE_PARA_API_KEY=... npm run dev`
+  );
+}

package/package.json

@@ -1,18 +1,38 @@
 {
   "name": "@miden-sdk/create-para-react",
-  "version": "0.0.0-bootstrap",
-  "description": "Reserved name. Placeholder published only to allow an npm trusted publisher to be attached; do not install.",
+  "version": "0.16.0-rc.6",
+  "description": "Create a Vite react-ts app preconfigured with Miden + Para's Vite setup",
+  "type": "module",
+  "bin": "./bin/create-miden-para-react.mjs",
+  "files": [
+    "bin",
+    "template",
+    "README.md",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "license": "MIT",
   "author": "Miden Contributors",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/0xMiden/web-sdk.git"
+    "url": "git+https://github.com/0xMiden/web-sdk.git",
+    "directory": "packages/para/create"
   },
   "bugs": {
     "url": "https://github.com/0xMiden/web-sdk/issues"
   },
-  "homepage": "https://github.com/0xMiden/web-sdk",
-  "files": [
-    "README.md"
-  ]
-}
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "create-vite",
+    "vite",
+    "react",
+    "typescript",
+    "miden",
+    "para"
+  ],
+  "homepage": "https://github.com/0xMiden/web-sdk"
+}

package/template/src/App.tsx

@@ -0,0 +1,49 @@
+import "./App.css";
+import "@getpara/react-sdk-lite/styles.css";
+import { ParaSignerProvider, useParaSigner } from "@miden-sdk/para-react";
+import { MidenProvider, useSigner, useMiden } from "@miden-sdk/react";
+
+function App() {
+  return (
+    <ParaSignerProvider
+      apiKey={import.meta.env.VITE_PARA_API_KEY}
+      environment="BETA"
+      appName="Starter for MidenxPara"
+    >
+      <MidenProvider config={{ rpcUrl: "testnet" }}>
+        <Content />
+      </MidenProvider>
+    </ParaSignerProvider>
+  );
+}
+
+function Content() {
+  const signer = useSigner();
+  const { wallet } = useParaSigner();
+  const { isReady, signerAccountId } = useMiden();
+
+  const handleConnect = async () => {
+    if (signer?.isConnected) {
+      await signer.disconnect();
+    } else {
+      await signer?.connect();
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={handleConnect}>
+        {signer?.isConnected ? "Disconnect Para" : "Connect with Para"}
+      </button>
+      {signer?.isConnected && (
+        <>
+          <p>Wallet: {wallet?.address ?? "—"}</p>
+          <p>Account: {signerAccountId ?? "—"}</p>
+          <p>Client ready: {isReady ? "yes" : "no"}</p>
+        </>
+      )}
+    </div>
+  );
+}
+
+export default App;

package/template/src/optional-connectors.ts

@@ -0,0 +1 @@
+export {};

package/template/src/polyfills.ts

@@ -0,0 +1,11 @@
+import { Buffer } from "buffer";
+import process from "process";
+
+// Ensure Node globals exist when dependencies expect them in the browser.
+if (!globalThis.Buffer) {
+  globalThis.Buffer = Buffer;
+}
+
+if (!globalThis.process) {
+  globalThis.process = process;
+}

package/template/vite.config.ts

@@ -0,0 +1,87 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+import wasm from "vite-plugin-wasm";
+import topLevelAwait from "vite-plugin-top-level-await";
+
+// Optional connector families that are never imported by the starter template.
+// Alias them to an empty module so Vite doesn't try to resolve their deps.
+// @getpara/aa-* packages are lazy `import()`ed by @getpara/react-core but the
+// rolldown bundler in Vite 8 still fails if they can't be resolved at build time.
+const optionalPackages = [
+  "@getpara/solana-wallet-connectors",
+  "@getpara/cosmos-wallet-connectors",
+  "@getpara/wagmi-v2-connector",
+  "@getpara/aa-alchemy",
+  "@getpara/aa-biconomy",
+  "@getpara/aa-cdp",
+  "@getpara/aa-gelato",
+  "@getpara/aa-pimlico",
+  "@getpara/aa-porto",
+  "@getpara/aa-rhinestone",
+  "@getpara/aa-safe",
+  "@getpara/aa-thirdweb",
+  "@getpara/aa-zerodev",
+  "wagmi",
+  "@wagmi/core",
+  "@wagmi/connectors",
+];
+
+// Mark any import whose bare specifier starts with an optional package
+// (including subpath imports like "wagmi/connectors") as external so
+// Rollup skips them entirely. These code paths are never reached at runtime.
+function externalizeOptionalPackages() {
+  return {
+    name: "externalize-optional-packages",
+    enforce: "pre" as const,
+    resolveId(id: string) {
+      if (
+        optionalPackages.some((pkg) => id === pkg || id.startsWith(pkg + "/"))
+      ) {
+        return { id, external: true };
+      }
+    },
+  };
+}
+
+// Keep the miden SDK unbundled so its WASM asset path stays valid in dev.
+export default defineConfig({
+  plugins: [
+    externalizeOptionalPackages(),
+    wasm(),
+    topLevelAwait(),
+    react(),
+    nodePolyfills({
+      include: ["buffer", "crypto", "stream", "util"],
+    }),
+  ],
+  optimizeDeps: {
+    // Keep Miden SDK unbundled and avoid prebundling Para's Stencil component bundles
+    // to prevent multiple runtimes in dev.
+    exclude: ["@miden-sdk/miden-sdk", ...optionalPackages],
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  build: {
+    target: "esnext",
+  },
+  worker: {
+    format: "es",
+  },
+  resolve: {
+    dedupe: [
+      "@getpara/web-sdk",
+      "@getpara/react-sdk-lite",
+      "react",
+      "react-dom",
+    ],
+  },
+  // Ensure Vite treats wasm as a static asset with the correct MIME type.
+  assetsInclude: ["**/*.wasm"],
+  server: {
+    fs: {
+      allow: [process.cwd()],
+    },
+  },
+});