@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/families/wasm-rust/files/validate-wasm.mjs

@@ -0,0 +1,30 @@
+// Structural validator for the wasm-rust starter. Does NOT run wasm-pack
+// (that requires the Rust + wasm toolchain which scaffold validation runs
+// without). Confirms the entry files exist and reference each other.
+
+import fs from "node:fs/promises";
+
+const [cargoToml, libRs, mainTs, viteConfig] = await Promise.all([
+  fs.readFile("Cargo.toml", "utf8"),
+  fs.readFile("src/lib.rs", "utf8"),
+  fs.readFile("src/main.ts", "utf8"),
+  fs.readFile("vite.config.ts", "utf8"),
+]);
+
+if (!cargoToml.includes('crate-type = ["cdylib", "rlib"]')) {
+  throw new Error("Cargo.toml must declare cdylib for wasm-bindgen output");
+}
+if (!cargoToml.includes('wasm-bindgen')) {
+  throw new Error("Cargo.toml missing wasm-bindgen dependency");
+}
+if (!libRs.includes('#[wasm_bindgen]')) {
+  throw new Error("src/lib.rs must export at least one #[wasm_bindgen] function");
+}
+if (!mainTs.includes('./pkg/')) {
+  throw new Error("src/main.ts must import the compiled wasm module from ./pkg/");
+}
+if (!viteConfig.includes('vite-plugin-wasm')) {
+  throw new Error("vite.config.ts must include vite-plugin-wasm for WASM asset handling");
+}
+
+console.log("wasm-rust starter ok");

package/registry/families/wasm-rust/files/vite.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+import wasm from 'vite-plugin-wasm'
+import topLevelAwait from 'vite-plugin-top-level-await'
+
+export default defineConfig({
+  plugins: [wasm(), topLevelAwait()],
+  server: { port: {{port}} },
+  build: {
+    target: 'esnext',
+  },
+})

package/registry/families/wasm-rust/manifest.json

