brain0 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+# brain0 — the black box for AI-written code
+
+`git` tells you *what* changed. **brain0** tells you *why* — which prompt wrote it, what the
+agent **read** to write it, and whether you can trust it.
+
+```bash
+npx brain0 up
+```
+
+One command, any repo: brain0 passively indexes your git history (the **facts**) and your
+coding-agent sessions (the **intents** — Codex and Claude Code auto-discovered), then opens
+an explorable decision graph at `http://localhost:8787`. Clicking a commit reveals the
+prompts behind it, per-file diffs, what the agents read, and risk at a glance.
+
+- **Drift** — the agent said "I only touched the parser". brain0 fact-checks it against git.
+- **DLP reads** — which files (and which *secrets*) reached the model's context.
+- **Risk that learns** — evidence-driven scoring; "looked safe, proved dangerous" gets flagged.
+- **MCP why-layer** — `claude mcp add brain0 -- brain0 mcp` gives your agent long-term memory
+  of why the code is the way it is.
+- **Offline by default** — no hooks, no signup, no telemetry, zero egress without keys.
+
+Daily loop:
+
+```bash
+brain0 today             # morning triage: what agents did, riskiest first
+brain0 report            # the accountability report (add --md to share it)
+brain0 rewind            # the agent wrecked your tree? restore any checkpoint
+```
+
+Requirements: Node ≥ 20. Local models via [Ollama](https://ollama.com) are optional and
+make summaries/search better — never required.
+
+Full documentation, GUI guide, configuration and troubleshooting:
+**https://github.com/Brain0-ai/brain0**
+
+Apache-2.0 · © The brain0 Authors

package/bin/brain0.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * The `brain0` npm CLI. One product command plus passthrough:
+ *
+ *   brain0 up [--path <dir>] [--repo <id>] [--port 8787] [--encrypt] [--all]
+ *             [--no-ingest] [--no-observe] [--no-open]
+ *       Index the repo (git facts + agent transcripts) and serve the GUI — one command,
+ *       zero config: repo id is inferred from the git remote, data lives in <repo>/.brain0.
+ *
+ *   brain0 <ingest|observe|query|mcp|verify|audit|reembed|purge|watch> …
+ *       Forwarded verbatim to the Rust core binary.
+ *
+ * Resolution order (works from the monorepo during development and from the published
+ * package): BRAIN0_BIN → @brain0/cli-<platform>-<arch> package → monorepo target/{release,debug}.
+ */
+
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { inferRepoId, parseArgs, REPO_RE } from "../src/lib.mjs";
+
+const PKG_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+// In the monorepo this is packages/cli → two levels up is the repo root.
+const MONOREPO_ROOT = resolve(PKG_DIR, "../..");
+
+// ── component resolution ────────────────────────────────────────────────────
+function resolveRustBin() {
+  if (process.env.BRAIN0_BIN && existsSync(process.env.BRAIN0_BIN)) return process.env.BRAIN0_BIN;
+  const exe = process.platform === "win32" ? "brain0.exe" : "brain0";
+  // Published layout: platform package installed next to us (npm resolves optionalDependencies).
+  const platformPkg = `@brain0/cli-${process.platform}-${process.arch}`;
+  try {
+    const entry = import.meta.resolve(`${platformPkg}/package.json`);
+    const p = resolve(dirname(fileURLToPath(entry)), exe);
+    if (existsSync(p)) return p;
+  } catch {
+    /* not installed — fall through to the dev layout */
+  }
+  for (const rel of [`target/release/${exe}`, `target/debug/${exe}`]) {
+    const p = resolve(MONOREPO_ROOT, rel);
+    if (existsSync(p)) return p;
+  }
+  return undefined;
+}
+
+function resolveServerEntry() {
+  for (const p of [
+    resolve(PKG_DIR, "vendor/server/server.js"), // published: bundled at release time
+    resolve(MONOREPO_ROOT, "packages/server/dist/server.js"), // monorepo dev
+  ]) {
+    if (existsSync(p)) return p;
+  }
+  return undefined;
+}
+
+function resolveGuiDir() {
+  if (process.env.BRAIN0_GUI_DIR) return process.env.BRAIN0_GUI_DIR;
+  for (const p of [
+    resolve(PKG_DIR, "vendor/gui"), // published: bundled at release time
+    resolve(MONOREPO_ROOT, "packages/gui/build"), // monorepo dev
+  ]) {
+    if (existsSync(resolve(p, "index.html"))) return p;
+  }
+  return undefined;
+}
+
+// ── small process helpers (mirrors scripts/dev.mjs) ─────────────────────────
+const COLORS = { ingest: 33, observe: 34, server: 35 };
+const prefixer = (label) => {
+  const c = COLORS[label] ?? 37;
+  return (chunk) => {
+    for (const line of chunk.toString().split(/\r?\n/)) {
+      if (line.length) process.stdout.write(`\x1b[${c}m[${label}]\x1b[0m ${line}\n`);
+    }
+  };
+};
+
+const longLived = [];
+let shuttingDown = false;
+function shutdown(code = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  for (const child of longLived) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      /* already gone */
+    }
+  }
+  process.exit(code);
+}
+for (const sig of ["SIGINT", "SIGTERM", "exit"]) process.on(sig, () => shutdown());
+
+function run(label, cmd, args, cwd, env) {
+  return new Promise((res, rej) => {
+    const child = spawn(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", prefixer(label));
+    child.stderr.on("data", prefixer(label));
+    child.on("exit", (c) => (c === 0 ? res() : rej(new Error(`${label} exited with code ${c}`))));
+    child.on("error", rej);
+  });
+}
+
+function runLongLived(label, cmd, args, cwd, env) {
+  const child = spawn(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], detached: true });
+  child.stdout.on("data", prefixer(label));
+  child.stderr.on("data", prefixer(label));
+  child.on("exit", (c) => {
+    if (!shuttingDown) shutdown(c ?? 0);
+  });
+  longLived.push(child);
+  return child;
+}
+
+async function poll(url, timeoutMs = 30000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      if ((await fetch(url)).ok) return;
+    } catch {
+      /* not up yet */
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`timed out waiting for ${url}`);
+}
+
+function openBrowser(url) {
+  const cmd =
+    process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+  } catch {
+    /* headless is fine — the URL is printed */
+  }
+}
+
+// ── `up` ────────────────────────────────────────────────────────────────────
+async function up(argv) {
+  const { flags, opts } = parseArgs(argv, ["path", "repo", "port"]);
+  const repoPath = resolve(opts.get("path") ?? ".");
+  if (!existsSync(repoPath)) {
+    console.error(`brain0 up: --path not found: ${repoPath}`);
+    process.exit(1);
+  }
+
+  let repo = opts.get("repo") ?? "";
+  if (!repo) {
+    let remote = "";
+    try {
+      remote = execFileSync("git", ["-C", repoPath, "remote", "get-url", "origin"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+    } catch {
+      /* no git remote — fall back to the directory name */
+    }
+    repo = inferRepoId(remote, basename(repoPath));
+  }
+  if (!REPO_RE.test(repo) || repo.startsWith("-")) {
+    console.error(`brain0 up: invalid repo id "${repo}" (allowed: letters digits . _ / -)`);
+    process.exit(1);
+  }
+
+  const bin = resolveRustBin();
+  if (!bin) {
+    console.error(
+      "brain0 up: core binary not found.\n" +
+        `  Expected @brain0/cli-${process.platform}-${process.arch} (npm) or target/release/brain0 (repo).\n` +
+        "  From the repo: cargo build --release -p brain0-cli",
+    );
+    process.exit(1);
+  }
+  const serverEntry = resolveServerEntry();
+  if (!serverEntry) {
+    console.error(
+      "brain0 up: server not found — from the repo run: pnpm --filter @brain0/server build",
+    );
+    process.exit(1);
+  }
+  const guiDir = resolveGuiDir(); // optional: API still works without it
+
+  const port = Number(opts.get("port") ?? process.env.PORT ?? "8787");
+  const db = resolve(repoPath, ".brain0/index.db");
+  const payload = resolve(repoPath, ".brain0/payload");
+  // The GUI must read diffs/summaries, so `up` defaults to a plaintext payload (opt back into
+  // at-rest encryption with --encrypt; the GUI then shows an "encrypted" notice instead of text).
+  const encArgs = flags.has("encrypt") ? [] : ["--no-encrypt-payload"];
+  const common = ["--repo", repo, "--path", repoPath, "--db", db, "--payload", payload, ...encArgs];
+
+  const env = {
+    ...process.env,
+    BRAIN0_REPO: repo,
+    BRAIN0_DB: db,
+    BRAIN0_PAYLOAD: payload,
+    BRAIN0_REPO_PATH: repoPath,
+    BRAIN0_BIN: bin,
+    PORT: String(port),
+    ...(guiDir ? { BRAIN0_GUI_DIR: guiDir } : {}),
+  };
+
+  console.log(`brain0 up · repo=${repo} · path=${repoPath}`);
+  try {
+    if (!flags.has("no-ingest")) await run("ingest", bin, ["ingest", ...common], repoPath, env);
+    if (!flags.has("no-observe"))
+      await run(
+        "observe",
+        bin,
+        ["observe", ...common, ...(flags.has("all") ? ["--all"] : [])],
+        repoPath,
+        env,
+      );
+
+    runLongLived(
+      "server",
+      process.execPath,
+      ["--experimental-sqlite", serverEntry],
+      repoPath,
+      env,
+    );
+    await poll(`http://localhost:${port}/health`);
+
+    const url = `http://localhost:${port}/`;
+    console.log(
+      guiDir
+        ? `\n  brain0 is up → ${url}   (Ctrl-C to stop)\n`
+        : `\n  brain0 API is up → ${url} (GUI build not bundled — set BRAIN0_GUI_DIR)\n`,
+    );
+    if (guiDir && !flags.has("no-open")) openBrowser(url);
+  } catch (err) {
+    console.error(`brain0 up: aborted — ${err.message}`);
+    shutdown(1);
+  }
+}
+
+// ── dispatcher ──────────────────────────────────────────────────────────────
+const HELP = `brain0 — the black box for AI-written code
+
+Usage:
+  brain0 up [--path <dir>] [--repo <id>] [--port 8787] [--encrypt] [--all]
+            [--no-ingest] [--no-observe] [--no-open]
+  brain0 <ingest|observe|query|mcp|verify|audit|reembed|purge|watch> [args…]
+
+\`up\` indexes the repo (git facts + coding-agent transcripts) and serves the GUI at
+http://localhost:8787. Everything else is forwarded to the brain0 core binary.`;
+
+const [cmd, ...rest] = process.argv.slice(2);
+if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
+  console.log(HELP);
+  process.exit(0);
+}
+if (cmd === "up") {
+  await up(rest);
+} else {
+  const bin = resolveRustBin();
+  if (!bin) {
+    console.error(
+      `brain0: core binary not found for "${cmd}" — install @brain0/cli-${process.platform}-${process.arch} or build target/release/brain0`,
+    );
+    process.exit(1);
+  }
+  const child = spawn(bin, [cmd, ...rest], { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (err) => {
+    console.error(`brain0: ${err.message}`);
+    process.exit(1);
+  });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "brain0",
+  "version": "0.1.0",
+  "description": "brain0 — the black box for AI-written code: `npx brain0 up` on any repo",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "brain0": "./bin/brain0.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "vendor",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node -e \"process.exit(0)\"",
+    "typecheck": "node --check bin/brain0.js && node --check src/lib.mjs",
+    "lint": "node --check bin/brain0.js && node --check src/lib.mjs",
+    "test": "node --test test/*.test.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Brain0-ai/brain0.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/Brain0-ai/brain0#readme",
+  "bugs": "https://github.com/Brain0-ai/brain0/issues",
+  "keywords": [
+    "ai",
+    "provenance",
+    "coding-agents",
+    "audit",
+    "dlp",
+    "drift",
+    "git",
+    "claude-code",
+    "codex",
+    "mcp",
+    "attestation",
+    "code-review",
+    "observability"
+  ],
+  "optionalDependencies": {
+    "@brain0/cli-linux-x64": "0.1.0",
+    "@brain0/cli-linux-arm64": "0.1.0",
+    "@brain0/cli-darwin-x64": "0.1.0",
+    "@brain0/cli-darwin-arm64": "0.1.0"
+  }
+}

package/src/lib.mjs

@@ -0,0 +1,72 @@
+/**
+ * Pure helpers for the `brain0` npm CLI (no I/O, unit-tested): repo-id inference from a git
+ * remote, argument parsing, and the shared repo-id validation mirrored from the server.
+ */
+
+/** Legal repo id (mirrors the server's refresh validation — keep in sync). */
+export const REPO_RE = /^[A-Za-z0-9._/-]+$/;
+
+/** Replace illegal characters and strip leading dashes so the result always passes REPO_RE. */
+export function sanitizeRepoId(raw) {
+  const cleaned = String(raw)
+    .replace(/[^A-Za-z0-9._/-]+/g, "-")
+    .replace(/^-+/, "");
+  return cleaned || "repo";
+}
+
+/**
+ * Infer a stable repo id from the git remote URL, falling back to the directory name.
+ * Handles the common shapes:
+ *   git@github.com:owner/repo.git · ssh://git@host/owner/repo.git
+ *   https://host/owner/repo(.git) · https://host/group/sub/repo (GitLab nesting)
+ */
+export function inferRepoId(remoteUrl, dirName) {
+  const url = (remoteUrl ?? "").trim();
+  if (url) {
+    let path = "";
+    const scp = url.match(/^[\w.+-]+@[^:/]+:(.+)$/); // git@host:owner/repo.git
+    if (scp) {
+      path = scp[1];
+    } else {
+      try {
+        path = new URL(url).pathname; // ssh:// https:// git:// file://
+      } catch {
+        path = "";
+      }
+    }
+    path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/, "");
+    if (path) {
+      // Keep the last two segments (owner/repo) — enough identity without host noise.
+      const segs = path.split("/").filter(Boolean);
+      const id = segs.slice(-2).join("/");
+      if (id && REPO_RE.test(id) && !id.startsWith("-")) return id;
+      return sanitizeRepoId(id);
+    }
+  }
+  return sanitizeRepoId(dirName ?? "repo");
+}
+
+/**
+ * Minimal argv parser: `--flag` booleans, `--opt value` pairs, everything else positional.
+ * `optNames` decides which --names consume a value; unknown --names are flags.
+ */
+export function parseArgs(argv, optNames) {
+  const takesValue = new Set(optNames);
+  const flags = new Set();
+  const opts = new Map();
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const name = a.slice(2);
+      if (takesValue.has(name) && i + 1 < argv.length) {
+        opts.set(name, argv[++i]);
+      } else {
+        flags.add(name);
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, opts, positional };
+}

package/vendor/gui/assets/BufferResource-VGpCfGWQ.js

@@ -0,0 +1,186 @@
+import{w as U,g,c,u as S,B as _,d as m,E as I,e as p}from"./index-QopGLZI_.js";const x={name:"local-uniform-bit",vertex:{header:`
+
+            struct LocalUniforms {
+                uTransformMatrix:mat3x3<f32>,
+                uColor:vec4<f32>,
+                uRound:f32,
+            }
+
+            @group(1) @binding(0) var<uniform> localUniforms : LocalUniforms;
+        `,main:`
+            vColor *= localUniforms.uColor;
+            modelMatrix *= localUniforms.uTransformMatrix;
+        `,end:`
+            if(localUniforms.uRound == 1)
+            {
+                vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
+            }
+        `}},C={...x,vertex:{...x.vertex,header:x.vertex.header.replace("group(1)","group(2)")}},D={name:"local-uniform-bit",vertex:{header:`
+
+            uniform mat3 uTransformMatrix;
+            uniform vec4 uColor;
+            uniform float uRound;
+        `,main:`
+            vColor *= uColor;
+            modelMatrix = uTransformMatrix;
+        `,end:`
+            if(uRound == 1.)
+            {
+                gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+            }
+        `}},O={name:"texture-bit",vertex:{header:`
+
+        struct TextureUniforms {
+            uTextureMatrix:mat3x3<f32>,
+        }
+
+        @group(2) @binding(2) var<uniform> textureUniforms : TextureUniforms;
+        `,main:`
+            uv = (textureUniforms.uTextureMatrix * vec3(uv, 1.0)).xy;
+        `},fragment:{header:`
+            @group(2) @binding(0) var uTexture: texture_2d<f32>;
+            @group(2) @binding(1) var uSampler: sampler;
+
+
+        `,main:`
+            outColor = textureSample(uTexture, uSampler, vUV);
+        `}},R={name:"texture-bit",vertex:{header:`
+            uniform mat3 uTextureMatrix;
+        `,main:`
+            uv = (uTextureMatrix * vec3(uv, 1.0)).xy;
+        `},fragment:{header:`
+        uniform sampler2D uTexture;
+
+
+        `,main:`
+            outColor = texture(uTexture, vUV);
+        `}};function A(e,t){for(const a in e.attributes){const s=e.attributes[a],r=t[a];r?(s.format??(s.format=r.format),s.offset??(s.offset=r.offset),s.instance??(s.instance=r.instance)):U(`Attribute ${a} is not present in the shader, but is present in the geometry. Unable to infer attribute details.`)}M(e)}function M(e){const{buffers:t,attributes:a}=e,s={},r={};for(const n in t){const o=t[n];s[o.uid]=0,r[o.uid]=0}for(const n in a){const o=a[n];s[o.buffer.uid]+=g(o.format).stride}for(const n in a){const o=a[n];o.stride??(o.stride=s[o.buffer.uid]),o.start??(o.start=r[o.buffer.uid]),r[o.buffer.uid]+=g(o.format).stride}}const d=[];d[c.NONE]=void 0;d[c.DISABLED]={stencilWriteMask:0,stencilReadMask:0};d[c.RENDERING_MASK_ADD]={stencilFront:{compare:"equal",passOp:"increment-clamp"},stencilBack:{compare:"equal",passOp:"increment-clamp"}};d[c.RENDERING_MASK_REMOVE]={stencilFront:{compare:"equal",passOp:"decrement-clamp"},stencilBack:{compare:"equal",passOp:"decrement-clamp"}};d[c.MASK_ACTIVE]={stencilWriteMask:0,stencilFront:{compare:"equal",passOp:"keep"},stencilBack:{compare:"equal",passOp:"keep"}};d[c.INVERSE_MASK_ACTIVE]={stencilWriteMask:0,stencilFront:{compare:"not-equal",passOp:"keep"},stencilBack:{compare:"not-equal",passOp:"keep"}};class B{constructor(t){this._syncFunctionHash=Object.create(null),this._adaptor=t,this._systemCheck()}_systemCheck(){if(!S())throw new Error("Current environment does not allow unsafe-eval, please use pixi.js/unsafe-eval module to enable support.")}ensureUniformGroup(t){const a=this.getUniformGroupData(t);t.buffer||(t.buffer=new _({data:new Float32Array(a.layout.size/4),usage:m.UNIFORM|m.COPY_DST}))}getUniformGroupData(t){return this._syncFunctionHash[t._signature]||this._initUniformGroup(t)}_initUniformGroup(t){const a=t._signature;let s=this._syncFunctionHash[a];if(!s){const r=Object.keys(t.uniformStructures).map(l=>t.uniformStructures[l]),n=this._adaptor.createUboElements(r),o=this._generateUboSync(n.uboElements);s=this._syncFunctionHash[a]={layout:n,syncFunction:o}}return this._syncFunctionHash[a]}_generateUboSync(t){return this._adaptor.generateUboSync(t)}syncUniformGroup(t,a,s){const r=this.getUniformGroupData(t);t.buffer||(t.buffer=new _({data:new Float32Array(r.layout.size/4),usage:m.UNIFORM|m.COPY_DST}));let n=null;return a||(a=t.buffer.data,n=t.buffer.dataInt32),s||(s=0),r.syncFunction(t.uniforms,a,n,s),!0}updateUniformGroup(t){if(t.isStatic&&!t._dirtyId)return!1;t._dirtyId=0;const a=this.syncUniformGroup(t);return t.buffer.update(),a}destroy(){this._syncFunctionHash=null}}const h=[{type:"mat3x3<f32>",test:e=>e.value.a!==void 0,ubo:`
+            var matrix = uv[name].toArray(true);
+            data[offset] = matrix[0];
+            data[offset + 1] = matrix[1];
+            data[offset + 2] = matrix[2];
+            data[offset + 4] = matrix[3];
+            data[offset + 5] = matrix[4];
+            data[offset + 6] = matrix[5];
+            data[offset + 8] = matrix[6];
+            data[offset + 9] = matrix[7];
+            data[offset + 10] = matrix[8];
+        `,uniform:`
+            gl.uniformMatrix3fv(ud[name].location, false, uv[name].toArray(true));
+        `},{type:"vec4<f32>",test:e=>e.type==="vec4<f32>"&&e.size===1&&e.value.width!==void 0,ubo:`
+            v = uv[name];
+            data[offset] = v.x;
+            data[offset + 1] = v.y;
+            data[offset + 2] = v.width;
+            data[offset + 3] = v.height;
+        `,uniform:`
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height) {
+                cv[0] = v.x;
+                cv[1] = v.y;
+                cv[2] = v.width;
+                cv[3] = v.height;
+                gl.uniform4f(ud[name].location, v.x, v.y, v.width, v.height);
+            }
+        `},{type:"vec2<f32>",test:e=>e.type==="vec2<f32>"&&e.size===1&&e.value.x!==void 0,ubo:`
+            v = uv[name];
+            data[offset] = v.x;
+            data[offset + 1] = v.y;
+        `,uniform:`
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.x || cv[1] !== v.y) {
+                cv[0] = v.x;
+                cv[1] = v.y;
+                gl.uniform2f(ud[name].location, v.x, v.y);
+            }
+        `},{type:"vec4<f32>",test:e=>e.type==="vec4<f32>"&&e.size===1&&e.value.red!==void 0,ubo:`
+            v = uv[name];
+            data[offset] = v.red;
+            data[offset + 1] = v.green;
+            data[offset + 2] = v.blue;
+            data[offset + 3] = v.alpha;
+        `,uniform:`
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue || cv[3] !== v.alpha) {
+                cv[0] = v.red;
+                cv[1] = v.green;
+                cv[2] = v.blue;
+                cv[3] = v.alpha;
+                gl.uniform4f(ud[name].location, v.red, v.green, v.blue, v.alpha);
+            }
+        `},{type:"vec3<f32>",test:e=>e.type==="vec3<f32>"&&e.size===1&&e.value.red!==void 0,ubo:`
+            v = uv[name];
+            data[offset] = v.red;
+            data[offset + 1] = v.green;
+            data[offset + 2] = v.blue;
+        `,uniform:`
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue) {
+                cv[0] = v.red;
+                cv[1] = v.green;
+                cv[2] = v.blue;
+                gl.uniform3f(ud[name].location, v.red, v.green, v.blue);
+            }
+        `}];function k(e,t,a,s){const r=[`
+        var v = null;
+        var v2 = null;
+        var t = 0;
+        var index = 0;
+        var name = null;
+        var arrayOffset = null;
+    `];let n=0;for(let l=0;l<e.length;l++){const f=e[l],b=f.data.name;let y=!1,i=0;for(let u=0;u<h.length;u++)if(h[u].test(f.data)){i=f.offset/4,r.push(`name = "${b}";`,`offset += ${i-n};`,h[u][t]||h[u].ubo),y=!0;break}if(!y)if(f.data.size>1)i=f.offset/4,r.push(a(f,i-n));else{const u=s[f.data.type];i=f.offset/4,r.push(`
+                    v = uv.${b};
+                    offset += ${i-n};
+                    ${u};
+                `)}n=i}const o=r.join(`
+`);return new Function("uv","data","dataInt32","offset",o)}function v(e,t){return`
+        for (let i = 0; i < ${e*t}; i++) {
+            data[offset + (((i / ${e})|0) * 4) + (i % ${e})] = v[i];
+        }
+    `}const F={f32:`
+        data[offset] = v;`,i32:`
+        dataInt32[offset] = v;`,"vec2<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];`,"vec3<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];`,"vec4<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];`,"vec2<i32>":`
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];`,"vec3<i32>":`
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];
+        dataInt32[offset + 2] = v[2];`,"vec4<i32>":`
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];
+        dataInt32[offset + 2] = v[2];
+        dataInt32[offset + 3] = v[3];`,"mat2x2<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 4] = v[2];
+        data[offset + 5] = v[3];`,"mat3x3<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 4] = v[3];
+        data[offset + 5] = v[4];
+        data[offset + 6] = v[5];
+        data[offset + 8] = v[6];
+        data[offset + 9] = v[7];
+        data[offset + 10] = v[8];`,"mat4x4<f32>":`
+        for (let i = 0; i < 16; i++) {
+            data[offset + i] = v[i];
+        }`,"mat3x2<f32>":v(3,2),"mat4x2<f32>":v(4,2),"mat2x3<f32>":v(2,3),"mat4x3<f32>":v(4,3),"mat2x4<f32>":v(2,4),"mat3x4<f32>":v(3,4)},w={...F,"mat2x2<f32>":`
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];
+    `};class P extends I{constructor({buffer:t,offset:a,size:s}){super(),this.uid=p("buffer"),this._resourceType="bufferResource",this._touched=0,this._resourceId=p("resource"),this._bufferResource=!0,this.destroyed=!1,this.buffer=t,this.offset=a|0,this.size=s,this.buffer.on("change",this.onBufferChange,this)}onBufferChange(){this._resourceId=p("resource"),this.emit("change",this)}destroy(t=!1){this.destroyed=!0,t&&this.buffer.destroy(),this.emit("change",this),this.buffer=null,this.removeAllListeners()}}export{P as B,d as G,B as U,x as a,F as b,k as c,h as d,A as e,D as f,R as g,C as l,O as t,w as u};
+//# sourceMappingURL=BufferResource-VGpCfGWQ.js.map