@cimplify/cli 0.15.3 → 0.17.0

package/dist/chunk-N2WZJX5P.mjs

@@ -0,0 +1,1989 @@
+#!/usr/bin/env node
+import { encodeChunk } from './chunk-EYEMPIMP.mjs';
+import { SDK_PACKAGE, PINNED_TYPESCRIPT_VERSION, PINNED_SDK_VERSION, LIBRARY_ALLOWLIST } from './chunk-BGM7CH5G.mjs';
+import { isDigest, sha256, compareStrings } from './chunk-25ZPFHLF.mjs';
+import { diagnostic } from './chunk-SGT5IJVW.mjs';
+import { authConfigDir } from './chunk-GGPN4QYQ.mjs';
+import { randomBytes, createHash } from 'crypto';
+import { existsSync, readFileSync, promises, realpathSync, mkdirSync, writeFileSync, renameSync } from 'fs';
+import path4 from 'path';
+import { FULL_ENGINE_VARIANT, TEXT_DICTIONARIES_FILE, ENGINE_AUDIO_UNIT, ENGINE_LUAU_UNIT, ENGINE_CORE_GL_UNIT, ENGINE_CORE_SCRIPTS_UNIT, AUDIO_WORKLET_FILE, LUAU_VM_FILE, isScriptsVariant, isShadersVariant, SCRIPTS_SHADERS_ENGINE_VARIANT, SCRIPTS_ENGINE_VARIANT, glVariantOf, threadedVariantOf, ENGINE_EXPORT_PROTOTYPES } from '@cimplify/sdk/interactives';
+import { buildSync, transformSync } from 'esbuild';
+import ts from 'typescript';
+import os from 'os';
+import { pathToFileURL, fileURLToPath } from 'url';
+
+var LICENSEE_SECTION = "cimplify.licensee";
+var ENGINE_CACHE_DIR = "engine-runtime";
+var CACHE_OBJECTS_DIR = "objects";
+var CACHE_VERSIONS_DIR = "versions";
+var CACHE_CURRENT_FILE = "current.json";
+var WASM_MAGIC = [0, 97, 115, 109];
+var WASM_HEADER_BYTES = 8;
+var CUSTOM_SECTION_ID = 0;
+var LEB_PAYLOAD_BITS = 7;
+var LEB_PAYLOAD_MASK = 127;
+var LEB_CONTINUE = 128;
+var LEB_U32_MAX_BYTES = 5;
+var TEMP_PREFIX = ".tmp-";
+var TEMP_SUFFIX_BYTES = 6;
+var PATH_SEPARATOR = "/";
+var VERSION_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var UNSAFE_SEGMENTS = /* @__PURE__ */ new Set(["", ".", ".."]);
+var ON_DEMAND_PREFIX = "tools/";
+var ON_DEMAND_INDEX_SUFFIX = ".json";
+function isWasm(bytes) {
+  return bytes.length >= WASM_HEADER_BYTES && WASM_MAGIC.every((b, i) => bytes[i] === b);
+}
+function leb(bytes, at2) {
+  let value = 0;
+  for (let i = 0; i < LEB_U32_MAX_BYTES; i++) {
+    const byte = bytes[at2 + i];
+    if (byte === void 0) throw new Error("the engine runtime wasm ends inside a section header");
+    value += (byte & LEB_PAYLOAD_MASK) * 2 ** (LEB_PAYLOAD_BITS * i);
+    if ((byte & LEB_CONTINUE) === 0) return { value, next: at2 + i + 1 };
+  }
+  throw new Error("the engine runtime wasm has an oversized section length");
+}
+function stripLicenseeSection(bytes) {
+  if (!isWasm(bytes)) return bytes;
+  const kept = [bytes.subarray(0, WASM_HEADER_BYTES)];
+  let stripped = false;
+  let at2 = WASM_HEADER_BYTES;
+  while (at2 < bytes.length) {
+    const start = at2;
+    const id = bytes[at2];
+    const size = leb(bytes, at2 + 1);
+    const end = size.next + size.value;
+    if (end > bytes.length) throw new Error("the engine runtime wasm has a section past its end");
+    if (id === CUSTOM_SECTION_ID) {
+      const name = leb(bytes, size.next);
+      if (name.next + name.value > end) throw new Error("the engine runtime wasm has a custom section name past its section");
+      if (new TextDecoder().decode(bytes.subarray(name.next, name.next + name.value)) === LICENSEE_SECTION) {
+        stripped = true;
+        at2 = end;
+        continue;
+      }
+    }
+    kept.push(bytes.subarray(start, end));
+    at2 = end;
+  }
+  return stripped ? Buffer.concat(kept) : bytes;
+}
+function engineCacheRoot() {
+  return path4.join(authConfigDir(), ENGINE_CACHE_DIR);
+}
+function safeRelative(file) {
+  if (file.includes("\\") || path4.isAbsolute(file)) return false;
+  return file.split(PATH_SEPARATOR).every((segment) => !UNSAFE_SEGMENTS.has(segment));
+}
+function validManifest(manifest) {
+  return typeof manifest.version === "string" && VERSION_SHAPE.test(manifest.version) && Array.isArray(manifest.files) && manifest.files.length > 0 && manifest.files.every((f) => typeof f.path === "string" && safeRelative(f.path) && isDigest(f.sha256) && Number.isInteger(f.bytes) && f.bytes >= 0);
+}
+function cachedEngineRuntimeDir(root = engineCacheRoot()) {
+  const current = path4.join(root, CACHE_CURRENT_FILE);
+  if (!existsSync(current)) return null;
+  let version;
+  try {
+    version = JSON.parse(readFileSync(current, "utf8")).version;
+  } catch {
+    return null;
+  }
+  if (typeof version !== "string" || !VERSION_SHAPE.test(version)) return null;
+  const dir = path4.join(root, CACHE_VERSIONS_DIR, version);
+  return existsSync(dir) ? dir : null;
+}
+function cachedVersion(root, version) {
+  const dir = path4.join(root, CACHE_VERSIONS_DIR, version);
+  return cachedEngineRuntimeDir(root) === dir ? dir : null;
+}
+function temporary(dir) {
+  return path4.join(dir, `${TEMP_PREFIX}${process.pid}-${randomBytes(TEMP_SUFFIX_BYTES).toString("hex")}`);
+}
+async function writeAtomically(file, bytes) {
+  await promises.mkdir(path4.dirname(file), { recursive: true });
+  const staged = temporary(path4.dirname(file));
+  await promises.writeFile(staged, bytes);
+  await promises.rename(staged, file);
+}
+function canonicalBytes(file, downloaded) {
+  const canonical2 = stripLicenseeSection(downloaded);
+  if (canonical2.length !== file.bytes || sha256(canonical2) !== file.sha256) {
+    throw new Error(`the downloaded engine runtime file ${file.path} does not match its published digest ${file.sha256}`);
+  }
+  return canonical2;
+}
+function onDemandRuntimeFile(file) {
+  return file.startsWith(ON_DEMAND_PREFIX) && !file.endsWith(ON_DEMAND_INDEX_SUFFIX);
+}
+async function storeRuntime(root, manifest, download) {
+  const objects = path4.join(root, CACHE_OBJECTS_DIR);
+  const eager = manifest.files.filter((f) => !onDemandRuntimeFile(f.path));
+  for (const file of eager) {
+    const object = path4.join(objects, file.sha256);
+    if (existsSync(object)) continue;
+    await writeAtomically(object, canonicalBytes(file, await download(file)));
+  }
+  const versions = path4.join(root, CACHE_VERSIONS_DIR);
+  const target = path4.join(versions, manifest.version);
+  if (!existsSync(target)) {
+    const staged = temporary(versions);
+    for (const file of eager) {
+      const out = path4.join(staged, ...file.path.split(PATH_SEPARATOR));
+      await promises.mkdir(path4.dirname(out), { recursive: true });
+      await promises.copyFile(path4.join(objects, file.sha256), out);
+    }
+    try {
+      await promises.rename(staged, target);
+    } catch (error) {
+      await promises.rm(staged, { recursive: true, force: true });
+      if (!existsSync(target)) throw error;
+    }
+  }
+  await writeAtomically(path4.join(root, CACHE_CURRENT_FILE), `${JSON.stringify({ version: manifest.version })}
+`);
+  return target;
+}
+var COMPILER_OPTIONS = { allowJs: true, checkJs: false, noLib: true, noResolve: true, target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext, types: [] };
+function literalOf(node) {
+  if (node === void 0) return null;
+  if (ts.isNumericLiteral(node)) return node.getText();
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return "true";
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return "false";
+  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) return `-${node.operand.getText()}`;
+  if (ts.isParenthesizedExpression(node)) return literalOf(node.expression);
+  return null;
+}
+function isAssignmentOperator(kind) {
+  return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+function assignedValue(node) {
+  const parent = node.parent;
+  if (ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
+    return parent.operatorToken.kind === ts.SyntaxKind.EqualsToken ? parent.right : null;
+  }
+  if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) return null;
+  if ((ts.isForInStatement(parent.parent) || ts.isForOfStatement(parent.parent)) && parent === parent.parent.initializer) return null;
+  if (ts.isShorthandPropertyAssignment(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) {
+    let up = parent;
+    while (ts.isArrayLiteralExpression(up) || ts.isObjectLiteralExpression(up) || ts.isShorthandPropertyAssignment(up) || ts.isPropertyAssignment(up) || ts.isSpreadElement(up)) up = up.parent;
+    if (ts.isBinaryExpression(up) && up.operatorToken.kind === ts.SyntaxKind.EqualsToken && up.left.pos <= node.pos && node.end <= up.left.end) return null;
+  }
+  return void 0;
+}
+function isReference(node) {
+  const parent = node.parent;
+  if (ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node) return false;
+  if ((ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isGetAccessor(parent) || ts.isSetAccessor(parent)) && parent.name === node) return false;
+  if (ts.isExportSpecifier(parent) || ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent)) return false;
+  if (ts.isLabeledStatement(parent) || ts.isBreakOrContinueStatement(parent)) return false;
+  if (ts.isVariableDeclaration(parent) && parent.name === node) return false;
+  if ((ts.isFunctionDeclaration(parent) || ts.isClassDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isClassExpression(parent) || ts.isParameter(parent)) && parent.name === node) return false;
+  if (ts.isBindingElement(parent)) return false;
+  return true;
+}
+function program(fileName, code) {
+  const file = ts.createSourceFile(fileName, code, ts.ScriptTarget.ES2022, true, ts.ScriptKind.JS);
+  const host = {
+    getSourceFile: (name) => name === fileName ? file : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "",
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (name) => name === fileName,
+    readFile: (name) => name === fileName ? code : void 0
+  };
+  const built2 = ts.createProgram({ rootNames: [fileName], options: COMPILER_OPTIONS, host });
+  return { checker: built2.getTypeChecker(), file };
+}
+function topLevelVariables(file, checker) {
+  const out = /* @__PURE__ */ new Map();
+  for (const statement of file.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    if ((statement.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const | ts.NodeFlags.Using)) !== 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name)) continue;
+      const symbol = checker.getSymbolAtLocation(declaration.name);
+      if (symbol === void 0 || (symbol.declarations?.length ?? 0) !== 1) continue;
+      const literal = literalOf(declaration.initializer);
+      out.set(symbol, { writes: declaration.initializer === void 0 ? 0 : 1, literal, reads: [] });
+    }
+  }
+  return out;
+}
+function inlineModuleConstants(code, fileName = "bundle.js") {
+  const { checker, file } = program(fileName, code);
+  const candidates = topLevelVariables(file, checker);
+  if (candidates.size === 0) return { code, inlined: 0, constants: 0 };
+  const visit = (node) => {
+    if (ts.isIdentifier(node) && !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)) {
+      const shorthand = ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+      const symbol = shorthand ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+      const candidate = symbol === void 0 ? void 0 : candidates.get(symbol);
+      if (candidate !== void 0) {
+        const written = assignedValue(node);
+        if (written !== void 0) {
+          candidate.writes++;
+          candidate.literal = candidate.writes === 1 && written !== null ? literalOf(written) : null;
+        } else if (shorthand || isReference(node)) {
+          candidate.reads.push(node);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(file, visit);
+  const edits = [];
+  let constants = 0;
+  for (const candidate of candidates.values()) {
+    if (candidate.writes !== 1 || candidate.literal === null || candidate.reads.length === 0) continue;
+    constants++;
+    for (const read of candidate.reads) {
+      const at2 = read.getStart(file);
+      const text = ts.isShorthandPropertyAssignment(read.parent) ? `${read.text}: (${candidate.literal})` : `(${candidate.literal})`;
+      edits.push({ at: at2, end: read.end, text });
+    }
+  }
+  if (edits.length === 0) return { code, inlined: 0, constants: 0 };
+  edits.sort((a, b) => b.at - a.at);
+  let out = code;
+  for (const edit of edits) out = out.slice(0, edit.at) + edit.text + out.slice(edit.end);
+  return { code: out, inlined: edits.length, constants };
+}
+
+// src/interactives/build/engine-abi.ts
+var WASM_HEADER_BYTES2 = 8;
+var IMPORT_SECTION = 2;
+var KIND_FUNCTION = 0;
+var KIND_TABLE = 1;
+var KIND_MEMORY = 2;
+var KIND_GLOBAL = 3;
+var LIMITS_HAS_MAX = 1;
+var LIMITS_SHARED = 2;
+var LEB_PAYLOAD = 127;
+var LEB_CONTINUE2 = 128;
+var LEB_STEP = 7;
+var ABI_EXPORT = "engine_abi_version";
+var MEMORY_MODULE = "env";
+var MEMORY_FIELD = "memory";
+var FUNCTION_IMPORT = "function";
+var PROTOTYPE_EXPORT = "engine_export_prototype_of";
+var ALLOC_EXPORT = "engine_alloc";
+var ENGINE_PREFIX = /^engine_[a-z0-9_]+$/;
+var NAME_CAPACITY = 64;
+var NAME_ALIGN = 8;
+var NULL = 0;
+var NO_PROTOTYPE = 0;
+var WASM = globalThis.WebAssembly;
+var Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  bytes;
+  at = WASM_HEADER_BYTES2;
+  get done() {
+    return this.at >= this.bytes.length;
+  }
+  byte() {
+    if (this.at >= this.bytes.length) throw new Error("the engine module is truncated");
+    return this.bytes[this.at++];
+  }
+  u32() {
+    let value = 0;
+    let shift = 0;
+    for (; ; ) {
+      const b = this.byte();
+      value += (b & LEB_PAYLOAD) * 2 ** shift;
+      if ((b & LEB_CONTINUE2) === 0) return value;
+      shift += LEB_STEP;
+    }
+  }
+  name() {
+    const length = this.u32();
+    const text = new TextDecoder().decode(this.bytes.subarray(this.at, this.at + length));
+    this.at += length;
+    return text;
+  }
+  limits() {
+    const flags = this.byte();
+    const initial = this.u32();
+    if ((flags & LIMITS_HAS_MAX) === 0) return { initial };
+    const maximum = this.u32();
+    return (flags & LIMITS_SHARED) === 0 ? { initial, maximum } : { initial, maximum, shared: true };
+  }
+};
+function importedMemory(bytes) {
+  const reader = new Reader(bytes);
+  while (!reader.done) {
+    const id = reader.byte();
+    const size = reader.u32();
+    const end = reader.at + size;
+    if (id !== IMPORT_SECTION) {
+      reader.at = end;
+      continue;
+    }
+    const count = reader.u32();
+    for (let i = 0; i < count; i++) {
+      const module = reader.name();
+      const field = reader.name();
+      const kind = reader.byte();
+      if (kind === KIND_FUNCTION) reader.u32();
+      else if (kind === KIND_TABLE) {
+        reader.byte();
+        reader.limits();
+      } else if (kind === KIND_MEMORY) {
+        const limits = reader.limits();
+        if (module === MEMORY_MODULE && field === MEMORY_FIELD) return limits;
+      } else if (kind === KIND_GLOBAL) {
+        reader.byte();
+        reader.byte();
+      } else throw new Error(`the engine module has an unknown import kind ${kind}`);
+    }
+    return null;
+  }
+  return null;
+}
+var UNBOUND = () => 0;
+function unboundImports(module) {
+  const imports = {};
+  for (const entry of WASM.Module.imports(module)) {
+    if (entry.kind !== FUNCTION_IMPORT) continue;
+    imports[entry.module] ??= {};
+    imports[entry.module][entry.name] = UNBOUND;
+  }
+  return imports;
+}
+function instantiate(bytes) {
+  const module = new WASM.Module(bytes);
+  const limits = importedMemory(bytes);
+  const imports = unboundImports(module);
+  const imported = limits === null ? null : new WASM.Memory(limits);
+  if (imported !== null) {
+    imports[MEMORY_MODULE] ??= {};
+    imports[MEMORY_MODULE][MEMORY_FIELD] = imported;
+  }
+  const instance = new WASM.Instance(module, imports);
+  const exported = instance.exports[MEMORY_FIELD];
+  return { module, exports: instance.exports, memory: imported ?? exported ?? null };
+}
+function engineExportTable(bytes, fallback) {
+  const { module, exports, memory } = instantiate(bytes);
+  const query = exports[PROTOTYPE_EXPORT];
+  const alloc = exports[ALLOC_EXPORT];
+  const table = /* @__PURE__ */ new Map();
+  const names = WASM.Module.exports(module).filter((entry) => entry.kind === FUNCTION_IMPORT && ENGINE_PREFIX.test(entry.name)).map((entry) => entry.name).sort();
+  const scratch = typeof query === "function" && typeof alloc === "function" && memory !== null ? alloc(NAME_CAPACITY, NAME_ALIGN) : NULL;
+  for (const name of names) {
+    let prototype = NO_PROTOTYPE;
+    if (scratch !== NULL && memory !== null) {
+      new Uint8Array(memory.buffer, scratch, NAME_CAPACITY).set(new TextEncoder().encode(name).subarray(0, NAME_CAPACITY));
+      prototype = query(scratch, name.length) >>> 0;
+    } else prototype = fallback[name] ?? NO_PROTOTYPE;
+    if (prototype !== NO_PROTOTYPE) table.set(name, prototype);
+  }
+  return table;
+}
+function engineAbiVersion(bytes) {
+  const instance = instantiate(bytes);
+  const version = instance.exports[ABI_EXPORT];
+  if (typeof version !== "function") throw new Error(`the engine module does not export ${ABI_EXPORT}`);
+  const abi = version();
+  if (!Number.isInteger(abi) || abi < 0) throw new Error(`the engine module reports ABI ${abi}`);
+  return abi >>> 0;
+}
+var BROWSER_CONDITIONS = ["browser", "import", "module", "default"];
+var NODE_CONDITIONS = ["node", "import", "module", "default"];
+function findPackageDir(start, name) {
+  let dir = start;
+  for (; ; ) {
+    const candidate = path4.join(dir, "node_modules", ...name.split("/"));
+    if (existsSync(path4.join(candidate, "package.json"))) return realpathSync(candidate);
+    const parent = path4.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readPackageJson(dir) {
+  return JSON.parse(readFileSync(path4.join(dir, "package.json"), "utf8"));
+}
+function pickTarget(target, conditions) {
+  if (target === void 0 || target === null) return null;
+  if (typeof target === "string") return target;
+  for (const condition of conditions) {
+    const hit = pickTarget(target[condition], conditions);
+    if (hit !== null) return hit;
+  }
+  return null;
+}
+function exportsMap(pkg) {
+  const exp = pkg.exports;
+  if (exp === void 0 || exp === null) return null;
+  if (typeof exp === "string") return { ".": exp };
+  const keys = Object.keys(exp);
+  if (keys.length > 0 && keys[0].startsWith(".")) return exp;
+  return { ".": exp };
+}
+function exportTarget(pkg, subpath, conditions) {
+  const map = exportsMap(pkg);
+  if (map !== null) return pickTarget(map[subpath], conditions);
+  return subpath === "." ? pkg.module ?? pkg.main ?? null : null;
+}
+function resolveExport(dir, subpath, conditions) {
+  const target = exportTarget(readPackageJson(dir), subpath, conditions);
+  if (target === null) return null;
+  const file = path4.resolve(dir, target);
+  return existsSync(file) ? file : null;
+}
+function stripDotSlash(target) {
+  return target.startsWith("./") ? target.slice(2) : target;
+}
+
+// src/interactives/build/forks/fork.ts
+var FORK_ROOT = "cimplify-forks";
+var DIGEST_HEX = 32;
+function occurrences(text, find) {
+  let count = 0;
+  for (let at2 = text.indexOf(find); at2 >= 0; at2 = text.indexOf(find, at2 + find.length)) count++;
+  return count;
+}
+function patchAfter(fork, file, source, patch, after) {
+  const anchor = source.indexOf(after);
+  if (anchor < 0 || occurrences(source, after) !== 1) throw new Error(`the ${fork.library} fork expects one ${JSON.stringify(after)} in ${file}`);
+  const at2 = source.indexOf(patch.find, anchor);
+  if (at2 < 0) throw new Error(`the ${fork.library} fork finds no ${JSON.stringify(patch.find.slice(0, 80))} after ${JSON.stringify(after)} in ${file}`);
+  return source.slice(0, at2) + patch.replace + source.slice(at2 + patch.find.length);
+}
+function patchSource(fork, file, source) {
+  let out = source;
+  for (const patch of fork.patches) {
+    if (patch.file !== file) continue;
+    if (patch.after !== void 0) {
+      out = patchAfter(fork, file, out, patch, patch.after);
+      continue;
+    }
+    const expected = patch.count ?? 1;
+    const found = occurrences(out, patch.find);
+    if (found !== expected) {
+      throw new Error(`the ${fork.library} fork expects ${expected} matches in ${file} for ${JSON.stringify(patch.find.slice(0, 80))}, found ${found}`);
+    }
+    out = out.split(patch.find).join(patch.replace);
+  }
+  return out;
+}
+function forkedEntry(fork, packageDir) {
+  const installed = readPackageJson(packageDir).version;
+  if (installed !== fork.version) throw new Error(`the ${fork.library} fork patches ${fork.version}; ${installed ?? "an unknown version"} is installed`);
+  const sources = fork.files.map((file) => readFileSync(path4.join(packageDir, file), "utf8"));
+  const patched = fork.files.map((file, i) => patchSource(fork, file, sources[i]));
+  const digest = createHash("sha256");
+  for (let i = 0; i < patched.length; i++) digest.update(fork.files[i]).update("\0").update(patched[i]).update("\0");
+  const dir = path4.join(os.tmpdir(), FORK_ROOT, `${fork.library}@${fork.version}-${digest.digest("hex").slice(0, DIGEST_HEX)}`);
+  const entry = path4.join(dir, fork.entry);
+  if (existsSync(entry)) return entry;
+  const order = fork.files.map((_, i) => i).sort((a, b) => Number(fork.files[a] === fork.entry) - Number(fork.files[b] === fork.entry));
+  for (const i of order) {
+    const target = path4.join(dir, fork.files[i]);
+    mkdirSync(path4.dirname(target), { recursive: true });
+    const staging = `${target}.${process.pid}`;
+    writeFileSync(staging, patched[i]);
+    renameSync(staging, target);
+  }
+  return entry;
+}
+
+// src/interactives/build/forks/three.ts
+var CORE = "build/three.core.js";
+var MODULE = "build/three.module.js";
+var PATCHES = [
+  {
+    file: CORE,
+    find: `class Frustum {`,
+    replace: `const _cimplifyPlaneScratch = new Float64Array( 4 );
+
+function _cimplifyPlaneStore( plane, s ) {
+
+	const inverse = 1.0 / Math.sqrt( s[ 0 ] * s[ 0 ] + s[ 1 ] * s[ 1 ] + s[ 2 ] * s[ 2 ] );
+	const normal = plane.normal;
+	normal.x = s[ 0 ] * inverse;
+	normal.y = s[ 1 ] * inverse;
+	normal.z = s[ 2 ] * inverse;
+	plane.constant = s[ 3 ] * inverse;
+
+}
+
+class Frustum {`
+  },
+  {
+    file: CORE,
+    find: `		planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
+		planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
+		planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
+		planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
+
+		if ( reversedDepth ) {
+
+			planes[ 4 ].setComponents( me2, me6, me10, me14 ).normalize(); // far
+			planes[ 5 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize(); // near
+
+		} else {
+
+			planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize(); // far
+
+			if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+				planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize(); // near
+
+			} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+				planes[ 5 ].setComponents( me2, me6, me10, me14 ).normalize(); // near
+
+			} else {
+
+				throw new Error( 'THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem );
+
+			}
+
+		}`,
+    replace: `		_cimplifyPlaneScratch[ 0 ] = me3 - me0; _cimplifyPlaneScratch[ 1 ] = me7 - me4; _cimplifyPlaneScratch[ 2 ] = me11 - me8; _cimplifyPlaneScratch[ 3 ] = me15 - me12; _cimplifyPlaneStore( planes[ 0 ], _cimplifyPlaneScratch );
+		_cimplifyPlaneScratch[ 0 ] = me3 + me0; _cimplifyPlaneScratch[ 1 ] = me7 + me4; _cimplifyPlaneScratch[ 2 ] = me11 + me8; _cimplifyPlaneScratch[ 3 ] = me15 + me12; _cimplifyPlaneStore( planes[ 1 ], _cimplifyPlaneScratch );
+		_cimplifyPlaneScratch[ 0 ] = me3 + me1; _cimplifyPlaneScratch[ 1 ] = me7 + me5; _cimplifyPlaneScratch[ 2 ] = me11 + me9; _cimplifyPlaneScratch[ 3 ] = me15 + me13; _cimplifyPlaneStore( planes[ 2 ], _cimplifyPlaneScratch );
+		_cimplifyPlaneScratch[ 0 ] = me3 - me1; _cimplifyPlaneScratch[ 1 ] = me7 - me5; _cimplifyPlaneScratch[ 2 ] = me11 - me9; _cimplifyPlaneScratch[ 3 ] = me15 - me13; _cimplifyPlaneStore( planes[ 3 ], _cimplifyPlaneScratch );
+
+		if ( reversedDepth ) {
+
+			_cimplifyPlaneScratch[ 0 ] = me2; _cimplifyPlaneScratch[ 1 ] = me6; _cimplifyPlaneScratch[ 2 ] = me10; _cimplifyPlaneScratch[ 3 ] = me14; _cimplifyPlaneStore( planes[ 4 ], _cimplifyPlaneScratch ); // far
+			_cimplifyPlaneScratch[ 0 ] = me3 - me2; _cimplifyPlaneScratch[ 1 ] = me7 - me6; _cimplifyPlaneScratch[ 2 ] = me11 - me10; _cimplifyPlaneScratch[ 3 ] = me15 - me14; _cimplifyPlaneStore( planes[ 5 ], _cimplifyPlaneScratch ); // near
+
+		} else {
+
+			_cimplifyPlaneScratch[ 0 ] = me3 - me2; _cimplifyPlaneScratch[ 1 ] = me7 - me6; _cimplifyPlaneScratch[ 2 ] = me11 - me10; _cimplifyPlaneScratch[ 3 ] = me15 - me14; _cimplifyPlaneStore( planes[ 4 ], _cimplifyPlaneScratch ); // far
+
+			if ( coordinateSystem === WebGLCoordinateSystem ) {
+
+				_cimplifyPlaneScratch[ 0 ] = me3 + me2; _cimplifyPlaneScratch[ 1 ] = me7 + me6; _cimplifyPlaneScratch[ 2 ] = me11 + me10; _cimplifyPlaneScratch[ 3 ] = me15 + me14; _cimplifyPlaneStore( planes[ 5 ], _cimplifyPlaneScratch ); // near
+
+			} else if ( coordinateSystem === WebGPUCoordinateSystem ) {
+
+				_cimplifyPlaneScratch[ 0 ] = me2; _cimplifyPlaneScratch[ 1 ] = me6; _cimplifyPlaneScratch[ 2 ] = me10; _cimplifyPlaneScratch[ 3 ] = me14; _cimplifyPlaneStore( planes[ 5 ], _cimplifyPlaneScratch ); // near
+
+			} else {
+
+				throw new Error( 'THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem );
+
+			}
+
+		}`
+  },
+  {
+    file: MODULE,
+    find: `currentRenderList.push( object, geometry, material, groupOrder, _vector4.z, null, camera );`,
+    replace: `currentRenderList.push( object, geometry, material, groupOrder, _vector4, null, camera );`,
+    count: 2
+  },
+  {
+    file: MODULE,
+    find: `currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector4.z, group, camera );`,
+    replace: `currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector4, group, camera );`
+  },
+  {
+    file: MODULE,
+    find: `	function init() {
+
+		renderItemsIndex = 0;
+
+		opaque.length = 0;
+		transmissive.length = 0;
+		transparent.length = 0;
+
+	}
+
+`,
+    replace: `	let opaqueCount = 0;
+	let transmissiveCount = 0;
+	let transparentCount = 0;
+
+	function init() {
+
+		renderItemsIndex = 0;
+		opaqueCount = 0;
+		transmissiveCount = 0;
+		transparentCount = 0;
+
+	}
+
+`
+  },
+  {
+    file: MODULE,
+    find: `	function getNextRenderItem( object, geometry, material, groupOrder, z, group ) {
+
+		let renderItem = renderItems[ renderItemsIndex ];
+
+		if ( renderItem === undefined ) {
+
+			renderItem = {
+				id: object.id,
+				object: object,
+				geometry: geometry,
+				material: material,
+				materialVariant: materialVariant( object ),
+				groupOrder: groupOrder,
+				renderOrder: object.renderOrder,
+				z: z,
+				group: group
+			};
+
+			renderItems[ renderItemsIndex ] = renderItem;
+
+		} else {
+
+			renderItem.id = object.id;
+			renderItem.object = object;
+			renderItem.geometry = geometry;
+			renderItem.material = material;
+			renderItem.materialVariant = materialVariant( object );
+			renderItem.groupOrder = groupOrder;
+			renderItem.renderOrder = object.renderOrder;
+			renderItem.z = z;
+			renderItem.group = group;
+
+		}
+
+		renderItemsIndex ++;
+
+		return renderItem;
+
+	}
+
+	function push( object, geometry, material, groupOrder, z, group, camera ) {
+
+		// with a reversed depth buffer the projected z is inverted
+
+		if ( camera.reversedDepth === true ) z = - z;
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );
+
+		if ( material.transmission > 0.0 ) {
+
+			transmissive.push( renderItem );
+
+		} else if ( material.transparent === true ) {
+
+			transparent.push( renderItem );
+
+		} else {
+
+			opaque.push( renderItem );
+
+		}
+
+	}
+
+	function unshift( object, geometry, material, groupOrder, z, group ) {
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );
+
+		if ( material.transmission > 0.0 ) {
+
+			transmissive.unshift( renderItem );
+
+		} else if ( material.transparent === true ) {
+
+			transparent.unshift( renderItem );
+
+		} else {
+
+			opaque.unshift( renderItem );
+
+		}
+
+	}
+
+	function sort( customOpaqueSort, customTransparentSort ) {
+
+		if ( opaque.length > 1 ) opaque.sort( customOpaqueSort || painterSortStable );
+		if ( transmissive.length > 1 ) transmissive.sort( customTransparentSort || reversePainterSortStable );
+		if ( transparent.length > 1 ) transparent.sort( customTransparentSort || reversePainterSortStable );
+
+	}
+
+`,
+    replace: `	function getNextRenderItem( object, geometry, material, groupOrder, group ) {
+
+		let renderItem = renderItems[ renderItemsIndex ];
+
+		if ( renderItem === undefined ) {
+
+			renderItem = {
+				id: object.id,
+				object: object,
+				geometry: geometry,
+				material: material,
+				materialVariant: materialVariant( object ),
+				groupOrder: groupOrder,
+				renderOrder: object.renderOrder,
+				z: 0.5,
+				group: group
+			};
+
+			renderItems[ renderItemsIndex ] = renderItem;
+
+		} else {
+
+			renderItem.id = object.id;
+			renderItem.object = object;
+			renderItem.geometry = geometry;
+			renderItem.material = material;
+			renderItem.materialVariant = materialVariant( object );
+			renderItem.groupOrder = groupOrder;
+			renderItem.renderOrder = object.renderOrder;
+			renderItem.group = group;
+
+		}
+
+		renderItemsIndex ++;
+
+		return renderItem;
+
+	}
+
+	function file( renderItem, material ) {
+
+		if ( material.transmission > 0.0 ) {
+
+			transmissive[ transmissiveCount ++ ] = renderItem;
+
+		} else if ( material.transparent === true ) {
+
+			transparent[ transparentCount ++ ] = renderItem;
+
+		} else {
+
+			opaque[ opaqueCount ++ ] = renderItem;
+
+		}
+
+	}
+
+	function push( object, geometry, material, groupOrder, depth, group, camera ) {
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, group );
+		renderItem.z = camera.reversedDepth === true ? - depth.z : depth.z;
+		file( renderItem, material );
+
+	}
+
+	function insertFirst( list, count, renderItem ) {
+
+		for ( let i = count; i > 0; i -- ) list[ i ] = list[ i - 1 ];
+		list[ 0 ] = renderItem;
+
+	}
+
+	function unshift( object, geometry, material, groupOrder, z, group ) {
+
+		const renderItem = getNextRenderItem( object, geometry, material, groupOrder, group );
+		renderItem.z = z;
+
+		if ( material.transmission > 0.0 ) {
+
+			insertFirst( transmissive, transmissiveCount ++, renderItem );
+
+		} else if ( material.transparent === true ) {
+
+			insertFirst( transparent, transparentCount ++, renderItem );
+
+		} else {
+
+			insertFirst( opaque, opaqueCount ++, renderItem );
+
+		}
+
+	}
+
+	function sortList( list, compare ) {
+
+		for ( let i = 1, l = list.length; i < l; i ++ ) {
+
+			const item = list[ i ];
+			let j = i - 1;
+
+			while ( j >= 0 && compare( list[ j ], item ) > 0 ) {
+
+				list[ j + 1 ] = list[ j ];
+				j --;
+
+			}
+
+			list[ j + 1 ] = item;
+
+		}
+
+	}
+
+	function sort( customOpaqueSort, customTransparentSort ) {
+
+		if ( opaque.length > 1 ) sortList( opaque, customOpaqueSort || painterSortStable );
+		if ( transmissive.length > 1 ) sortList( transmissive, customTransparentSort || reversePainterSortStable );
+		if ( transparent.length > 1 ) sortList( transparent, customTransparentSort || reversePainterSortStable );
+
+	}
+
+`
+  },
+  {
+    file: MODULE,
+    find: `	function finish() {
+
+		// Clear references from inactive renderItems in the list
+`,
+    replace: `	function finish() {
+
+		if ( opaque.length !== opaqueCount ) opaque.length = opaqueCount;
+		if ( transmissive.length !== transmissiveCount ) transmissive.length = transmissiveCount;
+		if ( transparent.length !== transparentCount ) transparent.length = transparentCount;
+`
+  },
+  {
+    file: MODULE,
+    find: `		return a.z - b.z;`,
+    replace: `		return a.z < b.z ? - 1 : 1;`
+  },
+  {
+    file: MODULE,
+    find: `		return b.z - a.z;`,
+    replace: `		return b.z < a.z ? - 1 : 1;`
+  },
+  {
+    file: CORE,
+    find: `	setFromMatrix4( m ) {
+
+		const me = m.elements;
+
+		this.set(
+
+			me[ 0 ], me[ 4 ], me[ 8 ],
+			me[ 1 ], me[ 5 ], me[ 9 ],
+			me[ 2 ], me[ 6 ], me[ 10 ]
+
+		);
+
+		return this;
+
+	}`,
+    replace: `	setFromMatrix4( m ) {
+
+		const me = m.elements;
+		const te = this.elements;
+
+		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
+		te[ 3 ] = me[ 4 ]; te[ 4 ] = me[ 5 ]; te[ 5 ] = me[ 6 ];
+		te[ 6 ] = me[ 8 ]; te[ 7 ] = me[ 9 ]; te[ 8 ] = me[ 10 ];
+
+		return this;
+
+	}`
+  },
+  {
+    file: CORE,
+    find: `	normalize() {
+
+		return this.divideScalar( this.length() || 1 );
+
+	}`,
+    replace: `	normalize() {
+
+		const length = Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z ) || 1;
+		this.x /= length;
+		this.y /= length;
+		this.z /= length;
+		return this;
+
+	}`,
+    after: `class Vector3 {`
+  },
+  {
+    file: CORE,
+    find: `	determinantAffine() {`,
+    replace: `	_cimplifyDeterminantSign() {
+
+		const te = this.elements;
+		const n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ];
+		const n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ];
+		const n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ];
+		const det = n11 * ( n22 * n33 - n23 * n32 ) - n12 * ( n21 * n33 - n23 * n31 ) + n13 * ( n21 * n32 - n22 * n31 );
+		return det < 0 ? - 1 : det > 0 ? 1 : 0;
+
+	}
+
+	determinantAffine() {`
+  },
+  {
+    file: CORE,
+    find: `		const det = this.determinantAffine();
+
+		if ( det === 0 ) {
+
+			scale.set( 1, 1, 1 );
+			quaternion.identity();
+
+			return this;
+
+		}
+
+		let sx = _v1$7.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
+		const sy = _v1$7.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
+		const sz = _v1$7.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
+
+		// if determinant is negative, we need to invert one scale
+		if ( det < 0 ) sx = - sx;`,
+    replace: `		const sign = this._cimplifyDeterminantSign();
+
+		if ( sign === 0 ) {
+
+			scale.set( 1, 1, 1 );
+			quaternion.identity();
+
+			return this;
+
+		}
+
+		let sx = Math.sqrt( te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ] );
+		const sy = Math.sqrt( te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ] );
+		const sz = Math.sqrt( te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ] );
+
+		if ( sign < 0 ) sx = - sx;`
+  },
+  {
+    file: MODULE,
+    find: `object.matrixWorld.determinantAffine() < 0`,
+    replace: `object.matrixWorld._cimplifyDeterminantSign() < 0`
+  },
+  {
+    file: CORE,
+    find: `		this.radius = this.radius * matrix.getMaxScaleOnAxis();`,
+    replace: `		const te = matrix.elements;
+		const scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];
+		const scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];
+		const scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];
+		this.radius = this.radius * Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );`
+  },
+  {
+    file: MODULE,
+    find: `function shadowCastingAndTexturingLightsFirst( lightA, lightB ) {`,
+    replace: `function _cimplifySort( list, compare ) {
+
+	for ( let i = 1, l = list.length; i < l; i ++ ) {
+
+		const item = list[ i ];
+		let j = i - 1;
+
+		while ( j >= 0 && compare( list[ j ], item ) > 0 ) {
+
+			list[ j + 1 ] = list[ j ];
+			j --;
+
+		}
+
+		list[ j + 1 ] = item;
+
+	}
+
+}
+
+function shadowCastingAndTexturingLightsFirst( lightA, lightB ) {`
+  },
+  {
+    file: MODULE,
+    find: `		lights.sort( shadowCastingAndTexturingLightsFirst );`,
+    replace: `		_cimplifySort( lights, shadowCastingAndTexturingLightsFirst );`
+  },
+  {
+    file: MODULE,
+    find: `	function init( camera ) {
+
+		state.camera = camera;
+
+		lightsArray.length = 0;
+		shadowsArray.length = 0;
+		lightProbeGridArray.length = 0;
+
+	}
+
+	function pushLight( light ) {
+
+		lightsArray.push( light );
+
+	}
+
+	function pushShadow( shadowLight ) {
+
+		shadowsArray.push( shadowLight );
+
+	}
+
+	function pushLightProbeGrid( volume ) {
+
+		lightProbeGridArray.push( volume );
+
+	}
+
+	function setupLights() {
+
+		lights.setup( lightsArray );
+
+	}`,
+    replace: `	let lightsCount = 0;
+	let shadowsCount = 0;
+	let lightProbeGridCount = 0;
+
+	function init( camera ) {
+
+		state.camera = camera;
+
+		lightsCount = 0;
+		shadowsCount = 0;
+		lightProbeGridCount = 0;
+
+	}
+
+	function pushLight( light ) {
+
+		lightsArray[ lightsCount ++ ] = light;
+
+	}
+
+	function pushShadow( shadowLight ) {
+
+		shadowsArray[ shadowsCount ++ ] = shadowLight;
+
+	}
+
+	function pushLightProbeGrid( volume ) {
+
+		lightProbeGridArray[ lightProbeGridCount ++ ] = volume;
+
+	}
+
+	function finish() {
+
+		if ( lightsArray.length !== lightsCount ) lightsArray.length = lightsCount;
+		if ( shadowsArray.length !== shadowsCount ) shadowsArray.length = shadowsCount;
+		if ( lightProbeGridArray.length !== lightProbeGridCount ) lightProbeGridArray.length = lightProbeGridCount;
+
+	}
+
+	function setupLights() {
+
+		finish();
+		lights.setup( lightsArray );
+
+	}`
+  },
+  {
+    file: MODULE,
+    find: `		init: init,
+		state: state,
+		setupLights: setupLights,`,
+    replace: `		init: init,
+		finish: finish,
+		state: state,
+		setupLights: setupLights,`
+  },
+  {
+    file: MODULE,
+    find: `			currentRenderList.finish();`,
+    replace: `			currentRenderList.finish();
+			currentRenderState.finish();`
+  },
+  {
+    file: MODULE,
+    find: `function setValueV1f( gl, v ) {
+
+	const cache = this.cache;
+
+	if ( cache[ 0 ] === v ) return;
+
+	gl.uniform1f( this.addr, v );
+
+	cache[ 0 ] = v;
+
+}`,
+    replace: `const _cimplifyUniformScratch = new Float32Array( 4 );
+
+function setValueV1f( gl, v ) {
+
+	const cache = this._cimplifyCache;
+
+	if ( cache[ 0 ] === v ) return;
+
+	cache[ 0 ] = v;
+	_cimplifyUniformScratch[ 0 ] = v;
+	gl.uniform1fv( this.addr, _cimplifyUniformScratch, 0, 1 );
+
+}`
+  },
+  {
+    file: MODULE,
+    find: `		if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {
+
+			gl.uniform3f( this.addr, v.x, v.y, v.z );
+
+			cache[ 0 ] = v.x;
+			cache[ 1 ] = v.y;
+			cache[ 2 ] = v.z;
+
+		}
+
+	} else if ( v.r !== undefined ) {
+
+		if ( cache[ 0 ] !== v.r || cache[ 1 ] !== v.g || cache[ 2 ] !== v.b ) {
+
+			gl.uniform3f( this.addr, v.r, v.g, v.b );
+
+			cache[ 0 ] = v.r;
+			cache[ 1 ] = v.g;
+			cache[ 2 ] = v.b;
+
+		}`,
+    replace: `		const typed = this._cimplifyCache;
+
+		if ( typed[ 0 ] !== v.x || typed[ 1 ] !== v.y || typed[ 2 ] !== v.z ) {
+
+			typed[ 0 ] = v.x;
+			typed[ 1 ] = v.y;
+			typed[ 2 ] = v.z;
+			_cimplifyUniformScratch[ 0 ] = typed[ 0 ];
+			_cimplifyUniformScratch[ 1 ] = typed[ 1 ];
+			_cimplifyUniformScratch[ 2 ] = typed[ 2 ];
+			gl.uniform3fv( this.addr, _cimplifyUniformScratch, 0, 3 );
+
+		}
+
+	} else if ( v.r !== undefined ) {
+
+		const typed = this._cimplifyCache;
+
+		if ( typed[ 0 ] !== v.r || typed[ 1 ] !== v.g || typed[ 2 ] !== v.b ) {
+
+			typed[ 0 ] = v.r;
+			typed[ 1 ] = v.g;
+			typed[ 2 ] = v.b;
+			_cimplifyUniformScratch[ 0 ] = typed[ 0 ];
+			_cimplifyUniformScratch[ 1 ] = typed[ 1 ];
+			_cimplifyUniformScratch[ 2 ] = typed[ 2 ];
+			gl.uniform3fv( this.addr, _cimplifyUniformScratch, 0, 3 );
+
+		}`
+  },
+  {
+    file: MODULE,
+    find: `		uniforms.metalness.value = material.metalness;`,
+    replace: `		if ( uniforms.metalness.value !== material.metalness ) uniforms.metalness.value = material.metalness;`
+  },
+  {
+    file: MODULE,
+    find: `		uniforms.roughness.value = material.roughness;`,
+    replace: `		if ( uniforms.roughness.value !== material.roughness ) uniforms.roughness.value = material.roughness;`
+  },
+  {
+    file: MODULE,
+    find: `		this.cache = [];
+		this.type = activeInfo.type;
+		this.setValue = getSingularSetter( activeInfo.type );`,
+    replace: `		this.cache = [];
+		this._cimplifyCache = new Float64Array( 3 ).fill( NaN );
+		this.type = activeInfo.type;
+		this.setValue = getSingularSetter( activeInfo.type );`
+  },
+  {
+    file: MODULE,
+    find: `	if ( v.x !== undefined ) {`,
+    replace: `	if ( v.isVector3 === true ) {`,
+    after: `function setValueV3f( gl, v ) {`
+  },
+  {
+    file: MODULE,
+    find: `	} else if ( v.r !== undefined ) {`,
+    replace: `	} else if ( v.isColor === true ) {`,
+    after: `function setValueV3f( gl, v ) {`
+  },
+  {
+    file: MODULE,
+    find: `			object: vao,
+			attributes: {},
+			index: null`,
+    replace: `			object: vao,
+			attributes: {},
+			attributesNum: 0,
+			cimplifyNames: null,
+			cimplifyAttributes: [],
+			cimplifyData: [],
+			index: null`
+  },
+  {
+    file: MODULE,
+    find: `	function needsUpdate( object, geometry, program, index ) {
+
+		const cachedAttributes = currentState.attributes;
+		const geometryAttributes = geometry.attributes;
+
+		let attributesNum = 0;
+
+		const programAttributes = program.getAttributes();
+
+		for ( const name in programAttributes ) {
+
+			const programAttribute = programAttributes[ name ];
+
+			if ( programAttribute.location >= 0 ) {
+
+				const cachedAttribute = cachedAttributes[ name ];
+				let geometryAttribute = geometryAttributes[ name ];
+
+				if ( geometryAttribute === undefined ) {
+
+					if ( name === 'instanceMatrix' && object.instanceMatrix ) geometryAttribute = object.instanceMatrix;
+					if ( name === 'instanceColor' && object.instanceColor ) geometryAttribute = object.instanceColor;
+
+				}
+
+				if ( cachedAttribute === undefined ) return true;
+
+				if ( cachedAttribute.attribute !== geometryAttribute ) return true;
+
+				if ( geometryAttribute && cachedAttribute.data !== geometryAttribute.data ) return true;
+
+				attributesNum ++;
+
+			}
+
+		}
+
+		if ( currentState.attributesNum !== attributesNum ) return true;
+
+		if ( currentState.index !== index ) return true;
+
+		return false;
+
+	}
+
+	function saveCache( object, geometry, program, index ) {
+
+		const cache = {};
+		const attributes = geometry.attributes;
+		let attributesNum = 0;
+
+		const programAttributes = program.getAttributes();
+
+		for ( const name in programAttributes ) {
+
+			const programAttribute = programAttributes[ name ];
+
+			if ( programAttribute.location >= 0 ) {
+
+				let attribute = attributes[ name ];
+
+				if ( attribute === undefined ) {
+
+					if ( name === 'instanceMatrix' && object.instanceMatrix ) attribute = object.instanceMatrix;
+					if ( name === 'instanceColor' && object.instanceColor ) attribute = object.instanceColor;
+
+				}
+
+				const data = {};
+				data.attribute = attribute;
+
+				if ( attribute && attribute.data ) {
+
+					data.data = attribute.data;
+
+				}
+
+				cache[ name ] = data;
+
+				attributesNum ++;
+
+			}
+
+		}
+
+		currentState.attributes = cache;
+		currentState.attributesNum = attributesNum;
+
+		currentState.index = index;
+
+	}
+`,
+    replace: `	function attributeNames( program ) {
+
+		let names = program.cimplifyAttributeNames;
+
+		if ( names === undefined ) {
+
+			names = [];
+			const programAttributes = program.getAttributes();
+
+			for ( const name in programAttributes ) {
+
+				if ( programAttributes[ name ].location >= 0 ) names.push( name );
+
+			}
+
+			program.cimplifyAttributeNames = names;
+
+		}
+
+		return names;
+
+	}
+
+	function attributeOf( object, attributes, name ) {
+
+		const attribute = attributes[ name ];
+
+		if ( attribute !== undefined ) return attribute;
+		if ( name === 'instanceMatrix' && object.instanceMatrix ) return object.instanceMatrix;
+		if ( name === 'instanceColor' && object.instanceColor ) return object.instanceColor;
+		return undefined;
+
+	}
+
+	function needsUpdate( object, geometry, program, index ) {
+
+		const names = attributeNames( program );
+
+		if ( currentState.cimplifyNames !== names ) return true;
+		if ( currentState.index !== index ) return true;
+
+		const cachedAttributes = currentState.cimplifyAttributes;
+		const cachedData = currentState.cimplifyData;
+		const geometryAttributes = geometry.attributes;
+
+		for ( let i = 0, l = names.length; i < l; i ++ ) {
+
+			const geometryAttribute = attributeOf( object, geometryAttributes, names[ i ] );
+
+			if ( cachedAttributes[ i ] !== geometryAttribute ) return true;
+			if ( geometryAttribute !== undefined && cachedData[ i ] !== geometryAttribute.data ) return true;
+
+		}
+
+		return false;
+
+	}
+
+	function saveCache( object, geometry, program, index ) {
+
+		const names = attributeNames( program );
+		const cache = {};
+		const attributes = geometry.attributes;
+		const cachedAttributes = currentState.cimplifyAttributes;
+		const cachedData = currentState.cimplifyData;
+
+		cachedAttributes.length = names.length;
+		cachedData.length = names.length;
+
+		for ( let i = 0, l = names.length; i < l; i ++ ) {
+
+			const name = names[ i ];
+			const attribute = attributeOf( object, attributes, name );
+			const data = attribute !== undefined ? attribute.data : undefined;
+
+			cachedAttributes[ i ] = attribute;
+			cachedData[ i ] = data;
+			cache[ name ] = { attribute: attribute, data: data };
+
+		}
+
+		currentState.attributes = cache;
+		currentState.attributesNum = names.length;
+		currentState.cimplifyNames = names;
+		currentState.index = index;
+
+	}
+`
+  }
+];
+var THREE_FORK = {
+  library: "three",
+  version: "0.186.1",
+  entry: MODULE,
+  files: [CORE, MODULE],
+  patches: PATCHES
+};
+
+// src/interactives/build/runtime-chunks.ts
+var ENGINE_CORE = "@cimplify/engine-core";
+var ENGINE_CORE_THREADS = "@cimplify/engine-core-threads";
+var ENGINE_RUNTIME_PACKAGE = "@cimplify/engine-runtime";
+var ENGINE_RUNTIME_ENV = "CIMPLIFY_ENGINE_RUNTIME_DIR";
+var ENGINE_RUNTIME_WASM_DIR = "wasm";
+var ENGINE_RUNTIME_WORKSPACE_DIR = "engine-runtime";
+var WORKSPACE_TEXT_DICTIONARIES = ["..", "..", "crates", "engine_text", "data", "dictionaries.bin"];
+var RUNTIME_REGISTRY_ID = "esbuild-0.28.2-cjs@3";
+var SDK_CHUNK_PREFIX = `${SDK_PACKAGE}/~/`;
+var SDK_DIST_DIR = "dist";
+var RELATIVE_IMPORT = /^\.\.?\//;
+var RUNTIME_IMPORT_META_URL = "https://runtime.cimplify.invalid/";
+var ESBUILD_TARGET = "es2022";
+var NODE_ENV = '"production"';
+var PREFIX_WILDCARD = "*";
+var VERSION_DIGEST_SEPARATOR = "+";
+var VERSION_DIGEST_HEX = 16;
+var UNIT_KEY_SEPARATOR = "\n";
+var SHA256 = "sha256";
+var PREFIX_ALIASES = [["three/examples/jsm/", "three/addons/"]];
+var WHOLE_SPECIFIER = "*";
+var SDK_SHAKEN_PREFIX = `${SDK_PACKAGE}/~`;
+var CANVAS_CORE_UNIT = `${SDK_PACKAGE}/~canvas-core`;
+var SDK_GAME_UNIT_PREFIX = `${SDK_PACKAGE}/~game-`;
+var SDK_GAME_NAME_HEX = 16;
+var CANVAS_CORE_BINDINGS = /* @__PURE__ */ new Map([["@cimplify/sdk/game/kit/canvas", /* @__PURE__ */ new Set(["firstFrame", "runCanvasGame"])]]);
+function isShakenSdkUnit(name) {
+  return name.startsWith(SDK_SHAKEN_PREFIX) && !name.startsWith(SDK_CHUNK_PREFIX);
+}
+function sdkVersion() {
+  const sdk = LIBRARY_ALLOWLIST.find((l) => l.name === SDK_PACKAGE);
+  if (sdk === void 0) throw new Error("the SDK is not on the allowlist");
+  return sdk.version;
+}
+function sdkUnit(specifier) {
+  return { name: specifier, version: sdkVersion(), specifiers: [specifier] };
+}
+function isSdkRuntime(name) {
+  return name === SDK_PACKAGE || name.startsWith(`${SDK_PACKAGE}/`);
+}
+function runtimeExportOf(specifier) {
+  for (const [alias, target] of PREFIX_ALIASES) {
+    if (specifier.startsWith(alias)) return target + specifier.slice(alias.length);
+  }
+  return specifier;
+}
+function runtimeUnitOf(raw) {
+  const specifier = runtimeExportOf(raw);
+  if (specifier === ENGINE_CORE) return { name: ENGINE_CORE, version: sdkVersion(), specifiers: [ENGINE_CORE] };
+  if (specifier.startsWith(SDK_CHUNK_PREFIX) || isShakenSdkUnit(specifier)) return sdkUnit(specifier);
+  for (const library of LIBRARY_ALLOWLIST) {
+    for (const entry of library.entries) {
+      if (entry.prefix && specifier.startsWith(entry.specifier)) {
+        return { name: specifier, version: library.version, specifiers: [specifier] };
+      }
+      if (!entry.prefix && specifier === entry.specifier) {
+        if (library.name === SDK_PACKAGE) return sdkUnit(specifier);
+        const fixed = library.entries.filter((e) => !e.prefix).map((e) => e.specifier);
+        return { name: library.name, version: library.version, specifiers: fixed };
+      }
+    }
+  }
+  return null;
+}
+function externals(unit) {
+  const out = [];
+  for (const library of LIBRARY_ALLOWLIST) {
+    for (const entry of library.entries) {
+      if (entry.prefix) out.push(`${entry.specifier}${PREFIX_WILDCARD}`);
+      else if (library.name !== unit.name && unit.specifiers.indexOf(entry.specifier) < 0) out.push(entry.specifier);
+    }
+  }
+  return out;
+}
+var FORKS = [THREE_FORK];
+function sdkDist(sdkDir) {
+  return path4.join(sdkDir, SDK_DIST_DIR);
+}
+function entryPath(specifier, resolveDir) {
+  const fork = FORKS.find((f) => f.library === specifier);
+  if (fork !== void 0) {
+    const dir2 = findPackageDir(resolveDir, fork.library);
+    if (dir2 === null) throw new Error(`${specifier} does not resolve to a package`);
+    return forkedEntry(fork, dir2);
+  }
+  const prefixed = LIBRARY_ALLOWLIST.some((l) => l.entries.some((e) => e.prefix && specifier.startsWith(e.specifier)));
+  if (!prefixed) return specifier;
+  const library = LIBRARY_ALLOWLIST.find((l) => specifier.startsWith(`${l.name}/`));
+  const dir = library === void 0 ? null : findPackageDir(resolveDir, library.name);
+  if (dir === null || library === void 0) throw new Error(`${specifier} does not resolve to a package`);
+  const subpath = `.${specifier.slice(library.name.length)}`;
+  const map = exportsMap(readPackageJson(dir)) ?? {};
+  for (const key of Object.keys(map)) {
+    if (!key.endsWith(PREFIX_WILDCARD) || !subpath.startsWith(key.slice(0, -1))) continue;
+    const target = pickTarget(map[key], BROWSER_CONDITIONS);
+    if (target === null) continue;
+    const file = path4.resolve(dir, target.replace(PREFIX_WILDCARD, subpath.slice(key.length - 1)));
+    if (existsSync(file)) return file;
+  }
+  throw new Error(`${specifier} does not resolve to a file`);
+}
+function entrySource(unit, resolveDir) {
+  let imports = "";
+  let record = "";
+  unit.specifiers.forEach((specifier, i) => {
+    imports += `import * as e${i} from ${JSON.stringify(entryPath(specifier, resolveDir))};
+`;
+    record += `${JSON.stringify(specifier)}: e${i},`;
+  });
+  return `${imports}export default {${record}};
+`;
+}
+var REQUIRE_CALL = /\brequire\((["'])([^"'\\\n]+)\1\)/g;
+function requiresOf(code, unit, externalPaths) {
+  const out = [];
+  for (const match of code.matchAll(REQUIRE_CALL)) {
+    const specifier = match[2];
+    if (!externalPaths.has(specifier)) continue;
+    const at2 = match.index + match[0].indexOf(match[1]) + 1;
+    const target = runtimeUnitOf(specifier);
+    if (target === null) throw new Error(`runtime ${unit.name} requires '${specifier}', which is not an allowlisted library`);
+    out.push({ at: at2, end: at2 + specifier.length, module: null, library: target.name, export: runtimeExportOf(specifier), specifier });
+  }
+  return out;
+}
+function bundle(unit, resolveDir) {
+  const result = buildSync({
+    stdin: { contents: entrySource(unit, resolveDir), resolveDir, loader: "js", sourcefile: `${unit.name}.runtime.js` },
+    bundle: true,
+    write: false,
+    format: "cjs",
+    platform: "browser",
+    target: ESBUILD_TARGET,
+    conditions: ["browser", "import", "module"],
+    mainFields: ["browser", "module", "main"],
+    external: externals(unit),
+    define: { "process.env.NODE_ENV": NODE_ENV, "import.meta.url": JSON.stringify(RUNTIME_IMPORT_META_URL) },
+    legalComments: "none",
+    minifyWhitespace: true,
+    minifySyntax: true,
+    charset: "utf8",
+    logLevel: "silent",
+    metafile: true
+  });
+  const found = /* @__PURE__ */ new Set();
+  for (const input of Object.values(result.metafile.inputs)) {
+    for (const imported of input.imports) if (imported.external === true) found.add(imported.path);
+  }
+  return { code: Buffer.from(inlineModuleConstants(result.outputFiles[0].text, `${unit.name}.runtime.js`).code, "utf8"), externals: found };
+}
+function built(unit, kind, chunk, imports, engineAbi, engineExports = null) {
+  const version = `${unit.version}${VERSION_DIGEST_SEPARATOR}${chunk.digest.slice(0, VERSION_DIGEST_HEX)}`;
+  return { unit, version, kind, chunk, imports, engineAbi, engineExports };
+}
+function engineWasm(unit, bytes) {
+  return built(unit, "wasm", encodeChunk("wasm", bytes), [], engineAbiVersion(bytes), engineExportTable(bytes, ENGINE_EXPORT_PROTOTYPES));
+}
+function isEngineRuntime(dir) {
+  return existsSync(path4.join(dir, "package.json")) && readPackageJson(dir).name === ENGINE_RUNTIME_PACKAGE;
+}
+function localEngineRuntimeDir(sdkDir) {
+  const configured = process.env[ENGINE_RUNTIME_ENV];
+  if (configured !== void 0 && configured !== "") return path4.resolve(configured);
+  const installed = findPackageDir(sdkDir, ENGINE_RUNTIME_PACKAGE);
+  if (installed !== null) return installed;
+  const workspace = path4.resolve(sdkDir, "..", ENGINE_RUNTIME_WORKSPACE_DIR);
+  return isEngineRuntime(workspace) ? workspace : null;
+}
+function engineRuntimeDir(sdkDir) {
+  return localEngineRuntimeDir(sdkDir) ?? cachedEngineRuntimeDir();
+}
+function engineCoreFile(sdkDir, variant) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) {
+    throw new Error(
+      `the Cimplify Engine runtime is not downloaded yet: run \`cimplify login\` so the CLI fetches it for your account, or set ${ENGINE_RUNTIME_ENV} to a local engine runtime directory`
+    );
+  }
+  for (const file of [variant.file, FULL_ENGINE_VARIANT.file]) {
+    const candidate = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, file);
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`${dir} holds no ${ENGINE_RUNTIME_WASM_DIR}/${variant.file}: run bun run build in packages/engine-runtime`);
+}
+function textDictionariesFile(sdkDir) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir !== null) {
+    const staged = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, TEXT_DICTIONARIES_FILE);
+    if (existsSync(staged)) return staged;
+  }
+  const workspace = path4.resolve(sdkDir, ...WORKSPACE_TEXT_DICTIONARIES);
+  return existsSync(workspace) ? workspace : null;
+}
+function luauVmFile(sdkDir) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) return null;
+  const file = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, LUAU_VM_FILE);
+  return existsSync(file) ? file : null;
+}
+function luauVmRuntime(sdkDir) {
+  const file = luauVmFile(sdkDir);
+  if (file === null) return null;
+  const unit = { name: ENGINE_LUAU_UNIT, version: sdkVersion(), specifiers: [] };
+  return built(unit, "wasm", encodeChunk("wasm", readFileSync(file)), [], null);
+}
+function audioWorkletFile(sdkDir) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) return null;
+  const file = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, AUDIO_WORKLET_FILE);
+  return existsSync(file) ? file : null;
+}
+function audioWorkletRuntime(sdkDir) {
+  const file = audioWorkletFile(sdkDir);
+  if (file === null) return null;
+  const unit = { name: ENGINE_AUDIO_UNIT, version: sdkVersion(), specifiers: [] };
+  return built(unit, "wasm", encodeChunk("wasm", readFileSync(file)), [], null);
+}
+function linkedCoreVariant(sdkDir, variant) {
+  return path4.basename(engineCoreFile(sdkDir, variant)) === variant.file ? variant : FULL_ENGINE_VARIANT;
+}
+function threadedCoreFile(sdkDir, variant) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) return null;
+  const file = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, threadedVariantOf(linkedCoreVariant(sdkDir, variant)).file);
+  return existsSync(file) ? file : null;
+}
+function scriptsCoreFile(sdkDir, variant) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) return null;
+  const widest = isShadersVariant(variant) ? SCRIPTS_SHADERS_ENGINE_VARIANT : SCRIPTS_ENGINE_VARIANT;
+  for (const file of [variant.file, widest.file]) {
+    const candidate = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, file);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function threadedCoreRuntime(core, sdkDir, variant) {
+  const file = threadedCoreFile(sdkDir, variant);
+  if (file === null) return null;
+  const unit = { name: ENGINE_CORE_THREADS, version: core.version, specifiers: [] };
+  return engineWasm(unit, readFileSync(file));
+}
+function scriptsCoreRuntime(core, sdkDir, variant) {
+  const file = scriptsCoreFile(sdkDir, variant);
+  if (file === null) return null;
+  const unit = { name: ENGINE_CORE_SCRIPTS_UNIT, version: core.version, specifiers: [] };
+  return engineWasm(unit, readFileSync(file));
+}
+function glCoreFile(sdkDir, variant) {
+  const dir = engineRuntimeDir(sdkDir);
+  if (dir === null) return null;
+  const widest = isScriptsVariant(variant) ? isShadersVariant(variant) ? SCRIPTS_SHADERS_ENGINE_VARIANT : SCRIPTS_ENGINE_VARIANT : FULL_ENGINE_VARIANT;
+  for (const candidate of [glVariantOf(variant), glVariantOf(widest)]) {
+    if (candidate === null) continue;
+    const file = path4.join(dir, ENGINE_RUNTIME_WASM_DIR, candidate.file);
+    if (existsSync(file)) return file;
+  }
+  return null;
+}
+function glCoreRuntime(core, sdkDir, variant) {
+  const file = glCoreFile(sdkDir, variant);
+  if (file === null) return null;
+  const unit = { name: ENGINE_CORE_GL_UNIT, version: core.version, specifiers: [] };
+  return engineWasm(unit, readFileSync(file));
+}
+function engineCoreRuntime(unit, sdkDir, variant) {
+  return engineWasm(unit, readFileSync(engineCoreFile(sdkDir, variant)));
+}
+function sdkFile(unit, sdkDir) {
+  const dist = sdkDist(sdkDir);
+  if (unit.name.startsWith(SDK_CHUNK_PREFIX)) {
+    const file = path4.resolve(dist, unit.name.slice(SDK_CHUNK_PREFIX.length));
+    if (path4.relative(dist, file).startsWith("..") || !existsSync(file)) throw new Error(`${unit.name} is not a file of ${SDK_PACKAGE}`);
+    return { file, dist };
+  }
+  const target = pickTarget((exportsMap(readPackageJson(path4.dirname(dist))) ?? {})[`.${unit.name.slice(SDK_PACKAGE.length)}`], BROWSER_CONDITIONS);
+  if (target === null) throw new Error(`${unit.name} has no browser build in ${SDK_PACKAGE}`);
+  return { file: path4.resolve(path4.dirname(dist), target), dist };
+}
+function sdkRuntime(unit, sdkDir) {
+  const { file, dist } = sdkFile(unit, sdkDir);
+  const transformed = transformSync(readFileSync(file, "utf8"), {
+    loader: "js",
+    format: "cjs",
+    target: ESBUILD_TARGET,
+    define: { "process.env.NODE_ENV": NODE_ENV, "import.meta.url": JSON.stringify(RUNTIME_IMPORT_META_URL) },
+    legalComments: "none",
+    minifyWhitespace: true,
+    minifySyntax: true,
+    charset: "utf8",
+    sourcefile: path4.relative(dist, file)
+  });
+  const required = /* @__PURE__ */ new Set();
+  const body = transformed.code.replace(REQUIRE_CALL, (_call, quote, specifier) => {
+    const name = RELATIVE_IMPORT.test(specifier) ? SDK_CHUNK_PREFIX + path4.relative(dist, path4.resolve(path4.dirname(file), specifier)).split(path4.sep).join("/") : specifier;
+    required.add(name);
+    return `require(${quote}${name}${quote})`;
+  });
+  const record = JSON.stringify(unit.name);
+  const code = `var __unit={exports:{}};(function(module,exports){${body}
+})(__unit,__unit.exports);exports.default={${record}:__unit.exports};
+`;
+  const inlined = Buffer.from(inlineModuleConstants(code, `${unit.name}.runtime.js`).code, "utf8");
+  return built(unit, "code", encodeChunk("code", inlined), requiresOf(inlined.toString("utf8"), unit, required), null);
+}
+function usesCanvasCore(bindings) {
+  for (const [specifier, names] of CANVAS_CORE_BINDINGS) {
+    const used = bindings.get(specifier);
+    if (used !== void 0 && (used.has(WHOLE_SPECIFIER) || [...names].some((name) => used.has(name)))) return true;
+  }
+  return false;
+}
+function beyond(bindings, base) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [specifier, names] of bindings) {
+    const covered = base.get(specifier);
+    const left = new Set([...names].filter((name) => name === WHOLE_SPECIFIER || covered === void 0 || !covered.has(name)));
+    if (left.size > 0) out.set(specifier, left);
+  }
+  return out;
+}
+function canonical(bindings) {
+  return [...bindings.entries()].map(([specifier, names]) => [specifier, [...names].sort(compareStrings)]).sort((a, b) => compareStrings(a[0], b[0]));
+}
+function shakenEntry(name, bindings, base, sdkDir) {
+  let imports = base === null ? "" : `import __base from ${JSON.stringify(base.unit)};
+`;
+  let record = "";
+  canonical(bindings).forEach(([specifier, names], i) => {
+    const file = JSON.stringify(sdkFile(sdkUnit(specifier), sdkDir).file);
+    const inherited = base !== null && base.bindings.has(specifier) ? `...__base[${JSON.stringify(specifier)}],` : "";
+    if (names.includes(WHOLE_SPECIFIER)) {
+      imports += `import * as s${i} from ${file};
+`;
+      record += `${JSON.stringify(specifier)}: {${inherited}...s${i}},`;
+      return;
+    }
+    imports += `import { ${names.map((name2, k) => `${name2} as s${i}_${k}`).join(", ")} } from ${file};
+`;
+    record += `${JSON.stringify(specifier)}: {${inherited}${names.map((name2, k) => `${JSON.stringify(name2)}: s${i}_${k}`).join(",")}},`;
+  });
+  if (base !== null) {
+    for (const [specifier] of canonical(base.bindings)) if (!bindings.has(specifier)) record += `${JSON.stringify(specifier)}: __base[${JSON.stringify(specifier)}],`;
+  }
+  return `${imports}const __record = {${record}};
+__record[${JSON.stringify(name)}] = __record;
+export default __record;
+`;
+}
+function sdkExternals(base) {
+  const out = base === null ? [] : [base];
+  for (const library of LIBRARY_ALLOWLIST) {
+    if (library.name === SDK_PACKAGE) continue;
+    for (const entry of library.entries) out.push(entry.prefix ? `${entry.specifier}${PREFIX_WILDCARD}` : entry.specifier);
+  }
+  out.push(ENGINE_CORE);
+  return out;
+}
+function shakenSdkRuntime(name, bindings, base, sdkDir) {
+  const unit = sdkUnit(name);
+  const dist = sdkDist(sdkDir);
+  const result = buildSync({
+    stdin: { contents: shakenEntry(name, bindings, base, sdkDir), resolveDir: dist, loader: "js", sourcefile: `${name}.runtime.js` },
+    bundle: true,
+    write: false,
+    format: "cjs",
+    platform: "browser",
+    target: ESBUILD_TARGET,
+    conditions: ["browser", "import", "module"],
+    mainFields: ["browser", "module", "main"],
+    external: sdkExternals(base === null ? null : base.unit),
+    define: { "process.env.NODE_ENV": NODE_ENV, "import.meta.url": JSON.stringify(RUNTIME_IMPORT_META_URL) },
+    legalComments: "none",
+    minifyWhitespace: true,
+    minifySyntax: true,
+    minifyIdentifiers: true,
+    charset: "utf8",
+    logLevel: "silent",
+    metafile: true
+  });
+  const found = /* @__PURE__ */ new Set();
+  for (const input of Object.values(result.metafile.inputs)) {
+    for (const imported of input.imports) if (imported.external === true) found.add(imported.path);
+  }
+  const code = Buffer.from(inlineModuleConstants(result.outputFiles[0].text, `${name}.runtime.js`).code, "utf8");
+  return built(unit, "code", encodeChunk("code", code), requiresOf(code.toString("utf8"), unit, found), null);
+}
+function sdkGameRuntime(bindings, sdkDir) {
+  const base = usesCanvasCore(bindings) ? { unit: CANVAS_CORE_UNIT, bindings: CANVAS_CORE_BINDINGS } : null;
+  const own = base === null ? new Map(bindings) : beyond(bindings, base.bindings);
+  const key = createHash(SHA256).update(JSON.stringify([sdkVersion(), base?.unit ?? null, canonical(own)])).digest("hex").slice(0, SDK_GAME_NAME_HEX);
+  return shakenSdkRuntime(`${SDK_GAME_UNIT_PREFIX}${key}`, own, base, sdkDir);
+}
+function buildRuntime(unit, sdkDir) {
+  if (unit.name === CANVAS_CORE_UNIT) return shakenSdkRuntime(CANVAS_CORE_UNIT, CANVAS_CORE_BINDINGS, null, sdkDir);
+  if (unit.name === ENGINE_CORE) return engineCoreRuntime(unit, sdkDir, FULL_ENGINE_VARIANT);
+  if (isSdkRuntime(unit.name)) return sdkRuntime(unit, sdkDir);
+  const bundled = bundle(unit, sdkDir);
+  return built(unit, "code", encodeChunk("code", bundled.code), requiresOf(bundled.code.toString("utf8"), unit, bundled.externals), null);
+}
+var registries = /* @__PURE__ */ new Map();
+function bundledRuntimes(sdkDir) {
+  const known = registries.get(sdkDir);
+  if (known !== void 0) return known;
+  const cache = /* @__PURE__ */ new Map();
+  const registry = {
+    id: RUNTIME_REGISTRY_ID,
+    unitOf: runtimeUnitOf,
+    runtime(unit) {
+      const key = [unit.name, ...unit.specifiers].join(UNIT_KEY_SEPARATOR);
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = buildRuntime(unit, sdkDir);
+      cache.set(key, runtime);
+      return runtime;
+    },
+    engineCore(unit, variant) {
+      const key = [unit.name, variant.file].join(UNIT_KEY_SEPARATOR);
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = engineCoreRuntime(unit, sdkDir, variant);
+      cache.set(key, runtime);
+      return runtime;
+    },
+    engineCoreThreads(core, variant) {
+      const key = [ENGINE_CORE_THREADS, core.version, variant.file].join(UNIT_KEY_SEPARATOR);
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = threadedCoreRuntime(core, sdkDir, variant);
+      if (runtime !== null) cache.set(key, runtime);
+      return runtime;
+    },
+    engineCoreScripts(core, variant) {
+      const key = [ENGINE_CORE_SCRIPTS_UNIT, core.version, variant.file].join(UNIT_KEY_SEPARATOR);
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = scriptsCoreRuntime(core, sdkDir, variant);
+      if (runtime !== null) cache.set(key, runtime);
+      return runtime;
+    },
+    engineCoreGl(core, variant) {
+      const key = [ENGINE_CORE_GL_UNIT, core.version, variant.file].join(UNIT_KEY_SEPARATOR);
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = glCoreRuntime(core, sdkDir, variant);
+      if (runtime !== null) cache.set(key, runtime);
+      return runtime;
+    },
+    sdkGame(bindings) {
+      const key = JSON.stringify(canonical(bindings));
+      const cached = cache.get(key);
+      if (cached !== void 0) return cached;
+      const runtime = sdkGameRuntime(bindings, sdkDir);
+      cache.set(key, runtime);
+      return runtime;
+    },
+    luauVm() {
+      const cached = cache.get(ENGINE_LUAU_UNIT);
+      if (cached !== void 0) return cached;
+      const runtime = luauVmRuntime(sdkDir);
+      if (runtime !== null) cache.set(ENGINE_LUAU_UNIT, runtime);
+      return runtime;
+    },
+    audioWorklet() {
+      const cached = cache.get(ENGINE_AUDIO_UNIT);
+      if (cached !== void 0) return cached;
+      const runtime = audioWorkletRuntime(sdkDir);
+      if (runtime !== null) cache.set(ENGINE_AUDIO_UNIT, runtime);
+      return runtime;
+    }
+  };
+  registries.set(sdkDir, registry);
+  return registry;
+}
+function runtimeClosure(registry, roots) {
+  const reached = /* @__PURE__ */ new Map();
+  const linked = /* @__PURE__ */ new Map();
+  const pending = [...roots];
+  while (pending.length > 0) {
+    const specifier = runtimeExportOf(pending.pop());
+    const unit = registry.unitOf(specifier);
+    if (unit === null) throw new Error(`'${specifier}' has no shared runtime build`);
+    let entry = reached.get(unit.name);
+    if (entry === void 0) {
+      entry = { unit, specifiers: /* @__PURE__ */ new Set() };
+      reached.set(unit.name, entry);
+    }
+    if (entry.specifiers.has(specifier)) continue;
+    entry.specifiers.add(specifier);
+    const runtime = registry.runtime({ ...entry.unit, specifiers: [...entry.specifiers].sort(compareStrings) });
+    linked.set(unit.name, runtime);
+    for (const required of runtime.imports) pending.push(required.export);
+  }
+  return [...linked.values()].sort((a, b) => compareStrings(a.unit.name, b.unit.name));
+}
+var TYPESCRIPT_PACKAGE = "typescript";
+var PROBE_LIB = "lib.es2022.d.ts";
+var HEAP_HOOKS = ["./game/heap", "./game/conformance"];
+function builderBase() {
+  try {
+    const here = path4.dirname(fileURLToPath(import.meta.url));
+    return existsSync(here) ? here : null;
+  } catch {
+    return null;
+  }
+}
+function at(base, origin) {
+  const ts2 = findPackageDir(base, TYPESCRIPT_PACKAGE);
+  const sdk = findPackageDir(base, SDK_PACKAGE);
+  if (ts2 === null || sdk === null) return null;
+  const lib = path4.join(ts2, "lib");
+  if (!existsSync(path4.join(lib, PROBE_LIB))) return null;
+  return {
+    origin,
+    base,
+    typescriptLib: lib,
+    typescriptVersion: readPackageJson(ts2).version ?? "unknown",
+    sdkDir: sdk,
+    sdkVersion: readPackageJson(sdk).version ?? "unknown"
+  };
+}
+var located = /* @__PURE__ */ new Map();
+function locateToolchain(projectRoot) {
+  const key = projectRoot ?? "";
+  if (located.has(key)) return located.get(key) ?? null;
+  const builder = builderBase();
+  const found = (builder !== null ? at(builder, "builder") : null) ?? (projectRoot !== null ? at(projectRoot, "project") : null);
+  located.set(key, found);
+  return found;
+}
+function toolchainDiagnostics(toolchain) {
+  if (toolchain === null) {
+    return [diagnostic("toolchain.missing", `the pinned TypeScript ${PINNED_TYPESCRIPT_VERSION} and ${SDK_PACKAGE} ${PINNED_SDK_VERSION} are not installed where the builder can read them; run bun install in the project`, null, null)];
+  }
+  const out = [];
+  if (toolchain.typescriptVersion !== PINNED_TYPESCRIPT_VERSION) {
+    out.push(diagnostic("toolchain.version", `type checking found TypeScript ${toolchain.typescriptVersion}; the pinned toolchain is ${PINNED_TYPESCRIPT_VERSION}`, null, null));
+  }
+  if (toolchain.sdkVersion !== PINNED_SDK_VERSION) {
+    out.push(diagnostic("toolchain.version", `type checking found ${SDK_PACKAGE} ${toolchain.sdkVersion}; the pinned SDK is ${PINNED_SDK_VERSION}`, null, null));
+  }
+  return out;
+}
+function runtimeImportMap(toolchain) {
+  const map = {};
+  for (const library of LIBRARY_ALLOWLIST) {
+    const dir = findPackageDir(toolchain.base, library.name);
+    if (dir === null) continue;
+    const exports = exportsMap(readPackageJson(dir));
+    for (const entry of library.entries) {
+      const subpath = `.${entry.specifier.slice(library.name.length)}`;
+      if (entry.prefix) {
+        const target = pickTarget(exports?.[`${subpath}*`], NODE_CONDITIONS);
+        if (target !== null && target.endsWith("*")) map[entry.specifier] = pathToFileURL(path4.resolve(dir, target.slice(0, -1))).href + "/";
+        continue;
+      }
+      const file = resolveExport(dir, subpath, NODE_CONDITIONS);
+      if (file !== null) map[entry.specifier] = pathToFileURL(file).href;
+    }
+  }
+  return map;
+}
+function heapHooksUrl(toolchain) {
+  for (const subpath of HEAP_HOOKS) {
+    const file = resolveExport(toolchain.sdkDir, subpath, NODE_CONDITIONS);
+    if (file !== null) return pathToFileURL(file).href;
+  }
+  return null;
+}
+
+export { BROWSER_CONDITIONS, ENGINE_CORE, ENGINE_CORE_THREADS, NODE_CONDITIONS, WHOLE_SPECIFIER, bundledRuntimes, cachedEngineRuntimeDir, cachedVersion, canonicalBytes, engineCacheRoot, engineCoreFile, exportTarget, exportsMap, findPackageDir, heapHooksUrl, isSdkRuntime, localEngineRuntimeDir, locateToolchain, pickTarget, readPackageJson, resolveExport, runtimeClosure, runtimeExportOf, runtimeImportMap, storeRuntime, stripDotSlash, textDictionariesFile, toolchainDiagnostics, validManifest };