@@ -0,0 +1,156 @@
+{
+  "id": "wasm-rust",
+  "description": "Rust-compiled-to-WASM starter with wasm-bindgen bindings and a Vite frontend that loads + calls the module. For compute-heavy browser work (crypto primitives, image/video processing, physics, geometry, simulation) where JS throughput isn't enough.",
+  "tags": [
+    "wasm",
+    "rust",
+    "webassembly",
+    "frontend"
+  ],
+  "taxonomy": {
+    "language": "rust",
+    "runtime": "wasm",
+    "surface": "frontend"
+  },
+  "defaults": {
+    "projectType": "frontend",
+    "crateName": "starter_foundry_wasm",
+    "port": 4179,
+    "headline": "Rust + WASM in your browser",
+    "subheadline": "Native-speed compute shipped as a 20-line call from React."
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/Cargo.toml",
+      "target": "Cargo.toml"
+    },
+    {
+      "source": "files/build-wasm.mjs",
+      "target": "build-wasm.mjs"
+    },
+    {
+      "source": "files/validate-wasm.mjs",
+      "target": "validate-wasm.mjs"
+    },
+    {
+      "source": "files/vite.config.ts",
+      "target": "vite.config.ts"
+    },
+    {
+      "source": "files/tsconfig.json",
+      "target": "tsconfig.json"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "Cargo.toml"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib.rs"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/main.ts"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-wasm.mjs"
+      ],
+      "expect": "wasm-rust starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "pnpm run build:wasm",
+      "pnpm run dev"
+    ],
+    "entrypoints": [
+      "src/lib.rs",
+      "src/main.ts",
+      "Cargo.toml",
+      "vite.config.ts"
+    ],
+    "preview": {
+      "path": "/"
+    },
+    "extensionPoints": [
+      "src/lib.rs",
+      "pkg/"
+    ]
+  },
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "rust wasm",
+    "wasm-bindgen",
+    "wasm-pack",
+    "rust in browser",
+    "browser wasm"
+  ],
+  "scoring": {
+    "boost": {
+      "wasm": 3,
+      "webassembly": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "wasm",
+      "webassembly",
+      "wasm-bindgen",
+      "wasm-pack"
+    ],
+    "tier2": [
+      "rust wasm",
+      "rust in browser",
+      "browser wasm"
+    ],
+    "archetypes": [
+      "image processing in browser",
+      "browser crypto",
+      "client-side video encoder",
+      "physics simulation",
+      "geometry engine",
+      "scientific computing web"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Rust compiled to WASM + served by Vite. Use for compute-heavy browser workloads: crypto primitives, image/video processing, physics, geometry, scientific compute. Native-speed calls from React, 20-line API.",
+    "firstSteps": [
+      "Install wasm-pack (required): `curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh`",
+      "Run `pnpm run build:wasm` BEFORE `pnpm dev` \u2014 Vite imports from ./pkg/ which only exists after wasm-pack runs.",
+      "Extend `src/lib.rs` \u2014 annotate exports with `#[wasm_bindgen]`. Rust types auto-translate to JS (`&str` \u2192 string, `Vec<u8>` \u2192 Uint8Array).",
+      "Call from TS: `import init, { myFn } from './pkg/<crateName>.js'` then `await init()` once at module top-level.",
+      "Run native Rust tests via `cargo test` \u2014 they use the same src/lib.rs without WASM compilation."
+    ],
+    "gotchas": [
+      "Proving keys + ML weights are multi-MB \u2014 put them under `public/` (served as static assets), not imported as modules. Vite inlines imports <4KB and base64-bloats larger.",
+      "wasm-bindgen types that contain references (&str, &[u8]) force a copy across the JS/WASM boundary. For hot loops, pass owned types (String, Vec<u8>).",
+      "`top-level await` is required to await init() at module scope \u2014 vite-plugin-top-level-await is wired in vite.config.ts; don't remove it.",
+      "The `pkg/` directory regenerates on every build. Do NOT edit generated files; they are overwritten."
+    ],
+    "architectureNotes": [
+      "Compile profile `release` with `opt-level = \"s\"` + LTO is configured in Cargo.toml \u2014 smaller binaries. For CPU-heavy workloads switch to `opt-level = 3`.",
+      "The crate type is `[\"cdylib\", \"rlib\"]` \u2014 cdylib for wasm-bindgen output, rlib so Rust unit tests still link."
+    ],
+    "placeholders": [
+      {
+        "path": "src/lib.rs",
+        "description": "Default exports `greet()` and `fibonacci()` as demonstrations. Replace with the product's actual WASM-exposed API \u2014 each public function needs `#[wasm_bindgen]`."
+      },
+      {
+        "path": "src/main.ts",
+        "description": "Default DOM wiring that demos greet + fibonacci. Replace with the product's actual UI that calls the real WASM exports."
+      }
+    ]
+  }
+}

package/registry/families/webgpu-inference/files/index.html

@@ -0,0 +1,25 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{serviceName}}</title>
+    <style>
+      html, body { margin: 0; padding: 0; min-height: 100%; background: #0b0d10; color: #e7ecf3; font: 14px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; }
+      main { max-width: 880px; margin: 0 auto; padding: 32px 24px; }
+      h1 { font-size: 18px; margin: 0 0 12px; color: #6ea8ff; }
+      #status { padding: 8px 12px; border: 1px solid #2a3240; border-radius: 6px; background: #11161d; margin: 12px 0; }
+      #output { white-space: pre; padding: 12px; border: 1px solid #2a3240; border-radius: 6px; background: #11161d; overflow-x: auto; }
+      .err { color: #ff8080; }
+      .ok { color: #7bd88f; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>WebGPU Inference Starter</h1>
+      <div id="status">Initializing WebGPU…</div>
+      <pre id="output"></pre>
+    </main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/registry/families/webgpu-inference/files/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "validate": "node validate-webgpu-inference.mjs"
+  },
+  "devDependencies": {
+    "@webgpu/types": "^0.1.52",
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/webgpu-inference/files/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["@webgpu/types", "vite/client"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/registry/families/webgpu-inference/files/validate-webgpu-inference.mjs

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+
+const [pkgSource, mainSource, shaderSource, htmlSource, tsconfigSource] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("src/main.ts", "utf8"),
+  fs.readFile("src/shaders/matmul.wgsl", "utf8"),
+  fs.readFile("index.html", "utf8"),
+  fs.readFile("tsconfig.json", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+
+const devDeps = pkg.devDependencies ?? {};
+if (!devDeps["@webgpu/types"]) {
+  throw new Error("package.json missing `@webgpu/types` devDependency");
+}
+if (!devDeps.vite) {
+  throw new Error("package.json missing `vite` devDependency");
+}
+
+if (!mainSource.includes("navigator.gpu")) {
+  throw new Error("src/main.ts should call navigator.gpu.requestAdapter()");
+}
+if (!mainSource.includes("createComputePipeline")) {
+  throw new Error("src/main.ts should create a GPU compute pipeline");
+}
+if (!mainSource.includes("dispatchWorkgroups")) {
+  throw new Error("src/main.ts should dispatch workgroups");
+}
+if (!mainSource.includes("GPUBufferUsage")) {
+  throw new Error("src/main.ts should allocate GPU buffers");
+}
+
+if (!shaderSource.includes("@compute")) {
+  throw new Error("src/shaders/matmul.wgsl must declare an @compute entry point");
+}
+if (!shaderSource.includes("@workgroup_size")) {
+  throw new Error("src/shaders/matmul.wgsl must declare a @workgroup_size");
+}
+
+if (!htmlSource.includes('src="/src/main.ts"')) {
+  throw new Error("index.html should load /src/main.ts as a module");
+}
+
+if (!tsconfigSource.includes("@webgpu/types")) {
+  throw new Error("tsconfig.json should include @webgpu/types in the types array");
+}
+
+console.log("webgpu-inference starter ok");

package/registry/families/webgpu-inference/files/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  server: {
+    port: 5173,
+  },
+  build: {
+    target: 'es2022',
+  },
+  // WGSL files are imported with ?raw so Vite passes them through verbatim;
+  // no loader plugin needed.
+  assetsInclude: ['**/*.wgsl'],
+})

package/registry/families/webgpu-inference/manifest.json

@@ -0,0 +1,173 @@
+{
+  "id": "webgpu-inference",
+  "description": "Browser WebGPU compute starter for ML inference — raw navigator.gpu pipeline runs a WGSL matmul compute shader over real Float32 buffers, reads results back, and prints to DOM. Foundation for in-browser transformer inference, embedding generation, and client-side ML.",
+  "tags": [
+    "frontend",
+    "typescript",
+    "webgpu",
+    "ml",
+    "inference",
+    "compute"
+  ],
+  "taxonomy": {
+    "language": "typescript",
+    "runtime": "node",
+    "surface": "frontend"
+  },
+  "defaults": {
+    "projectType": "frontend",
+    "serviceName": "starter-foundry-webgpu-inference",
+    "port": 5173
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/tsconfig.json",
+      "target": "tsconfig.json"
+    },
+    {
+      "source": "files/vite.config.ts",
+      "target": "vite.config.ts"
+    },
+    {
+      "source": "files/index.html",
+      "target": "index.html"
+    },
+    {
+      "source": "files/validate-webgpu-inference.mjs",
+      "target": "validate-webgpu-inference.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "index.html"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/main.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/shaders/matmul.wgsl"
+    },
+    {
+      "type": "file-exists",
+      "path": "package.json"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-webgpu-inference.mjs"
+      ],
+      "expect": "webgpu-inference starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "pnpm dev",
+      "pnpm build"
+    ],
+    "entrypoints": [
+      "src/main.ts",
+      "src/shaders/matmul.wgsl",
+      "index.html",
+      "vite.config.ts",
+      "package.json"
+    ],
+    "preview": {
+      "path": "/"
+    },
+    "extensionPoints": [
+      "src/main.ts",
+      "src/shaders/matmul.wgsl"
+    ]
+  },
+  "keywords": [
+    "webgpu compute",
+    "gpu in browser",
+    "webgpu inference",
+    "wgsl compute",
+    "browser ml",
+    "transformers.js",
+    "wgsl shader",
+    "gpu matmul",
+    "client-side inference",
+    "webgpu buffers"
+  ],
+  "scoring": {
+    "boost": {
+      "webgpu compute": 5,
+      "webgpu inference": 5,
+      "browser ml": 4,
+      "wgsl compute": 4,
+      "transformers.js": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "webgpu compute",
+      "webgpu inference",
+      "wgsl compute",
+      "browser ml inference",
+      "transformers.js webgpu"
+    ],
+    "tier2": [
+      "gpu in browser",
+      "client-side ml",
+      "browser neural network",
+      "onnx webgpu",
+      "webgpu buffer"
+    ],
+    "archetypes": [
+      "in-browser transformer",
+      "client-side embedding",
+      "browser llm",
+      "webgpu matmul kernel",
+      "wgsl compute playground",
+      "browser image embedding",
+      "local sentiment classifier",
+      "on-device token generator",
+      "webgpu gemm benchmark",
+      "privacy-preserving inference"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Any product that needs to run ML inference inside the browser tab with GPU acceleration — small transformers, embeddings, classifiers, or custom WGSL compute kernels. Pick this over server inference when the workload is latency-sensitive, privacy-sensitive, or must work offline.",
+    "firstSteps": [
+      "Install: `pnpm install` then `pnpm dev` — Vite serves on 5173. Open Chrome 113+, Edge 113+, or Safari 18+; the page will print the output matrix from a GPU matmul.",
+      "The compute pipeline lives in `src/main.ts` — adapter → device → buffers → bind group → pipeline → dispatch → readback. It runs a 4x4 @ 4x4 matmul end-to-end on the GPU.",
+      "The WGSL kernel is in `src/shaders/matmul.wgsl` — edit the workgroup size, tiling, or the inner dot product to benchmark different strategies against a CPU reference.",
+      "For production ML, uncomment the Transformers.js path in `src/main.ts` and `pnpm add @huggingface/transformers` — it auto-detects WebGPU and runs ONNX models with a single `pipeline()` call.",
+      "Build: `pnpm build` emits static assets to `dist/` — deploy to any static host. WebGPU requires HTTPS in production (localhost is exempt)."
+    ],
+    "gotchas": [
+      "WebGPU is Chrome/Edge 113+ and Safari 18+ stable. Firefox ships it behind `dom.webgpu.enabled` — always feature-detect `navigator.gpu` and fall back to WebAssembly SIMD (Transformers.js does this automatically).",
+      "`requestAdapter()` returns `null` on iGPU-blocklisted devices and in private/incognito on some platforms — do not assume adapter is non-null. Surface a user-visible fallback message.",
+      "Buffer sizes must be multiples of 4 bytes and declared with the right `usage` flags — STORAGE for shader-writable, COPY_SRC to read back via a staging buffer, COPY_DST to upload input. Missing COPY_SRC silently produces zeros on readback.",
+      "`mapAsync(GPUMapMode.READ)` requires a buffer created with MAP_READ | COPY_DST — you cannot map a STORAGE buffer directly. Always copy STORAGE → staging → map.",
+      "Workgroup size in the WGSL (`@workgroup_size(x,y,z)`) must match the `dispatchWorkgroups(a,b,c)` call such that `a*x`, `b*y`, `c*z` cover the output tensor dimensions. Off-by-one here produces partial outputs with zero-filled tails.",
+      "Shader compilation errors are async — `await device.createShaderModule({...}).getCompilationInfo()` and log `.messages` during development or bugs will appear as silent NaN outputs."
+    ],
+    "architectureNotes": [
+      "Create one GPUDevice per page and reuse it across inference calls — `requestDevice()` is expensive and each device has its own command queue and buffer pool.",
+      "Keep bind group layouts explicit (not auto-generated) once the model stabilizes — auto layouts regenerate on each pipeline creation and fragment the cache, hurting cold-start latency.",
+      "For multi-kernel pipelines (attention + MLP + layernorm), batch commands into a single GPUCommandEncoder before submitting — each `queue.submit` incurs a kernel-launch roundtrip."
+    ],
+    "placeholders": [
+      {
+        "path": "src/main.ts",
+        "description": "WebGPU bootstrap — adapter, device, input/output/staging buffers, bind group, compute pipeline, dispatch, readback, DOM print. Replace the 4x4 matmul with the product's real kernel (attention QK^T, GEMM, convolution) or flip to the Transformers.js branch for ONNX models."
+      },
+      {
+        "path": "src/shaders/matmul.wgsl",
+        "description": "Minimal tiled matmul compute shader. Extend for fused kernels (matmul + bias + activation), different dtypes (f16 via the shader-f16 feature), or quantization (int8 dot-product via DP4a)."
+      }
+    ]
+  }
+}

package/registry/families/webgpu-render/files/index.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{serviceName}}</title>
+    <style>
+      html, body { margin: 0; padding: 0; height: 100%; background: #0b0d10; overflow: hidden; }
+      canvas { display: block; width: 100vw; height: 100vh; }
+      #status { position: fixed; top: 12px; left: 12px; font: 12px/1.3 ui-monospace, SFMono-Regular, Menlo, monospace; color: #e7ecf3; background: rgba(17,22,29,0.82); border: 1px solid #2a3240; padding: 6px 10px; border-radius: 6px; pointer-events: none; }
+      #status.err { color: #ff8080; border-color: #ff8080; }
+    </style>
+  </head>
+  <body>
+    <canvas id="scene"></canvas>
+    <div id="status">Initializing WebGPU…</div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/registry/families/webgpu-render/files/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "validate": "node validate-webgpu-render.mjs"
+  },
+  "devDependencies": {
+    "@webgpu/types": "^0.1.52",
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/webgpu-render/files/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["@webgpu/types", "vite/client"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/registry/families/webgpu-render/files/validate-webgpu-render.mjs

@@ -0,0 +1,58 @@
+import fs from "node:fs/promises";
+
+const [pkgSource, mainSource, shaderSource, htmlSource, tsconfigSource] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("src/main.ts", "utf8"),
+  fs.readFile("src/shaders/main.wgsl", "utf8"),
+  fs.readFile("index.html", "utf8"),
+  fs.readFile("tsconfig.json", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+
+const devDeps = pkg.devDependencies ?? {};
+if (!devDeps["@webgpu/types"]) {
+  throw new Error("package.json missing `@webgpu/types` devDependency");
+}
+if (!devDeps.vite) {
+  throw new Error("package.json missing `vite` devDependency");
+}
+
+if (!mainSource.includes("navigator.gpu")) {
+  throw new Error("src/main.ts should call navigator.gpu.requestAdapter()");
+}
+if (!mainSource.includes("createRenderPipeline")) {
+  throw new Error("src/main.ts should create a GPU render pipeline");
+}
+if (!mainSource.includes("beginRenderPass")) {
+  throw new Error("src/main.ts should open a render pass");
+}
+if (!mainSource.includes("getContext")) {
+  throw new Error("src/main.ts should acquire a webgpu canvas context");
+}
+if (!mainSource.includes("requestAnimationFrame")) {
+  throw new Error("src/main.ts should drive a requestAnimationFrame render loop");
+}
+
+if (!shaderSource.includes("@vertex")) {
+  throw new Error("src/shaders/main.wgsl must declare a @vertex entry point");
+}
+if (!shaderSource.includes("@fragment")) {
+  throw new Error("src/shaders/main.wgsl must declare a @fragment entry point");
+}
+
+if (!htmlSource.includes('src="/src/main.ts"')) {
+  throw new Error("index.html should load /src/main.ts as a module");
+}
+if (!htmlSource.includes('id="scene"')) {
+  throw new Error("index.html must include a <canvas id=\"scene\"> for the render target");
+}
+
+if (!tsconfigSource.includes("@webgpu/types")) {
+  throw new Error("tsconfig.json should include @webgpu/types in the types array");
+}
+
+console.log("webgpu-render starter ok");

package/registry/families/webgpu-render/files/vite.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  server: {
+    port: 5173,
+  },
+  build: {
+    target: 'es2022',
+  },
+  assetsInclude: ['**/*.wgsl'],
+})