@luma.gl/engine 9.0.11 → 9.1.0-alpha.1

package/dist/dist.dev.js

@@ -55,6 +55,7 @@ var __exports__ = (() => {
   __export(bundle_exports, {
     AnimationLoop: () => AnimationLoop,
     AnimationLoopTemplate: () => AnimationLoopTemplate,
+    AsyncTexture: () => AsyncTexture,
     BufferTransform: () => BufferTransform,
     ClipSpace: () => ClipSpace,
     Computation: () => Computation,
@@ -77,7 +78,13 @@ var __exports__ = (() => {
     Timeline: () => Timeline,
     TruncatedConeGeometry: () => TruncatedConeGeometry,
     _ShaderInputs: () => ShaderInputs,
-    makeAnimationLoop: () => makeAnimationLoop
+    cancelAnimationFrame: () => cancelAnimationFrame,
+    loadImage: () => loadImage,
+    loadImageBitmap: () => loadImageBitmap,
+    makeAnimationLoop: () => makeAnimationLoop,
+    makeRandomGenerator: () => makeRandomGenerator,
+    requestAnimationFrame: () => requestAnimationFrame,
+    setPathPrefix: () => setPathPrefix
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -254,7 +261,14 @@ var __exports__ = (() => {
 
   // src/animation-loop/animation-loop.ts
   var import_core = __toESM(require_core(), 1);
-  var import_core2 = __toESM(require_core(), 1);
+
+  // src/animation-loop/request-animation-frame.ts
+  function requestAnimationFrame(callback) {
+    return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60);
+  }
+  function cancelAnimationFrame(timerId) {
+    return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId);
+  }
 
   // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
@@ -273,8 +287,6 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name, type) {
-      this.name = void 0;
-      this.type = void 0;
       this.sampleSize = 1;
       this.time = 0;
       this.count = 0;
@@ -309,26 +321,31 @@ var __exports__ = (() => {
       this.sampleSize = samples;
       return this;
     }
+    /** Call to increment count (+1) */
     incrementCount() {
       this.addCount(1);
       return this;
     }
+    /** Call to decrement count (-1) */
     decrementCount() {
       this.subtractCount(1);
       return this;
     }
+    /** Increase count */
     addCount(value) {
       this._count += value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Decrease count */
     subtractCount(value) {
       this._count -= value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Add an arbitrary timing and bump the count */
     addTime(time) {
       this._time += time;
       this.lastTiming = time;
@@ -336,11 +353,13 @@ var __exports__ = (() => {
       this._checkSampling();
       return this;
     }
+    /** Start a timer */
     timeStart() {
       this._startTime = getHiResTimestamp();
       this._timerPending = true;
       return this;
     }
+    /** End a timer. Adds to time and bumps the timing count. */
     timeEnd() {
       if (!this._timerPending) {
         return this;
@@ -353,18 +372,22 @@ var __exports__ = (() => {
     getSampleAverageCount() {
       return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
     }
+    /** Calculate average time / count for the previous window */
     getSampleAverageTime() {
       return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
     }
+    /** Calculate counts per second for the previous window */
     getSampleHz() {
       return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
     }
     getAverageCount() {
       return this.samples > 0 ? this.count / this.samples : 0;
     }
+    /** Calculate average time / count */
     getAverageTime() {
       return this.samples > 0 ? this.time / this.samples : 0;
     }
+    /** Calculate counts per second */
     getHz() {
       return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
     }
@@ -385,23 +408,20 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
-      this.id = void 0;
       this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    get(name) {
-      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
-      return this._getOrCreate({
-        name,
-        type
-      });
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
     }
     get size() {
       return Object.keys(this.stats).length;
     }
+    /** Reset all stats */
     reset() {
       for (const stat of Object.values(this.stats)) {
         stat.reset();
@@ -425,15 +445,11 @@ var __exports__ = (() => {
       });
       return table;
     }
-    _initializeStats() {
-      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _initializeStats(stats = []) {
       stats.forEach((stat) => this._getOrCreate(stat));
     }
     _getOrCreate(stat) {
-      const {
-        name,
-        type
-      } = stat;
+      const { name, type } = stat;
       let result = this.stats[name];
       if (!result) {
         if (stat instanceof Stat) {
@@ -645,13 +661,13 @@ var __exports__ = (() => {
       if (!this._running) {
         return;
       }
-      this._animationFrameId = (0, import_core2.requestAnimationFrame)(this._animationFrame.bind(this));
+      this._animationFrameId = requestAnimationFrame(this._animationFrame.bind(this));
     }
     _cancelAnimationFrame() {
       if (this._animationFrameId === null) {
         return;
       }
-      (0, import_core2.cancelAnimationFrame)(this._animationFrameId);
+      cancelAnimationFrame(this._animationFrameId);
       this._animationFrameId = null;
     }
     _animationFrame() {
@@ -669,7 +685,7 @@ var __exports__ = (() => {
         return;
       }
       this.props.onRender(this._getAnimationProps());
-      this.device.submit();
+      this.device?.submit();
     }
     _clearNeedsRedraw() {
       this.needsRedraw = false;
@@ -680,13 +696,14 @@ var __exports__ = (() => {
     }
     // Initialize the  object that will be passed to app callbacks
     _initializeAnimationProps() {
-      if (!this.device) {
+      const canvas2 = this.device?.canvasContext?.canvas;
+      if (!this.device || !canvas2) {
         throw new Error("loop");
       }
       this.animationProps = {
         animationLoop: this,
         device: this.device,
-        canvas: this.device?.canvasContext?.canvas,
+        canvas: canvas2,
         timeline: this.timeline,
         // Initial values
         useDevicePixels: this.props.useDevicePixels,
@@ -827,10 +844,10 @@ var __exports__ = (() => {
   };
 
   // src/animation-loop/make-animation-loop.ts
-  var import_core3 = __toESM(require_core(), 1);
+  var import_core2 = __toESM(require_core(), 1);
   function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
     let renderLoop = null;
-    const device = props?.device || import_core3.luma.createDevice();
+    const device = props?.device || import_core2.luma.createDevice();
     const animationLoop = new AnimationLoop({
       ...props,
       device,
@@ -848,10 +865,10 @@ var __exports__ = (() => {
   }
 
   // src/model/model.ts
+  var import_core8 = __toESM(require_core(), 1);
   var import_core9 = __toESM(require_core(), 1);
   var import_core10 = __toESM(require_core(), 1);
   var import_core11 = __toESM(require_core(), 1);
-  var import_core12 = __toESM(require_core(), 1);
 
   // ../shadertools/src/lib/glsl-utils/highlight.ts
   var glsl = (x) => `${x}`;
@@ -1178,40 +1195,6 @@ ${moduleSource}
     }
   };
 
-  // ../shadertools/src/lib/shader-assembly/select-shaders.ts
-  function selectShaders(props) {
-    if (props.source && props.platformInfo.type === "webgpu") {
-      const propsCopy = { ...props, vs: void 0, fs: void 0 };
-      return propsCopy;
-    }
-    if (!props.vs) {
-      throw new Error("no vertex shader");
-    }
-    const vs = getShaderSource(props.platformInfo, props.vs);
-    let fs;
-    if (props.fs) {
-      fs = getShaderSource(props.platformInfo, props.fs);
-    }
-    return { ...props, vs, fs };
-  }
-  function getShaderSource(platformInfo, shader) {
-    if (typeof shader === "string") {
-      return shader;
-    }
-    switch (platformInfo.type) {
-      case "webgpu":
-        if (shader?.wgsl) {
-          return shader.wgsl;
-        }
-        throw new Error("WebGPU does not support GLSL shaders");
-      default:
-        if (shader?.glsl) {
-          return shader.glsl;
-        }
-        throw new Error("WebGL does not support WGSL shaders");
-    }
-  }
-
   // ../shadertools/src/lib/shader-assembly/resolve-modules.ts
   function resolveModules(modules) {
     const instances = ShaderModuleInstance.instantiateModules(modules);
@@ -1423,10 +1406,10 @@ ${DECLARATION_INJECT_MARKER}
   var FRAGMENT_SHADER_PROLOGUE = glsl`\
 precision highp float;
 `;
-  function assembleShaderWGSL(options) {
+  function assembleWGSLShader(options) {
     const modules = resolveModules(options.modules || []);
     return {
-      source: assembleWGSLShader(options.platformInfo, {
+      source: assembleShaderWGSL(options.platformInfo, {
         ...options,
         source: options.source,
         stage: "vertex",
@@ -1435,36 +1418,19 @@ precision highp float;
       getUniforms: assembleGetUniforms(modules)
     };
   }
-  function assembleShaderPairWGSL(options) {
-    const modules = resolveModules(options.modules || []);
-    return {
-      vs: assembleWGSLShader(options.platformInfo, {
-        ...options,
-        source: options.vs,
-        stage: "vertex",
-        modules
-      }),
-      fs: assembleWGSLShader(options.platformInfo, {
-        ...options,
-        source: options.fs,
-        stage: "fragment",
-        modules
-      }),
-      getUniforms: assembleGetUniforms(modules)
-    };
-  }
-  function assembleShaderPairGLSL(options) {
+  function assembleGLSLShaderPair(options) {
     const { vs, fs } = options;
     const modules = resolveModules(options.modules || []);
     return {
-      vs: assembleGLSLShader(options.platformInfo, {
+      vs: assembleShaderGLSL(options.platformInfo, {
         ...options,
         source: vs,
         stage: "vertex",
         modules
       }),
-      fs: assembleGLSLShader(options.platformInfo, {
+      fs: assembleShaderGLSL(options.platformInfo, {
         ...options,
+        // @ts-expect-error
         source: fs,
         stage: "fragment",
         modules
@@ -1472,7 +1438,7 @@ precision highp float;
       getUniforms: assembleGetUniforms(modules)
     };
   }
-  function assembleWGSLShader(platformInfo, options) {
+  function assembleShaderWGSL(platformInfo, options) {
     const {
       // id,
       source,
@@ -1537,7 +1503,7 @@ precision highp float;
     assembledSource = injectShader(assembledSource, stage, mainInjections);
     return assembledSource;
   }
-  function assembleGLSLShader(platformInfo, options) {
+  function assembleShaderGLSL(platformInfo, options) {
     const {
       id,
       source,
@@ -1666,6 +1632,29 @@ ${getApplicationDefines(allDefines)}
     return sourceText;
   }
 
+  // ../shadertools/src/lib/preprocessor/preprocessor.ts
+  var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
+  var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
+  function preprocess(source, options) {
+    const lines = source.split("\n");
+    const output = [];
+    let conditional = true;
+    let currentDefine = null;
+    for (const line of lines) {
+      const matchIf = line.match(IFDEF_REGEXP);
+      const matchEnd = line.match(ENDIF_REGEXP);
+      if (matchIf) {
+        currentDefine = matchIf[1];
+        conditional = Boolean(options?.defines?.[currentDefine]);
+      } else if (matchEnd) {
+        conditional = true;
+      } else if (conditional) {
+        output.push(line);
+      }
+    }
+    return output.join("\n");
+  }
+
   // ../shadertools/src/lib/shader-assembler.ts
   var _ShaderAssembler = class {
     /** Hook functions */
@@ -1709,22 +1698,23 @@ ${getApplicationDefines(allDefines)}
       this._hookFunctions.push(hook);
     }
     /**
-     * Assemble a pair of shaders into a single shader program
+     * Assemble a WGSL unified shader
      * @param platformInfo
      * @param props
      * @returns
      */
-    assembleShader(props) {
+    assembleWGSLShader(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
-      const options = selectShaders(props);
-      const assembled = assembleShaderWGSL({
-        platformInfo: props.platformInfo,
-        ...options,
+      const { source, getUniforms } = assembleWGSLShader({
+        ...props,
+        // @ts-expect-error
+        source: props.source,
         modules,
         hookFunctions
       });
-      return { ...assembled, modules };
+      const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source) : source;
+      return { source: preprocessedSource, getUniforms, modules };
     }
     /**
      * Assemble a pair of shaders into a single shader program
@@ -1732,13 +1722,18 @@ ${getApplicationDefines(allDefines)}
      * @param props
      * @returns
      */
-    assembleShaderPair(props) {
-      const options = selectShaders(props);
+    assembleGLSLShaderPair(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
-      const { platformInfo } = props;
-      const isWGSL = props.platformInfo.shaderLanguage === "wgsl";
-      const assembled = isWGSL ? assembleShaderPairWGSL({ platformInfo, ...options, modules, hookFunctions }) : assembleShaderPairGLSL({ platformInfo, ...options, modules, hookFunctions });
+      const assembled = assembleGLSLShaderPair({
+        ...props,
+        // @ts-expect-error
+        vs: props.vs,
+        // @ts-expect-error
+        fs: props.fs,
+        modules,
+        hookFunctions
+      });
       return { ...assembled, modules };
     }
     /**
@@ -1827,9 +1822,9 @@ void main() {
   }
 
   // ../shadertools/src/lib/wgsl/get-shader-layout-wgsl.ts
-  var import_core4 = __toESM(require_core(), 1);
+  var import_core3 = __toESM(require_core(), 1);
 
-  // ../shadertools/src/libs/wgsl-reflect/wgsl_reflect.module.js
+  // ../../node_modules/wgsl_reflect/wgsl_reflect.module.js
   var ParseContext = class {
     constructor() {
       this.constants = /* @__PURE__ */ new Map();
@@ -1852,23 +1847,50 @@ void main() {
     evaluateString(context) {
       return this.evaluate(context).toString();
     }
+    search(callback) {
+    }
+    searchBlock(block, callback) {
+      if (block) {
+        callback(_BlockStart.instance);
+        for (const node of block) {
+          if (node instanceof Array) {
+            this.searchBlock(node, callback);
+          } else {
+            node.search(callback);
+          }
+        }
+        callback(_BlockEnd.instance);
+      }
+    }
   };
+  var _BlockStart = class extends Node {
+  };
+  _BlockStart.instance = new _BlockStart();
+  var _BlockEnd = class extends Node {
+  };
+  _BlockEnd.instance = new _BlockEnd();
   var Statement = class extends Node {
     constructor() {
       super();
     }
   };
   var Function = class extends Statement {
-    constructor(name, args, returnType, body) {
+    constructor(name, args, returnType, body, startLine, endLine) {
       super();
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.args = args;
       this.returnType = returnType;
       this.body = body;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "function";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var StaticAssert = class extends Statement {
     constructor(expression) {
@@ -1878,6 +1900,9 @@ void main() {
     get astNodeType() {
       return "staticAssert";
     }
+    search(callback) {
+      this.expression.search(callback);
+    }
   };
   var While = class extends Statement {
     constructor(condition, body) {
@@ -1888,6 +1913,10 @@ void main() {
     get astNodeType() {
       return "while";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Continuing = class extends Statement {
     constructor(body) {
@@ -1897,6 +1926,9 @@ void main() {
     get astNodeType() {
       return "continuing";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var For = class extends Statement {
     constructor(init, condition, increment, body) {
@@ -1909,6 +1941,13 @@ void main() {
     get astNodeType() {
       return "for";
     }
+    search(callback) {
+      var _a2, _b, _c;
+      (_a2 = this.init) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+      (_b = this.condition) === null || _b === void 0 ? void 0 : _b.search(callback);
+      (_c = this.increment) === null || _c === void 0 ? void 0 : _c.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Var = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1922,6 +1961,11 @@ void main() {
     get astNodeType() {
       return "var";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Override = class extends Statement {
     constructor(name, type, value) {
@@ -1933,6 +1977,10 @@ void main() {
     get astNodeType() {
       return "override";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Let = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1946,6 +1994,11 @@ void main() {
     get astNodeType() {
       return "let";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Const = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1962,6 +2015,11 @@ void main() {
     evaluate(context) {
       return this.value.evaluate(context);
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var IncrementOperator;
   (function(IncrementOperator2) {
@@ -1986,6 +2044,9 @@ void main() {
     get astNodeType() {
       return "increment";
     }
+    search(callback) {
+      this.variable.search(callback);
+    }
   };
   var AssignOperator;
   (function(AssignOperator2) {
@@ -2004,9 +2065,10 @@ void main() {
   (function(AssignOperator2) {
     function parse(val) {
       const key = val;
-      if (key == "parse")
+      if (key == "parse") {
         throw new Error("Invalid value for AssignOperator");
-      return AssignOperator2[key];
+      }
+      return key;
     }
     AssignOperator2.parse = parse;
   })(AssignOperator || (AssignOperator = {}));
@@ -2020,6 +2082,9 @@ void main() {
     get astNodeType() {
       return "assign";
     }
+    search(callback) {
+      this.value.search(callback);
+    }
   };
   var Call = class extends Statement {
     constructor(name, args) {
@@ -2030,6 +2095,12 @@ void main() {
     get astNodeType() {
       return "call";
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var Loop = class extends Statement {
     constructor(body, continuing) {
@@ -2062,6 +2133,12 @@ void main() {
     get astNodeType() {
       return "if";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+      this.searchBlock(this.elseif, callback);
+      this.searchBlock(this.else, callback);
+    }
   };
   var Return = class extends Statement {
     constructor(value) {
@@ -2071,6 +2148,10 @@ void main() {
     get astNodeType() {
       return "return";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Enable = class extends Statement {
     constructor(name) {
@@ -2081,6 +2162,16 @@ void main() {
       return "enable";
     }
   };
+  var Diagnostic = class extends Statement {
+    constructor(severity, rule) {
+      super();
+      this.severity = severity;
+      this.rule = rule;
+    }
+    get astNodeType() {
+      return "diagnostic";
+    }
+  };
   var Alias = class extends Statement {
     constructor(name, type) {
       super();
@@ -2131,9 +2222,11 @@ void main() {
     }
   };
   var Struct = class extends Type {
-    constructor(name, members) {
+    constructor(name, members, startLine, endLine) {
       super(name);
       this.members = members;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "struct";
@@ -2224,6 +2317,12 @@ void main() {
     get astNodeType() {
       return "createExpr";
     }
+    search(callback) {
+      callback(this);
+      for (const node of this.args) {
+        node.search(callback);
+      }
+    }
   };
   var CallExpr = class extends Expression {
     constructor(name, args) {
@@ -2317,6 +2416,12 @@ void main() {
           throw new Error("Non const function: " + this.name);
       }
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var VariableExpr = class extends Expression {
     constructor(name) {
@@ -2326,6 +2431,16 @@ void main() {
     get astNodeType() {
       return "varExpr";
     }
+    search(callback) {
+      callback(this);
+    }
+    evaluate(context) {
+      const constant = context.constants.get(this.name);
+      if (!constant) {
+        throw new Error("Cannot evaluate node");
+      }
+      return constant.evaluate(context);
+    }
   };
   var ConstExpr = class extends Expression {
     constructor(name, initializer) {
@@ -2351,6 +2466,9 @@ void main() {
       }
       return this.initializer.evaluate(context);
     }
+    search(callback) {
+      this.initializer.search(callback);
+    }
   };
   var LiteralExpr = class extends Expression {
     constructor(value) {
@@ -2373,6 +2491,9 @@ void main() {
     get astNodeType() {
       return "bitcastExpr";
     }
+    search(callback) {
+      this.value.search(callback);
+    }
   };
   var TypecastExpr = class extends Expression {
     constructor(type, args) {
@@ -2386,6 +2507,9 @@ void main() {
     evaluate(context) {
       return this.args[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.args, callback);
+    }
   };
   var GroupingExpr = class extends Expression {
     constructor(contents) {
@@ -2398,6 +2522,9 @@ void main() {
     evaluate(context) {
       return this.contents[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.contents, callback);
+    }
   };
   var Operator = class extends Expression {
     constructor() {
@@ -2427,6 +2554,9 @@ void main() {
           throw new Error("Unknown unary operator: " + this.operator);
       }
     }
+    search(callback) {
+      this.right.search(callback);
+    }
   };
   var BinaryOperator = class extends Operator {
     constructor(operator, left, right) {
@@ -2470,6 +2600,10 @@ void main() {
           throw new Error(`Unknown operator ${this.operator}`);
       }
     }
+    search(callback) {
+      this.left.search(callback);
+      this.right.search(callback);
+    }
   };
   var SwitchCase = class extends Node {
     constructor() {
@@ -2485,6 +2619,9 @@ void main() {
     get astNodeType() {
       return "case";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Default = class extends SwitchCase {
     constructor(body) {
@@ -2494,6 +2631,9 @@ void main() {
     get astNodeType() {
       return "default";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Argument = class extends Node {
     constructor(name, type, attributes) {
@@ -2515,6 +2655,10 @@ void main() {
     get astNodeType() {
       return "elseif";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Member = class extends Node {
     constructor(name, type, attributes) {
@@ -2632,6 +2776,7 @@ void main() {
     discard: new TokenType("discard", TokenClass.keyword, "discard"),
     else: new TokenType("else", TokenClass.keyword, "else"),
     enable: new TokenType("enable", TokenClass.keyword, "enable"),
+    diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"),
     fallthrough: new TokenType("fallthrough", TokenClass.keyword, "fallthrough"),
     false: new TokenType("false", TokenClass.keyword, "false"),
     fn: new TokenType("fn", TokenClass.keyword, "fn"),
@@ -2704,7 +2849,7 @@ void main() {
     hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),
     int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),
     uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),
-    ident: new TokenType("ident", TokenClass.token, /[a-zA-Z][0-9a-zA-Z_]*/),
+    ident: new TokenType("ident", TokenClass.token, /[_a-zA-Z][0-9a-zA-Z_]*/),
     and: new TokenType("and", TokenClass.token, "&"),
     and_and: new TokenType("and_and", TokenClass.token, "&&"),
     arrow: new TokenType("arrow ", TokenClass.token, "->"),
@@ -2925,8 +3070,9 @@ void main() {
     scanTokens() {
       while (!this._isAtEnd()) {
         this._start = this._current;
-        if (!this.scanToken())
+        if (!this.scanToken()) {
           throw `Invalid syntax at line ${this._line}`;
+        }
       }
       this._tokens.push(new Token(TokenTypes.eof, "", this._line));
       return this._tokens;
@@ -2944,8 +3090,9 @@ void main() {
       if (lexeme == "/") {
         if (this._peekAhead() == "/") {
           while (lexeme != "\n") {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
           }
           this._line++;
@@ -2954,8 +3101,9 @@ void main() {
           this._advance();
           let commentLevel = 1;
           while (commentLevel > 0) {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
             if (lexeme == "\n") {
               this._line++;
@@ -3010,8 +3158,9 @@ void main() {
             }
           }
           if (matchedType === TokenTypes.none) {
-            if (matchType === TokenTypes.none)
+            if (matchType === TokenTypes.none) {
               return false;
+            }
             this._current--;
             this._addToken(matchType);
             return true;
@@ -3020,12 +3169,14 @@ void main() {
           this._current += lookAhead + 1;
         }
         matchType = matchedType;
-        if (this._isAtEnd())
+        if (this._isAtEnd()) {
           break;
+        }
         lexeme += this._advance();
       }
-      if (matchType === TokenTypes.none)
+      if (matchType === TokenTypes.none) {
         return false;
+      }
       this._addToken(matchType);
       return true;
     }
@@ -3051,8 +3202,9 @@ void main() {
         }
       } else {
         const match = rule.exec(lexeme);
-        if (match && match.index == 0 && match[0] == lexeme)
+        if (match && match.index == 0 && match[0] == lexeme) {
           return true;
+        }
       }
       return false;
     }
@@ -3071,8 +3223,9 @@ void main() {
     }
     _peekAhead(offset = 0) {
       offset = offset || 0;
-      if (this._current + offset >= this._source.length)
+      if (this._current + offset >= this._source.length) {
         return "\0";
+      }
       return this._source[this._current + offset];
     }
     _addToken(type) {
@@ -3084,17 +3237,40 @@ void main() {
     constructor() {
       this._tokens = [];
       this._current = 0;
+      this._currentLine = 0;
       this._context = new ParseContext();
+      this._deferArrayCountEval = [];
     }
     parse(tokensOrCode) {
       this._initialize(tokensOrCode);
-      let statements = [];
+      this._deferArrayCountEval.length = 0;
+      const statements = [];
       while (!this._isAtEnd()) {
         const statement = this._global_decl_or_directive();
-        if (!statement)
+        if (!statement) {
           break;
+        }
         statements.push(statement);
       }
+      if (this._deferArrayCountEval.length > 0) {
+        for (const arrayDecl of this._deferArrayCountEval) {
+          const arrayType = arrayDecl["arrayType"];
+          const countNode = arrayDecl["countNode"];
+          if (countNode instanceof VariableExpr) {
+            const variable = countNode;
+            const name = variable.name;
+            const constant = this._context.constants.get(name);
+            if (constant) {
+              try {
+                const count = constant.evaluate(this._context);
+                arrayType.count = count;
+              } catch (e) {
+              }
+            }
+          }
+        }
+        this._deferArrayCountEval.length = 0;
+      }
       return statements;
     }
     _initialize(tokensOrCode) {
@@ -3111,7 +3287,6 @@ void main() {
       this._current = 0;
     }
     _error(token, message) {
-      console.error(token, message);
       return {
         token,
         message,
@@ -3141,24 +3316,29 @@ void main() {
       return false;
     }
     _consume(types, message) {
-      if (this._check(types))
+      if (this._check(types)) {
         return this._advance();
+      }
       throw this._error(this._peek(), message);
     }
     _check(types) {
-      if (this._isAtEnd())
+      if (this._isAtEnd()) {
         return false;
+      }
       const tk = this._peek();
       if (types instanceof Array) {
-        let t = tk.type;
-        let index2 = types.indexOf(t);
+        const t = tk.type;
+        const index2 = types.indexOf(t);
         return index2 != -1;
       }
       return tk.type == types;
     }
     _advance() {
-      if (!this._isAtEnd())
+      var _a2, _b;
+      this._currentLine = (_b = (_a2 = this._peek()) === null || _a2 === void 0 ? void 0 : _a2.line) !== null && _b !== void 0 ? _b : -1;
+      if (!this._isAtEnd()) {
         this._current++;
+      }
       return this._previous();
     }
     _peek() {
@@ -3175,6 +3355,11 @@ void main() {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
         return type;
       }
+      if (this._match(TokenTypes.keywords.diagnostic)) {
+        const directive = this._diagnostic();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return directive;
+      }
       if (this._match(TokenTypes.keywords.enable)) {
         const enable = this._enable_directive();
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
@@ -3183,56 +3368,65 @@ void main() {
       const attrs = this._attribute();
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._global_variable_decl();
-        if (_var != null)
+        if (_var != null) {
           _var.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _var;
       }
       if (this._check(TokenTypes.keywords.override)) {
         const _override = this._override_variable_decl();
-        if (_override != null)
+        if (_override != null) {
           _override.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _override;
       }
       if (this._check(TokenTypes.keywords.let)) {
         const _let = this._global_let_decl();
-        if (_let != null)
+        if (_let != null) {
           _let.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _let;
       }
       if (this._check(TokenTypes.keywords.const)) {
         const _const = this._global_const_decl();
-        if (_const != null)
+        if (_const != null) {
           _const.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _const;
       }
       if (this._check(TokenTypes.keywords.struct)) {
         const _struct = this._struct_decl();
-        if (_struct != null)
+        if (_struct != null) {
           _struct.attributes = attrs;
+        }
         return _struct;
       }
       if (this._check(TokenTypes.keywords.fn)) {
         const _fn = this._function_decl();
-        if (_fn != null)
+        if (_fn != null) {
           _fn.attributes = attrs;
+        }
         return _fn;
       }
       return null;
     }
     _function_decl() {
-      if (!this._match(TokenTypes.keywords.fn))
+      if (!this._match(TokenTypes.keywords.fn)) {
         return null;
+      }
+      const startLine = this._currentLine;
       const name = this._consume(TokenTypes.tokens.ident, "Expected function name.").toString();
       this._consume(TokenTypes.tokens.paren_left, "Expected '(' for function arguments.");
       const args = [];
       if (!this._check(TokenTypes.tokens.paren_right)) {
         do {
-          if (this._check(TokenTypes.tokens.paren_right))
+          if (this._check(TokenTypes.tokens.paren_right)) {
             break;
+          }
           const argAttrs = this._attribute();
           const name2 = this._consume(TokenTypes.tokens.ident, "Expected argument name.").toString();
           this._consume(TokenTypes.tokens.colon, "Expected ':' for argument type.");
@@ -3249,19 +3443,22 @@ void main() {
       if (this._match(TokenTypes.tokens.arrow)) {
         const attrs = this._attribute();
         _return = this._type_decl();
-        if (_return != null)
+        if (_return != null) {
           _return.attributes = attrs;
+        }
       }
       const body = this._compound_statement();
-      return new Function(name, args, _return, body);
+      const endLine = this._currentLine;
+      return new Function(name, args, _return, body, startLine, endLine);
     }
     _compound_statement() {
       const statements = [];
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for block.");
       while (!this._check(TokenTypes.tokens.brace_right)) {
         const statement = this._statement();
-        if (statement !== null)
+        if (statement !== null) {
           statements.push(statement);
+        }
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block.");
       return statements;
@@ -3269,65 +3466,79 @@ void main() {
     _statement() {
       while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
         ;
-      if (this._check(TokenTypes.keywords.if))
+      if (this._check(TokenTypes.keywords.if)) {
         return this._if_statement();
-      if (this._check(TokenTypes.keywords.switch))
+      }
+      if (this._check(TokenTypes.keywords.switch)) {
         return this._switch_statement();
-      if (this._check(TokenTypes.keywords.loop))
+      }
+      if (this._check(TokenTypes.keywords.loop)) {
         return this._loop_statement();
-      if (this._check(TokenTypes.keywords.for))
+      }
+      if (this._check(TokenTypes.keywords.for)) {
         return this._for_statement();
-      if (this._check(TokenTypes.keywords.while))
+      }
+      if (this._check(TokenTypes.keywords.while)) {
         return this._while_statement();
-      if (this._check(TokenTypes.keywords.continuing))
+      }
+      if (this._check(TokenTypes.keywords.continuing)) {
         return this._continuing_statement();
-      if (this._check(TokenTypes.keywords.static_assert))
+      }
+      if (this._check(TokenTypes.keywords.static_assert)) {
         return this._static_assert_statement();
-      if (this._check(TokenTypes.tokens.brace_left))
+      }
+      if (this._check(TokenTypes.tokens.brace_left)) {
         return this._compound_statement();
+      }
       let result = null;
-      if (this._check(TokenTypes.keywords.return))
+      if (this._check(TokenTypes.keywords.return)) {
         result = this._return_statement();
-      else if (this._check([
+      } else if (this._check([
         TokenTypes.keywords.var,
         TokenTypes.keywords.let,
         TokenTypes.keywords.const
-      ]))
+      ])) {
         result = this._variable_statement();
-      else if (this._match(TokenTypes.keywords.discard))
+      } else if (this._match(TokenTypes.keywords.discard)) {
         result = new Discard();
-      else if (this._match(TokenTypes.keywords.break))
+      } else if (this._match(TokenTypes.keywords.break)) {
         result = new Break();
-      else if (this._match(TokenTypes.keywords.continue))
+      } else if (this._match(TokenTypes.keywords.continue)) {
         result = new Continue();
-      else
+      } else {
         result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement();
-      if (result != null)
+      }
+      if (result != null) {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement.");
+      }
       return result;
     }
     _static_assert_statement() {
-      if (!this._match(TokenTypes.keywords.static_assert))
+      if (!this._match(TokenTypes.keywords.static_assert)) {
         return null;
-      let expression = this._optional_paren_expression();
+      }
+      const expression = this._optional_paren_expression();
       return new StaticAssert(expression);
     }
     _while_statement() {
-      if (!this._match(TokenTypes.keywords.while))
+      if (!this._match(TokenTypes.keywords.while)) {
         return null;
-      let condition = this._optional_paren_expression();
+      }
+      const condition = this._optional_paren_expression();
       const block = this._compound_statement();
       return new While(condition, block);
     }
     _continuing_statement() {
-      if (!this._match(TokenTypes.keywords.continuing))
+      if (!this._match(TokenTypes.keywords.continuing)) {
         return null;
+      }
       const block = this._compound_statement();
       return new Continuing(block);
     }
     _for_statement() {
-      if (!this._match(TokenTypes.keywords.for))
+      if (!this._match(TokenTypes.keywords.for)) {
         return null;
+      }
       this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
       const init = !this._check(TokenTypes.tokens.semicolon) ? this._for_init() : null;
       this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
@@ -3347,11 +3558,13 @@ void main() {
     _variable_statement() {
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._variable_decl();
-        if (_var === null)
+        if (_var === null) {
           throw this._error(this._peek(), "Variable declaration expected.");
+        }
         let value = null;
-        if (this._match(TokenTypes.tokens.equal))
+        if (this._match(TokenTypes.tokens.equal)) {
           value = this._short_circuit_or_expression();
+        }
         return new Var(_var.name, _var.type, _var.storage, _var.access, value);
       }
       if (this._match(TokenTypes.keywords.let)) {
@@ -3360,8 +3573,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for let.");
         const value = this._short_circuit_or_expression();
@@ -3373,8 +3587,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for const.");
         const value = this._short_circuit_or_expression();
@@ -3385,8 +3600,9 @@ void main() {
     _increment_decrement_statement() {
       const savedPos = this._current;
       const _var = this._unary_expression();
-      if (_var == null)
+      if (_var == null) {
         return null;
+      }
       if (!this._check(TokenTypes.increment_operators)) {
         this._current = savedPos;
         return null;
@@ -3396,20 +3612,24 @@ void main() {
     }
     _assignment_statement() {
       let _var = null;
-      if (this._check(TokenTypes.tokens.brace_right))
+      if (this._check(TokenTypes.tokens.brace_right)) {
         return null;
+      }
       let isUnderscore = this._match(TokenTypes.tokens.underscore);
-      if (!isUnderscore)
+      if (!isUnderscore) {
         _var = this._unary_expression();
-      if (!isUnderscore && _var == null)
+      }
+      if (!isUnderscore && _var == null) {
         return null;
+      }
       const type = this._consume(TokenTypes.assignment_operators, "Expected assignment operator.");
       const value = this._short_circuit_or_expression();
       return new Assign(AssignOperator.parse(type.lexeme), _var, value);
     }
     _func_call_statement() {
-      if (!this._check(TokenTypes.tokens.ident))
+      if (!this._check(TokenTypes.tokens.ident)) {
         return null;
+      }
       const savedPos = this._current;
       const name = this._consume(TokenTypes.tokens.ident, "Expected function name.");
       const args = this._argument_expression_list();
@@ -3420,8 +3640,9 @@ void main() {
       return new Call(name.lexeme, args);
     }
     _loop_statement() {
-      if (!this._match(TokenTypes.keywords.loop))
+      if (!this._match(TokenTypes.keywords.loop)) {
         return null;
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop.");
       const statements = [];
       let statement = this._statement();
@@ -3436,19 +3657,22 @@ void main() {
         statement = this._statement();
       }
       let continuing = null;
-      if (this._match(TokenTypes.keywords.continuing))
+      if (this._match(TokenTypes.keywords.continuing)) {
         continuing = this._compound_statement();
+      }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for loop.");
       return new Loop(statements, continuing);
     }
     _switch_statement() {
-      if (!this._match(TokenTypes.keywords.switch))
+      if (!this._match(TokenTypes.keywords.switch)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch.");
       const body = this._switch_body();
-      if (body == null || body.length == 0)
+      if (body == null || body.length == 0) {
         throw this._error(this._previous(), "Expected 'case' or 'default'.");
+      }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for switch.");
       return new Switch(condition, body);
     }
@@ -3476,12 +3700,12 @@ void main() {
       return cases;
     }
     _case_selectors() {
-      var _a2, _b, _c, _d;
       const selectors = [
-        (_b = (_a2 = this._shift_expression()) === null || _a2 === void 0 ? void 0 : _a2.evaluate(this._context).toString()) !== null && _b !== void 0 ? _b : ""
+        this._shift_expression()
+        //?.evaluate(this._context).toString() ?? "",
       ];
       while (this._match(TokenTypes.tokens.comma)) {
-        selectors.push((_d = (_c = this._shift_expression()) === null || _c === void 0 ? void 0 : _c.evaluate(this._context).toString()) !== null && _d !== void 0 ? _d : "");
+        selectors.push(this._shift_expression());
       }
       return selectors;
     }
@@ -3491,19 +3715,22 @@ void main() {
         return [];
       }
       let statement = this._statement();
-      if (statement == null)
+      if (statement == null) {
         return [];
+      }
       if (!(statement instanceof Array)) {
         statement = [statement];
       }
       const nextStatement = this._case_body();
-      if (nextStatement.length == 0)
+      if (nextStatement.length == 0) {
         return statement;
+      }
       return [...statement, nextStatement[0]];
     }
     _if_statement() {
-      if (!this._match(TokenTypes.keywords.if))
+      if (!this._match(TokenTypes.keywords.if)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
       const block = this._compound_statement();
       let elseif = [];
@@ -3511,8 +3738,9 @@ void main() {
         elseif = this._elseif_statement(elseif);
       }
       let _else = null;
-      if (this._match(TokenTypes.keywords.else))
+      if (this._match(TokenTypes.keywords.else)) {
         _else = this._compound_statement();
+      }
       return new If(condition, block, elseif, _else);
     }
     _match_elseif() {
@@ -3533,8 +3761,9 @@ void main() {
       return elseif;
     }
     _return_statement() {
-      if (!this._match(TokenTypes.keywords.return))
+      if (!this._match(TokenTypes.keywords.return)) {
         return null;
+      }
       const value = this._short_circuit_or_expression();
       return new Return(value);
     }
@@ -3701,12 +3930,14 @@ void main() {
       return new TypecastExpr(type, args);
     }
     _argument_expression_list() {
-      if (!this._match(TokenTypes.tokens.paren_left))
+      if (!this._match(TokenTypes.tokens.paren_left)) {
         return null;
+      }
       const args = [];
       do {
-        if (this._check(TokenTypes.tokens.paren_right))
+        if (this._check(TokenTypes.tokens.paren_right)) {
           break;
+        }
         const arg = this._short_circuit_or_expression();
         args.push(arg);
       } while (this._match(TokenTypes.tokens.comma));
@@ -3726,8 +3957,10 @@ void main() {
       return new GroupingExpr([expr]);
     }
     _struct_decl() {
-      if (!this._match(TokenTypes.keywords.struct))
+      if (!this._match(TokenTypes.keywords.struct)) {
         return null;
+      }
+      const startLine = this._currentLine;
       const name = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString();
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body.");
       const members = [];
@@ -3737,8 +3970,9 @@ void main() {
         this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type.");
         const typeAttrs = this._attribute();
         const memberType = this._type_decl();
-        if (memberType != null)
+        if (memberType != null) {
           memberType.attributes = typeAttrs;
+        }
         if (!this._check(TokenTypes.tokens.brace_right))
           this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member.");
         else
@@ -3746,32 +3980,37 @@ void main() {
         members.push(new Member(memberName, memberType, memberAttrs));
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body.");
-      const structNode = new Struct(name, members);
+      const endLine = this._currentLine;
+      const structNode = new Struct(name, members, startLine, endLine);
       this._context.structs.set(name, structNode);
       return structNode;
     }
     _global_variable_decl() {
       const _var = this._variable_decl();
-      if (_var && this._match(TokenTypes.tokens.equal))
+      if (_var && this._match(TokenTypes.tokens.equal)) {
         _var.value = this._const_expression();
+      }
       return _var;
     }
     _override_variable_decl() {
       const _override = this._override_decl();
-      if (_override && this._match(TokenTypes.tokens.equal))
+      if (_override && this._match(TokenTypes.tokens.equal)) {
         _override.value = this._const_expression();
+      }
       return _override;
     }
     _global_const_decl() {
-      if (!this._match(TokenTypes.keywords.const))
+      if (!this._match(TokenTypes.keywords.const)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3794,15 +4033,17 @@ void main() {
       return c;
     }
     _global_let_decl() {
-      if (!this._match(TokenTypes.keywords.let))
+      if (!this._match(TokenTypes.keywords.let)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3811,23 +4052,26 @@ void main() {
       return new Let(name.toString(), type, "", "", value);
     }
     _const_expression() {
-      if (this._match(TokenTypes.const_literal))
+      if (this._match(TokenTypes.const_literal)) {
         return new StringExpr(this._previous().toString());
+      }
       const type = this._type_decl();
       this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
       let args = [];
       while (!this._check(TokenTypes.tokens.paren_right)) {
         args.push(this._const_expression());
-        if (!this._check(TokenTypes.tokens.comma))
+        if (!this._check(TokenTypes.tokens.comma)) {
           break;
+        }
         this._advance();
       }
       this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
       return new CreateExpr(type, args);
     }
     _variable_decl() {
-      if (!this._match(TokenTypes.keywords.var))
+      if (!this._match(TokenTypes.keywords.var)) {
         return null;
+      }
       let storage = "";
       let access = "";
       if (this._match(TokenTypes.tokens.less_than)) {
@@ -3841,24 +4085,35 @@ void main() {
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Var(name.toString(), type, storage, access, null);
     }
     _override_decl() {
-      if (!this._match(TokenTypes.keywords.override))
+      if (!this._match(TokenTypes.keywords.override)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Override(name.toString(), type, null);
     }
+    _diagnostic() {
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('");
+      const severity = this._consume(TokenTypes.tokens.ident, "Expected severity control name.");
+      this._consume(TokenTypes.tokens.comma, "Expected ','");
+      const rule = this._consume(TokenTypes.tokens.ident, "Expected diagnostic rule name.");
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
+      return new Diagnostic(severity.toString(), rule.toString());
+    }
     _enable_directive() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       return new Enable(name.toString());
@@ -3897,8 +4152,9 @@ void main() {
         return new Type(type2.toString());
       }
       let type = this._texture_sampler_types();
-      if (type)
+      if (type) {
         return type;
+      }
       if (this._check(TokenTypes.template_types)) {
         let type2 = this._advance().toString();
         let format = null;
@@ -3906,8 +4162,9 @@ void main() {
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           access = null;
-          if (this._match(TokenTypes.tokens.comma))
+          if (this._match(TokenTypes.tokens.comma)) {
             access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+          }
           this._consume(TokenTypes.tokens.greater_than, "Expected '>' for type.");
         }
         return new TemplateType(type2, format, access);
@@ -3919,8 +4176,9 @@ void main() {
         this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer.");
         const decl = this._type_decl();
         let access = null;
-        if (this._match(TokenTypes.tokens.comma))
+        if (this._match(TokenTypes.tokens.comma)) {
           access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+        }
         this._consume(TokenTypes.tokens.greater_than, "Expected '>' for pointer.");
         return new PointerType(pointer, storage.toString(), decl, access);
       }
@@ -3929,6 +4187,7 @@ void main() {
         let format = null;
         let countInt = -1;
         const array = this._previous();
+        let countNode = null;
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           if (this._context.aliases.has(format.name)) {
@@ -3936,21 +4195,32 @@ void main() {
           }
           let count = "";
           if (this._match(TokenTypes.tokens.comma)) {
-            let c = this._shift_expression();
-            count = c.evaluate(this._context).toString();
+            countNode = this._shift_expression();
+            try {
+              count = countNode.evaluate(this._context).toString();
+              countNode = null;
+            } catch (e) {
+              count = "1";
+            }
           }
           this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array.");
           countInt = count ? parseInt(count) : 0;
         }
-        return new ArrayType(array.toString(), attrs, format, countInt);
+        const arrayType = new ArrayType(array.toString(), attrs, format, countInt);
+        if (countNode) {
+          this._deferArrayCountEval.push({ arrayType, countNode });
+        }
+        return arrayType;
       }
       return null;
     }
     _texture_sampler_types() {
-      if (this._match(TokenTypes.sampler_type))
+      if (this._match(TokenTypes.sampler_type)) {
         return new SamplerType(this._previous().toString(), null, null);
-      if (this._match(TokenTypes.depth_texture_type))
+      }
+      if (this._match(TokenTypes.depth_texture_type)) {
         return new SamplerType(this._previous().toString(), null, null);
+      }
       if (this._match(TokenTypes.sampled_texture_type) || this._match(TokenTypes.multisampled_texture_type)) {
         const sampler = this._previous();
         this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type.");
@@ -4013,8 +4283,9 @@ void main() {
         }
         this._consume(TokenTypes.tokens.attr_right, "Expected ']]' after attribute declarations");
       }
-      if (attributes.length == 0)
+      if (attributes.length == 0) {
         return null;
+      }
       return attributes;
     }
   };
@@ -4072,6 +4343,9 @@ void main() {
       super(name, attributes);
       this.members = [];
       this.align = 0;
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
     }
     get isStruct() {
       return true;
@@ -4177,6 +4451,11 @@ void main() {
       this.stage = null;
       this.inputs = [];
       this.outputs = [];
+      this.resources = [];
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.stage = stage;
     }
@@ -4196,6 +4475,14 @@ void main() {
       this.id = id;
     }
   };
+  var _FunctionResources = class {
+    constructor(node) {
+      this.resources = null;
+      this.inUse = false;
+      this.info = null;
+      this.node = node;
+    }
+  };
   var WgslReflect = class {
     constructor(code) {
       this.uniforms = [];
@@ -4206,7 +4493,9 @@ void main() {
       this.overrides = [];
       this.structs = [];
       this.entry = new EntryFunctions();
+      this.functions = [];
       this._types = /* @__PURE__ */ new Map();
+      this._functions = /* @__PURE__ */ new Map();
       if (code) {
         this.update(code);
       }
@@ -4217,14 +4506,20 @@ void main() {
     update(code) {
       const parser = new WgslParser();
       const ast = parser.parse(code);
+      for (const node of ast) {
+        if (node instanceof Function) {
+          this._functions.set(node.name, new _FunctionResources(node));
+        }
+      }
       for (const node of ast) {
         if (node instanceof Struct) {
           const info = this._getTypeInfo(node, null);
           if (info instanceof StructInfo) {
             this.structs.push(info);
           }
-          continue;
         }
+      }
+      for (const node of ast) {
         if (node instanceof Alias) {
           this.aliases.push(this._getAliasInfo(node));
           continue;
@@ -4283,8 +4578,15 @@ void main() {
           const fragmentStage = this._getAttribute(node, "fragment");
           const computeStage = this._getAttribute(node, "compute");
           const stage = vertexStage || fragmentStage || computeStage;
+          const fn = new FunctionInfo(node.name, stage === null || stage === void 0 ? void 0 : stage.name);
+          fn.startLine = node.startLine;
+          fn.endLine = node.endLine;
+          this.functions.push(fn);
+          this._functions.get(node.name).info = fn;
           if (stage) {
-            const fn = new FunctionInfo(node.name, stage.name);
+            this._functions.get(node.name).inUse = true;
+            fn.inUse = true;
+            fn.resources = this._findResources(node, !!stage);
             fn.inputs = this._getInputs(node.args);
             fn.outputs = this._getOutputs(node.returnType);
             this.entry[stage.name].push(fn);
@@ -4292,48 +4594,214 @@ void main() {
           continue;
         }
       }
+      for (const fn of this._functions.values()) {
+        if (fn.info) {
+          fn.info.inUse = fn.inUse;
+          this._addCalls(fn.node, fn.info.calls);
+        }
+      }
+      for (const u of this.uniforms) {
+        this._markStructsInUse(u.type);
+      }
+      for (const s of this.storage) {
+        this._markStructsInUse(s.type);
+      }
     }
-    getBindGroups() {
-      const groups = [];
-      function _makeRoom(group, binding) {
-        if (group >= groups.length)
-          groups.length = group + 1;
-        if (groups[group] === void 0)
-          groups[group] = [];
-        if (binding >= groups[group].length)
-          groups[group].length = binding + 1;
+    _markStructsInUse(type) {
+      if (type.isStruct) {
+        type.inUse = true;
+        for (const m of type.members) {
+          this._markStructsInUse(m.type);
+        }
+      } else if (type.isArray) {
+        this._markStructsInUse(type.format);
+      } else if (type.isTemplate) {
+        this._markStructsInUse(type.format);
+      } else {
+        const alias = this._getAlias(type.name);
+        if (alias) {
+          this._markStructsInUse(alias);
+        }
+      }
+    }
+    _addCalls(fn, calls) {
+      var _a2;
+      for (const call of fn.calls) {
+        const info = (_a2 = this._functions.get(call.name)) === null || _a2 === void 0 ? void 0 : _a2.info;
+        if (info) {
+          calls.add(info);
+        }
       }
+    }
+    /// Find a resource by its group and binding.
+    findResource(group, binding) {
       for (const u of this.uniforms) {
-        _makeRoom(u.group, u.binding);
-        const group = groups[u.group];
-        group[u.binding] = u;
+        if (u.group == group && u.binding == binding) {
+          return u;
+        }
       }
-      for (const u of this.storage) {
-        _makeRoom(u.group, u.binding);
-        const group = groups[u.group];
-        group[u.binding] = u;
+      for (const s of this.storage) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
       }
       for (const t of this.textures) {
-        _makeRoom(t.group, t.binding);
-        const group = groups[t.group];
-        group[t.binding] = t;
+        if (t.group == group && t.binding == binding) {
+          return t;
+        }
       }
-      for (const t of this.samplers) {
-        _makeRoom(t.group, t.binding);
-        const group = groups[t.group];
-        group[t.binding] = t;
+      for (const s of this.samplers) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
       }
-      return groups;
+      return null;
     }
-    _getOutputs(type, outputs = void 0) {
-      if (outputs === void 0)
-        outputs = [];
+    _findResource(name) {
+      for (const u of this.uniforms) {
+        if (u.name == name) {
+          return u;
+        }
+      }
+      for (const s of this.storage) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      for (const t of this.textures) {
+        if (t.name == name) {
+          return t;
+        }
+      }
+      for (const s of this.samplers) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      return null;
+    }
+    _markStructsFromAST(type) {
+      const info = this._getTypeInfo(type, null);
+      this._markStructsInUse(info);
+    }
+    _findResources(fn, isEntry) {
+      const resources = [];
+      const self = this;
+      const varStack = [];
+      fn.search((node) => {
+        if (node instanceof _BlockStart) {
+          varStack.push({});
+        } else if (node instanceof _BlockEnd) {
+          varStack.pop();
+        } else if (node instanceof Var) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof CreateExpr) {
+          const c = node;
+          if (isEntry && c.type !== null) {
+            this._markStructsFromAST(c.type);
+          }
+        } else if (node instanceof Let) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof VariableExpr) {
+          const v = node;
+          if (varStack.length > 0) {
+            const varInfo2 = varStack[varStack.length - 1][v.name];
+            if (varInfo2) {
+              return;
+            }
+          }
+          const varInfo = self._findResource(v.name);
+          if (varInfo) {
+            resources.push(varInfo);
+          }
+        } else if (node instanceof CallExpr) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        } else if (node instanceof Call) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        }
+      });
+      return [...new Map(resources.map((r) => [r.name, r])).values()];
+    }
+    getBindGroups() {
+      const groups = [];
+      function _makeRoom(group, binding) {
+        if (group >= groups.length) {
+          groups.length = group + 1;
+        }
+        if (groups[group] === void 0) {
+          groups[group] = [];
+        }
+        if (binding >= groups[group].length) {
+          groups[group].length = binding + 1;
+        }
+      }
+      for (const u of this.uniforms) {
+        _makeRoom(u.group, u.binding);
+        const group = groups[u.group];
+        group[u.binding] = u;
+      }
+      for (const u of this.storage) {
+        _makeRoom(u.group, u.binding);
+        const group = groups[u.group];
+        group[u.binding] = u;
+      }
+      for (const t of this.textures) {
+        _makeRoom(t.group, t.binding);
+        const group = groups[t.group];
+        group[t.binding] = t;
+      }
+      for (const t of this.samplers) {
+        _makeRoom(t.group, t.binding);
+        const group = groups[t.group];
+        group[t.binding] = t;
+      }
+      return groups;
+    }
+    _getOutputs(type, outputs = void 0) {
+      if (outputs === void 0) {
+        outputs = [];
+      }
       if (type instanceof Struct) {
         this._getStructOutputs(type, outputs);
       } else {
         const output = this._getOutputInfo(type);
-        if (output !== null)
+        if (output !== null) {
           outputs.push(output);
+        }
       }
       return outputs;
     }
@@ -4363,15 +4831,17 @@ void main() {
       return null;
     }
     _getInputs(args, inputs = void 0) {
-      if (inputs === void 0)
+      if (inputs === void 0) {
         inputs = [];
+      }
       for (const arg of args) {
         if (arg.type instanceof Struct) {
           this._getStructInputs(arg.type, inputs);
         } else {
           const input = this._getInputInfo(arg);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
       return inputs;
@@ -4382,8 +4852,9 @@ void main() {
           this._getStructInputs(m.type, inputs);
         } else {
           const input = this._getInputInfo(m);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
     }
@@ -4416,8 +4887,9 @@ void main() {
     }
     _getAlias(name) {
       for (const a of this.aliases) {
-        if (a.name == name)
+        if (a.name == name) {
           return a.type;
+        }
       }
       return null;
     }
@@ -4441,6 +4913,8 @@ void main() {
       if (type instanceof Struct) {
         const s = type;
         const info2 = new StructInfo(s.name, attributes);
+        info2.startLine = s.startLine;
+        info2.endLine = s.endLine;
         for (const m of s.members) {
           const t = this._getTypeInfo(m.type, m.attributes);
           info2.members.push(new MemberInfo(m.name, t, m.attributes));
@@ -4493,8 +4967,9 @@ void main() {
       for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) {
         const member = struct.members[mi];
         const sizeInfo = this._getTypeSize(member);
-        if (!sizeInfo)
+        if (!sizeInfo) {
           continue;
+        }
         (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type;
         const align = sizeInfo.align;
         const size = sizeInfo.size;
@@ -4511,12 +4986,14 @@ void main() {
     }
     _getTypeSize(type) {
       var _a2;
-      if (type === null || type === void 0)
+      if (type === null || type === void 0) {
         return null;
+      }
       const explicitSize = this._getAttributeNum(type.attributes, "size", 0);
       const explicitAlign = this._getAttributeNum(type.attributes, "align", 0);
-      if (type instanceof MemberInfo)
+      if (type instanceof MemberInfo) {
         type = type.type;
+      }
       if (type instanceof TypeInfo) {
         const alias = this._getAlias(type.name);
         if (alias !== null) {
@@ -4549,8 +5026,9 @@ void main() {
         const N = arrayType.count;
         const stride = this._getAttributeNum((_a2 = type === null || type === void 0 ? void 0 : type.attributes) !== null && _a2 !== void 0 ? _a2 : null, "stride", this._roundUp(align, size));
         size = N * stride;
-        if (explicitSize)
+        if (explicitSize) {
           size = explicitSize;
+        }
         return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size));
       }
       if (type instanceof StructInfo) {
@@ -4587,18 +5065,21 @@ void main() {
     }
     _getAttribute(node, name) {
       const obj = node;
-      if (!obj || !obj["attributes"])
+      if (!obj || !obj["attributes"]) {
         return null;
+      }
       const attrs = obj["attributes"];
       for (let a of attrs) {
-        if (a.name == name)
+        if (a.name == name) {
           return a;
+        }
       }
       return null;
     }
     _getAttributeNum(attributes, name, defaultValue) {
-      if (attributes === null)
+      if (attributes === null) {
         return defaultValue;
+      }
       for (let a of attributes) {
         if (a.name == name) {
           let v = a !== null && a.value !== null ? a.value : defaultValue;
@@ -4653,15 +5134,15 @@ void main() {
     try {
       parsedWGSL = parseWGSL(source);
     } catch (error) {
-      import_core4.log.error(error.message)();
+      import_core3.log.error(error.message)();
       return shaderLayout;
     }
     for (const uniform of parsedWGSL.uniforms) {
       const members = [];
-      for (const member of uniform.type.members) {
+      for (const attribute of uniform.type?.members || []) {
         members.push({
-          name: member.name,
-          type: getType(member.type)
+          name: attribute.name,
+          type: getType(attribute.type)
         });
       }
       shaderLayout.bindings.push({
@@ -4681,7 +5162,7 @@ void main() {
         const type = getType(wgslAttribute.type);
         shaderLayout.attributes.push({
           name: wgslAttribute.name,
-          location: wgslAttribute.location,
+          location: Number(wgslAttribute.location),
           type
         });
       }
@@ -6599,7 +7080,17 @@ void main() {
   }
 
   // src/geometry/gpu-geometry.ts
-  var import_core5 = __toESM(require_core(), 1);
+  var import_core4 = __toESM(require_core(), 1);
+
+  // src/utils/uid.ts
+  var uidCounters = {};
+  function uid(id = "id") {
+    uidCounters[id] = uidCounters[id] || 1;
+    const count = uidCounters[id]++;
+    return `${id}-${count}`;
+  }
+
+  // src/geometry/gpu-geometry.ts
   var GPUGeometry = class {
     id;
     userData = {};
@@ -6610,14 +7101,16 @@ void main() {
     indices;
     attributes;
     constructor(props) {
-      this.id = props.id || (0, import_core5.uid)("geometry");
+      this.id = props.id || uid("geometry");
       this.topology = props.topology;
       this.indices = props.indices || null;
       this.attributes = props.attributes;
       this.vertexCount = props.vertexCount;
       this.bufferLayout = props.bufferLayout || [];
       if (this.indices) {
-        (0, import_core5.assert)(this.indices.usage === import_core5.Buffer.INDEX);
+        if (!(this.indices.usage & import_core4.Buffer.INDEX)) {
+          throw new Error("Index buffer must have INDEX usage");
+        }
       }
     }
     destroy() {
@@ -6633,7 +7126,7 @@ void main() {
       return this.attributes;
     }
     getIndexes() {
-      return this.indices;
+      return this.indices || null;
     }
     _calculateVertexCount(positions) {
       const vertexCount = positions.byteLength / 12;
@@ -6659,7 +7152,7 @@ void main() {
       return void 0;
     }
     const data = geometry.indices.value;
-    return device.createBuffer({ usage: import_core5.Buffer.INDEX, data });
+    return device.createBuffer({ usage: import_core4.Buffer.INDEX, data });
   }
   function getAttributeBuffersFromGeometry(device, geometry) {
     const bufferLayout = [];
@@ -6680,124 +7173,40 @@ void main() {
           name = "colors";
           break;
       }
-      attributes[name] = device.createBuffer({ data: attribute.value, id: `${attributeName}-buffer` });
-      const { value, size, normalized } = attribute;
-      bufferLayout.push({ name, format: (0, import_core5.getVertexFormatFromAttribute)(value, size, normalized) });
+      if (attribute) {
+        attributes[name] = device.createBuffer({
+          data: attribute.value,
+          id: `${attributeName}-buffer`
+        });
+        const { value, size, normalized } = attribute;
+        bufferLayout.push({ name, format: (0, import_core4.getVertexFormatFromAttribute)(value, size, normalized) });
+      }
     }
     const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
     return { attributes, bufferLayout, vertexCount };
   }
 
-  // src/shader-inputs.ts
-  var import_core6 = __toESM(require_core(), 1);
-  var ShaderInputs = class {
-    /**
-     * The map of modules
-     * @todo should should this include the resolved dependencies?
-     */
-    modules;
-    /** Stores the uniform values for each module */
-    moduleUniforms;
-    /** Stores the uniform bindings for each module  */
-    moduleBindings;
-    /** Tracks if uniforms have changed */
-    moduleUniformsChanged;
-    /**
-     * Create a new UniformStore instance
-     * @param modules
-     */
-    constructor(modules) {
-      const allModules = resolveModules(Object.values(modules));
-      import_core6.log.log(
-        1,
-        "Creating ShaderInputs with modules",
-        allModules.map((m) => m.name)
-      )();
-      this.modules = modules;
-      this.moduleUniforms = {};
-      this.moduleBindings = {};
-      for (const [name, module] of Object.entries(modules)) {
-        const moduleName = name;
-        this.moduleUniforms[moduleName] = module.defaultUniforms || {};
-        this.moduleBindings[moduleName] = {};
-      }
-    }
-    /** Destroy */
-    destroy() {
-    }
-    /**
-     * Set module props
-     */
-    setProps(props) {
-      for (const name of Object.keys(props)) {
-        const moduleName = name;
-        const moduleProps = props[moduleName];
-        const module = this.modules[moduleName];
-        if (!module) {
-          import_core6.log.warn(`Module ${name} not found`)();
-          continue;
-        }
-        const oldUniforms = this.moduleUniforms[moduleName];
-        const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
-        this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms };
-      }
-    }
-    /** Merges all bindings for the shader (from the various modules) */
-    // getUniformBlocks(): Record<string, Texture | Sampler> {
-    //   return this.moduleUniforms;
-    // }
-    /**
-     * Return the map of modules
-     * @todo should should this include the resolved dependencies?
-     */
-    getModules() {
-      return Object.values(this.modules);
-    }
-    /** Get all uniform values for all modules */
-    getUniformValues() {
-      return this.moduleUniforms;
-    }
-    /** Merges all bindings for the shader (from the various modules) */
-    getBindings() {
-      const bindings = {};
-      for (const moduleBindings of Object.values(this.moduleBindings)) {
-        Object.assign(bindings, moduleBindings);
-      }
-      return bindings;
-    }
-    getDebugTable() {
-      const table = {};
-      for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
-        for (const [key, value] of Object.entries(module)) {
-          table[`${moduleName}.${key}`] = {
-            type: this.modules[moduleName].uniformTypes?.[key],
-            value: String(value)
-          };
-        }
-      }
-      return table;
-    }
-  };
-
   // src/lib/pipeline-factory.ts
-  var import_core7 = __toESM(require_core(), 1);
+  var import_core5 = __toESM(require_core(), 1);
   var _PipelineFactory = class {
-    device;
-    _hashCounter = 0;
-    _hashes = {};
-    _renderPipelineCache = {};
-    _computePipelineCache = {};
     /** Get the singleton default pipeline factory for the specified device */
     static getDefaultPipelineFactory(device) {
       device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new _PipelineFactory(device);
       return device._lumaData.defaultPipelineFactory;
     }
+    device;
+    destroyPolicy;
+    _hashCounter = 0;
+    _hashes = {};
+    _renderPipelineCache = {};
+    _computePipelineCache = {};
     constructor(device) {
       this.device = device;
+      this.destroyPolicy = device.props._factoryDestroyPolicy;
     }
     /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */
     createRenderPipeline(props) {
-      const allProps = { ...import_core7.RenderPipeline.defaultProps, ...props };
+      const allProps = { ...import_core5.RenderPipeline.defaultProps, ...props };
       const hash = this._hashRenderPipeline(allProps);
       if (!this._renderPipelineCache[hash]) {
         const pipeline = this.device.createRenderPipeline({
@@ -6811,7 +7220,7 @@ void main() {
       return this._renderPipelineCache[hash].pipeline;
     }
     createComputePipeline(props) {
-      const allProps = { ...import_core7.ComputePipeline.defaultProps, ...props };
+      const allProps = { ...import_core5.ComputePipeline.defaultProps, ...props };
       const hash = this._hashComputePipeline(allProps);
       if (!this._computePipelineCache[hash]) {
         const pipeline = this.device.createComputePipeline({
@@ -6826,11 +7235,13 @@ void main() {
     }
     release(pipeline) {
       const hash = pipeline.hash;
-      const cache = pipeline instanceof import_core7.ComputePipeline ? this._computePipelineCache : this._renderPipelineCache;
+      const cache = pipeline instanceof import_core5.ComputePipeline ? this._computePipelineCache : this._renderPipelineCache;
       cache[hash].useCount--;
       if (cache[hash].useCount === 0) {
-        cache[hash].pipeline.destroy();
-        delete cache[hash];
+        if (this.destroyPolicy === "unused") {
+          cache[hash].pipeline.destroy();
+          delete cache[hash];
+        }
       }
     }
     // PRIVATE
@@ -6840,7 +7251,7 @@ void main() {
     }
     /** Calculate a hash based on all the inputs for a render pipeline */
     _hashRenderPipeline(props) {
-      const vsHash = this._getHash(props.vs.source);
+      const vsHash = props.vs ? this._getHash(props.vs.source) : 0;
       const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
       const varyingHash = "-";
       const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
@@ -6860,21 +7271,23 @@ void main() {
     }
   };
   var PipelineFactory = _PipelineFactory;
-  __publicField(PipelineFactory, "defaultProps", { ...import_core7.RenderPipeline.defaultProps });
+  __publicField(PipelineFactory, "defaultProps", { ...import_core5.RenderPipeline.defaultProps });
 
   // src/lib/shader-factory.ts
-  var import_core8 = __toESM(require_core(), 1);
+  var import_core6 = __toESM(require_core(), 1);
   var _ShaderFactory = class {
-    device;
-    _cache = {};
     /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
     static getDefaultShaderFactory(device) {
       device._lumaData.defaultShaderFactory ||= new _ShaderFactory(device);
       return device._lumaData.defaultShaderFactory;
     }
+    device;
+    destroyPolicy;
+    _cache = {};
     /** @internal */
     constructor(device) {
       this.device = device;
+      this.destroyPolicy = device.props._factoryDestroyPolicy;
     }
     /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
     createShader(props) {
@@ -6897,8 +7310,10 @@ void main() {
       if (cacheEntry) {
         cacheEntry.useCount--;
         if (cacheEntry.useCount === 0) {
-          delete this._cache[key];
-          cacheEntry.shader.destroy();
+          if (this.destroyPolicy === "unused") {
+            delete this._cache[key];
+            cacheEntry.shader.destroy();
+          }
         }
       }
     }
@@ -6908,7 +7323,7 @@ void main() {
     }
   };
   var ShaderFactory = _ShaderFactory;
-  __publicField(ShaderFactory, "defaultProps", { ...import_core8.Shader.defaultProps });
+  __publicField(ShaderFactory, "defaultProps", { ...import_core6.Shader.defaultProps });
 
   // src/debug/debug-shader-layout.ts
   function getDebugTableForShaderLayout(layout, name) {
@@ -6961,15 +7376,275 @@ void main() {
       canvas.style.height = "400px";
     }
     const color = fbo.device.readPixelsToArrayWebGL(fbo);
-    const imageData = ctx.createImageData(fbo.width, fbo.height);
-    const offset = 0;
-    for (let i = 0; i < color.length; i += 4) {
-      imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
-      imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
-      imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
-      imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
-    }
-    ctx.putImageData(imageData, 0, 0);
+    const imageData = ctx?.createImageData(fbo.width, fbo.height);
+    if (imageData) {
+      const offset = 0;
+      for (let i = 0; i < color.length; i += 4) {
+        imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
+        imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
+        imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
+        imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
+      }
+      ctx?.putImageData(imageData, 0, 0);
+    }
+  }
+
+  // src/utils/deep-equal.ts
+  function deepEqual(a, b, depth) {
+    if (a === b) {
+      return true;
+    }
+    if (!depth || !a || !b) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i], depth - 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (Array.isArray(b)) {
+      return false;
+    }
+    if (typeof a === "object" && typeof b === "object") {
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length) {
+        return false;
+      }
+      for (const key of aKeys) {
+        if (!b.hasOwnProperty(key)) {
+          return false;
+        }
+        if (!deepEqual(a[key], b[key], depth - 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  // ../../node_modules/@math.gl/types/dist/is-array.js
+  function isTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null;
+  }
+  function isNumericArray(value) {
+    if (Array.isArray(value)) {
+      return value.length === 0 || typeof value[0] === "number" ? value : null;
+    }
+    return isTypedArray(value);
+  }
+
+  // src/model/split-uniforms-and-bindings.ts
+  function isUniformValue(value) {
+    return isNumericArray(value) !== null || typeof value === "number" || typeof value === "boolean";
+  }
+  function splitUniformsAndBindings(uniforms) {
+    const result = { bindings: {}, uniforms: {} };
+    Object.keys(uniforms).forEach((name) => {
+      const uniform = uniforms[name];
+      if (isUniformValue(uniform)) {
+        result.uniforms[name] = uniform;
+      } else {
+        result.bindings[name] = uniform;
+      }
+    });
+    return result;
+  }
+
+  // src/shader-inputs.ts
+  var import_core7 = __toESM(require_core(), 1);
+  var ShaderInputs = class {
+    /**
+     * The map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    // @ts-expect-error Fix typings
+    modules;
+    /** Stores the uniform values for each module */
+    moduleUniforms;
+    /** Stores the uniform bindings for each module  */
+    moduleBindings;
+    /** Tracks if uniforms have changed */
+    // moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
+    /**
+     * Create a new UniformStore instance
+     * @param modules
+     */
+    // @ts-expect-error Fix typings
+    constructor(modules) {
+      const allModules = resolveModules(Object.values(modules));
+      import_core7.log.log(
+        1,
+        "Creating ShaderInputs with modules",
+        allModules.map((m) => m.name)
+      )();
+      this.modules = modules;
+      this.moduleUniforms = {};
+      this.moduleBindings = {};
+      for (const [name, module] of Object.entries(modules)) {
+        const moduleName = name;
+        this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+        this.moduleBindings[moduleName] = {};
+      }
+    }
+    /** Destroy */
+    destroy() {
+    }
+    /**
+     * Set module props
+     */
+    setProps(props) {
+      for (const name of Object.keys(props)) {
+        const moduleName = name;
+        const moduleProps = props[moduleName] || {};
+        const module = this.modules[moduleName];
+        if (!module) {
+          import_core7.log.warn(`Module ${name} not found`)();
+          continue;
+        }
+        const oldUniforms = this.moduleUniforms[moduleName];
+        const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
+        this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms };
+      }
+    }
+    /** Merges all bindings for the shader (from the various modules) */
+    // getUniformBlocks(): Record<string, Texture | Sampler> {
+    //   return this.moduleUniforms;
+    // }
+    /**
+     * Return the map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    getModules() {
+      return Object.values(this.modules);
+    }
+    /** Get all uniform values for all modules */
+    getUniformValues() {
+      return this.moduleUniforms;
+    }
+    /** Merges all bindings for the shader (from the various modules) */
+    getBindings() {
+      const bindings = {};
+      for (const moduleBindings of Object.values(this.moduleBindings)) {
+        Object.assign(bindings, moduleBindings);
+      }
+      return bindings;
+    }
+    getDebugTable() {
+      const table = {};
+      for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
+        for (const [key, value] of Object.entries(module)) {
+          table[`${moduleName}.${key}`] = {
+            type: this.modules[moduleName].uniformTypes?.[key],
+            value: String(value)
+          };
+        }
+      }
+      return table;
+    }
+  };
+
+  // src/application-utils/load-file.ts
+  var pathPrefix = "";
+  function setPathPrefix(prefix) {
+    pathPrefix = prefix;
+  }
+  async function loadImageBitmap(url, opts) {
+    const image = new Image();
+    image.crossOrigin = opts?.crossOrigin || "anonymous";
+    image.src = url.startsWith("http") ? url : pathPrefix + url;
+    await image.decode();
+    return await createImageBitmap(image);
+  }
+  async function loadImage(url, opts) {
+    return await new Promise((resolve, reject) => {
+      try {
+        const image = new Image();
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new Error(`Could not load image ${url}.`));
+        image.crossOrigin = opts?.crossOrigin || "anonymous";
+        image.src = url.startsWith("http") ? url : pathPrefix + url;
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  // src/async-texture/async-texture.ts
+  var AsyncTexture = class {
+    device;
+    // TODO - should we type these as possibly `null`? It will make usage harder?
+    // @ts-expect-error
+    texture;
+    // @ts-expect-error
+    sampler;
+    // @ts-expect-error
+    view;
+    ready;
+    isReady = false;
+    destroyed = false;
+    resolveReady = () => {
+    };
+    rejectReady = () => {
+    };
+    constructor(device, props) {
+      this.device = device;
+      if (typeof props?.data === "string" && props.dimension === "2d") {
+        props = { ...props, data: loadImageBitmap(props.data) };
+      }
+      this.ready = new Promise((resolve, reject) => {
+        this.resolveReady = () => {
+          this.isReady = true;
+          resolve();
+        };
+        this.rejectReady = reject;
+      });
+      this.initAsync(props);
+    }
+    async initAsync(props) {
+      let resolveReady;
+      let rejectReady;
+      const asyncData = props.data;
+      const data = await awaitAllPromises(asyncData).then(resolveReady, rejectReady);
+      if (this.destroyed) {
+        return;
+      }
+      const syncProps = { ...props, data };
+      this.texture = this.device.createTexture(syncProps);
+      this.sampler = this.texture.sampler;
+      this.view = this.texture.view;
+      this.isReady = true;
+    }
+    destroy() {
+      if (this.texture) {
+        this.texture.destroy();
+        this.texture = null;
+      }
+      this.destroyed = true;
+    }
+    // We could implement resize by replacing the texture
+    // resize(width: number, height: number): boolean {
+    //   throw new Error('Not implemented');
+    //   // return false;
+    // }
+  };
+  async function awaitAllPromises(x) {
+    x = await x;
+    if (Array.isArray(x)) {
+      return x.map(awaitAllPromises);
+    }
+    if (x && typeof x === "object" && x.constructor === Object) {
+      const entries = Object.entries(x).map(([key, value]) => [key, awaitAllPromises(value)]);
+      return Object.fromEntries(entries);
+    }
+    return x;
   }
 
   // src/model/model.ts
@@ -6978,8 +7653,11 @@ void main() {
   var _Model = class {
     device;
     id;
+    // @ts-expect-error assigned in function called from constructor
     source;
+    // @ts-expect-error assigned in function called from constructor
     vs;
+    // @ts-expect-error assigned in function called from constructor
     fs;
     pipelineFactory;
     shaderFactory;
@@ -7019,7 +7697,9 @@ void main() {
     /** The underlying GPU "program". @note May be recreated if parameters change */
     pipeline;
     /** ShaderInputs instance */
+    // @ts-expect-error Assigned in function called by constructor
     shaderInputs;
+    // @ts-expect-error Assigned in function called by constructor
     _uniformStore;
     _attributeInfos = {};
     _gpuGeometry = null;
@@ -7033,7 +7713,7 @@ void main() {
     constructor(device, props) {
       this.props = { ..._Model.defaultProps, ...props };
       props = this.props;
-      this.id = props.id || (0, import_core11.uid)("model");
+      this.id = props.id || uid("model");
       this.device = device;
       Object.assign(this.userData, props.userData);
       const moduleMap = Object.fromEntries(
@@ -7041,11 +7721,14 @@ void main() {
       );
       this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
       const platformInfo = getPlatformInfo(device);
-      const modules = (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || [];
+      const modules = (
+        // @ts-expect-error shaderInputs is assigned in setShaderInputs above.
+        (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || []
+      );
       const isWebGPU = this.device.type === "webgpu";
       if (isWebGPU && this.props.source) {
         this.props.shaderLayout ||= getShaderLayoutFromWGSL(this.props.source);
-        const { source, getUniforms } = this.props.shaderAssembler.assembleShader({
+        const { source, getUniforms } = this.props.shaderAssembler.assembleWGSLShader({
           platformInfo,
           ...this.props,
           modules
@@ -7053,7 +7736,7 @@ void main() {
         this.source = source;
         this._getModuleUniforms = getUniforms;
       } else {
-        const { vs, fs, getUniforms } = this.props.shaderAssembler.assembleShaderPair({
+        const { vs, fs, getUniforms } = this.props.shaderAssembler.assembleGLSLShaderPair({
           platformInfo,
           ...this.props,
           modules
@@ -7147,8 +7830,11 @@ void main() {
       try {
         this._logDrawCallStart();
         this.pipeline = this._updatePipeline();
-        this.pipeline.setBindings(this.bindings, { disableWarnings: this.props.disableWarnings });
-        if (!(0, import_core11.isObjectEmpty)(this.uniforms)) {
+        const syncBindings = this._getBindings();
+        this.pipeline.setBindings(syncBindings, {
+          disableWarnings: this.props.disableWarnings
+        });
+        if (!isObjectEmpty(this.uniforms)) {
           this.pipeline.setUniformsWebGL(this.uniforms);
         }
         const { indexBuffer } = this.vertexArray;
@@ -7228,7 +7914,7 @@ void main() {
      * @param parameters
      */
     setParameters(parameters) {
-      if (!(0, import_core11.deepEqual)(parameters, this.parameters, 2)) {
+      if (!deepEqual(parameters, this.parameters, 2)) {
         this.parameters = parameters;
         this._setPipelineNeedsUpdate("parameters");
       }
@@ -7256,7 +7942,7 @@ void main() {
     /** Set the shader inputs */
     setShaderInputs(shaderInputs) {
       this.shaderInputs = shaderInputs;
-      this._uniformStore = new import_core10.UniformStore(this.shaderInputs.modules);
+      this._uniformStore = new import_core9.UniformStore(this.shaderInputs.modules);
       for (const moduleName of Object.keys(this.shaderInputs.modules)) {
         const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
         this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
@@ -7296,7 +7982,7 @@ void main() {
      */
     setAttributes(buffers, options) {
       if (buffers.indices) {
-        import_core11.log.warn(
+        import_core10.log.warn(
           `Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`
         )();
       }
@@ -7305,7 +7991,7 @@ void main() {
           (layout) => getAttributeNames(layout).includes(bufferName)
         );
         if (!bufferLayout) {
-          import_core11.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
+          import_core10.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
           continue;
         }
         const attributeNames = getAttributeNames(bufferLayout);
@@ -7318,7 +8004,7 @@ void main() {
           }
         }
         if (!set && !(options?.disableWarnings ?? this.props.disableWarnings)) {
-          import_core11.log.warn(
+          import_core10.log.warn(
             `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
           )();
         }
@@ -7339,7 +8025,7 @@ void main() {
         if (attributeInfo) {
           this.vertexArray.setConstantWebGL(attributeInfo.location, value);
         } else if (!(options?.disableWarnings ?? this.props.disableWarnings)) {
-          import_core11.log.warn(
+          import_core10.log.warn(
             `Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`
           )();
         }
@@ -7353,7 +8039,7 @@ void main() {
      * @param uniforms
      */
     setUniforms(uniforms) {
-      if (!(0, import_core11.isObjectEmpty)(uniforms)) {
+      if (!isObjectEmpty(uniforms)) {
         this.pipeline.setUniformsWebGL(uniforms);
         Object.assign(this.uniforms, uniforms);
       }
@@ -7363,21 +8049,39 @@ void main() {
      * @deprecated Updates shader module settings (which results in uniforms being set)
      */
     updateModuleSettings(props) {
-      const { bindings, uniforms } = (0, import_core11.splitUniformsAndBindings)(this._getModuleUniforms(props));
+      const { bindings, uniforms } = splitUniformsAndBindings(this._getModuleUniforms(props));
       Object.assign(this.bindings, bindings);
       Object.assign(this.uniforms, uniforms);
       this.setNeedsRedraw("moduleSettings");
     }
     // Internal methods
+    /** Get texture / texture view from any async textures */
+    _getBindings() {
+      return Object.entries(this.bindings).reduce((acc, [name, binding]) => {
+        if (binding instanceof AsyncTexture) {
+          if (binding.isReady) {
+            acc[name] = binding.texture;
+          }
+        } else {
+          acc[name] = binding;
+        }
+        return acc;
+      }, {});
+    }
     /** Get the timestamp of the latest updated bound GPU memory resource (buffer/texture). */
     _getBindingsUpdateTimestamp() {
       let timestamp = 0;
       for (const binding of Object.values(this.bindings)) {
-        if (binding instanceof import_core9.TextureView) {
+        if (binding instanceof import_core8.TextureView) {
           timestamp = Math.max(timestamp, binding.texture.updateTimestamp);
-        } else if (binding instanceof import_core9.Buffer || binding instanceof import_core9.Texture) {
+        } else if (binding instanceof import_core8.Buffer || binding instanceof import_core8.Texture) {
           timestamp = Math.max(timestamp, binding.updateTimestamp);
-        } else if (!(binding instanceof import_core9.Sampler)) {
+        } else if (binding instanceof AsyncTexture) {
+          timestamp = binding.texture ? Math.max(timestamp, binding.texture.updateTimestamp) : (
+            // The texture will become available in the future
+            Infinity
+          );
+        } else if (!(binding instanceof import_core8.Sampler)) {
           timestamp = Math.max(timestamp, binding.buffer.updateTimestamp);
         }
       }
@@ -7412,7 +8116,7 @@ void main() {
         let prevShaderVs = null;
         let prevShaderFs = null;
         if (this.pipeline) {
-          import_core11.log.log(
+          import_core10.log.log(
             1,
             `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`
           )();
@@ -7442,10 +8146,13 @@ void main() {
           bufferLayout: this.bufferLayout,
           topology: this.topology,
           parameters: this.parameters,
+          // TODO - why set bindings here when we reset them every frame?
+          // Should we expose a BindGroup abstraction?
+          bindings: this._getBindings(),
           vs,
           fs
         });
-        this._attributeInfos = (0, import_core12.getAttributeInfosFromLayouts)(
+        this._attributeInfos = (0, import_core11.getAttributeInfosFromLayouts)(
           this.pipeline.shaderLayout,
           this.bufferLayout
         );
@@ -7460,33 +8167,33 @@ void main() {
     _lastLogTime = 0;
     _logOpen = false;
     _logDrawCallStart() {
-      const logDrawTimeout = import_core11.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
-      if (import_core11.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+      const logDrawTimeout = import_core10.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+      if (import_core10.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
         return;
       }
       this._lastLogTime = Date.now();
       this._logOpen = true;
-      import_core11.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core11.log.level <= 2 })();
+      import_core10.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core10.log.level <= 2 })();
     }
     _logDrawCallEnd() {
       if (this._logOpen) {
         const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
-        import_core11.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+        import_core10.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
         const uniformTable = this.shaderInputs.getDebugTable();
         for (const [name, value] of Object.entries(this.uniforms)) {
           uniformTable[name] = { value };
         }
-        import_core11.log.table(LOG_DRAW_PRIORITY, uniformTable)();
+        import_core10.log.table(LOG_DRAW_PRIORITY, uniformTable)();
         const attributeTable = this._getAttributeDebugTable();
-        import_core11.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
-        import_core11.log.table(LOG_DRAW_PRIORITY, attributeTable)();
-        import_core11.log.groupEnd(LOG_DRAW_PRIORITY)();
+        import_core10.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+        import_core10.log.table(LOG_DRAW_PRIORITY, attributeTable)();
+        import_core10.log.groupEnd(LOG_DRAW_PRIORITY)();
         this._logOpen = false;
       }
     }
     _drawCount = 0;
     _logFramebuffer(renderPass) {
-      const debugFramebuffers = import_core11.log.get("framebuffer");
+      const debugFramebuffers = import_core10.log.get("framebuffer");
       this._drawCount++;
       if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
         return;
@@ -7499,13 +8206,11 @@ void main() {
     _getAttributeDebugTable() {
       const table = {};
       for (const [name, attributeInfo] of Object.entries(this._attributeInfos)) {
+        const values = this.vertexArray.attributes[attributeInfo.location];
         table[attributeInfo.location] = {
           name,
           type: attributeInfo.shaderType,
-          values: this._getBufferOrConstantValues(
-            this.vertexArray.attributes[attributeInfo.location],
-            attributeInfo.bufferDataType
-          )
+          values: values ? this._getBufferOrConstantValues(values, attributeInfo.bufferDataType) : "null"
         };
       }
       if (this.vertexArray.indexBuffer) {
@@ -7521,15 +8226,15 @@ void main() {
     }
     // TODO - fix typing of luma data types
     _getBufferOrConstantValues(attribute, dataType) {
-      const TypedArrayConstructor = (0, import_core12.getTypedArrayFromDataType)(dataType);
-      const typedArray = attribute instanceof import_core9.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+      const TypedArrayConstructor = (0, import_core11.getTypedArrayFromDataType)(dataType);
+      const typedArray = attribute instanceof import_core8.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
       return typedArray.toString();
     }
   };
   var Model = _Model;
   __publicField(Model, "defaultProps", {
-    ...import_core10.RenderPipeline.defaultProps,
-    source: null,
+    ...import_core9.RenderPipeline.defaultProps,
+    source: void 0,
     vs: null,
     fs: null,
     id: "unnamed",
@@ -7579,9 +8284,17 @@ void main() {
   function getAttributeNames(bufferLayout) {
     return bufferLayout.attributes ? bufferLayout.attributes?.map((layout) => layout.attribute) : [bufferLayout.name];
   }
+  function isObjectEmpty(obj) {
+    let isEmpty = true;
+    for (const key in obj) {
+      isEmpty = false;
+      break;
+    }
+    return isEmpty;
+  }
 
   // src/transform/buffer-transform.ts
-  var import_core13 = __toESM(require_core(), 1);
+  var import_core12 = __toESM(require_core(), 1);
   var BufferTransform = class {
     device;
     model;
@@ -7591,7 +8304,9 @@ void main() {
       return device?.info?.type === "webgl";
     }
     constructor(device, props = Model.defaultProps) {
-      (0, import_core13.assert)(BufferTransform.isSupported(device), "BufferTransform not yet implemented on WebGPU");
+      if (!BufferTransform.isSupported(device)) {
+        throw new Error("BufferTransform not yet implemented on WebGPU");
+      }
       this.device = device;
       this.model = new Model(this.device, {
         id: props.id || "buffer-transform-model",
@@ -7601,6 +8316,7 @@ void main() {
       });
       this.transformFeedback = this.device.createTransformFeedback({
         layout: this.model.pipeline.shaderLayout,
+        // @ts-expect-error TODO
         buffers: props.feedbackBuffers
       });
       this.model.setTransformFeedback(this.transformFeedback);
@@ -7632,7 +8348,10 @@ void main() {
     }
     readAsync(varyingName) {
       const result = this.getBuffer(varyingName);
-      if (result instanceof import_core13.Buffer) {
+      if (!result) {
+        throw new Error("BufferTransform#getBuffer");
+      }
+      if (result instanceof import_core12.Buffer) {
         return result.readAsync();
       }
       const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result;
@@ -7715,6 +8434,7 @@ void main() {
         binding = {
           sourceBuffers: {},
           sourceTextures: {},
+          // @ts-expect-error
           targetTexture: null
         };
       }
@@ -7747,10 +8467,9 @@ void main() {
   };
 
   // src/lib/clip-space.ts
-  var import_core15 = __toESM(require_core(), 1);
+  var import_core13 = __toESM(require_core(), 1);
 
   // src/geometry/geometry.ts
-  var import_core14 = __toESM(require_core(), 1);
   var Geometry = class {
     id;
     /** Determines how vertices are read from the 'vertex' attributes */
@@ -7761,7 +8480,7 @@ void main() {
     userData = {};
     constructor(props) {
       const { attributes = {}, indices = null, vertexCount = null } = props;
-      this.id = props.id || (0, import_core14.uid)("geometry");
+      this.id = props.id || uid("geometry");
       this.topology = props.topology;
       if (indices) {
         this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
@@ -7769,15 +8488,18 @@ void main() {
       this.attributes = {};
       for (const [attributeName, attributeValue] of Object.entries(attributes)) {
         const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
-        (0, import_core14.assert)(
-          ArrayBuffer.isView(attribute.value),
-          `${this._print(attributeName)}: must be typed array or object with value as typed array`
-        );
+        if (!ArrayBuffer.isView(attribute.value)) {
+          throw new Error(
+            `${this._print(attributeName)}: must be typed array or object with value as typed array`
+          );
+        }
         if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) {
           attribute.size = 3;
         }
         if (attributeName === "indices") {
-          (0, import_core14.assert)(!this.indices);
+          if (this.indices) {
+            throw new Error("Multiple indices detected");
+          }
           this.indices = attribute;
         } else {
           this.attributes[attributeName] = attribute;
@@ -7824,17 +8546,16 @@ void main() {
       let vertexCount = Infinity;
       for (const attribute of Object.values(attributes)) {
         const { value, size, constant } = attribute;
-        if (!constant && value && size >= 1) {
+        if (!constant && value && size !== void 0 && size >= 1) {
           vertexCount = Math.min(vertexCount, value.length / size);
         }
       }
-      (0, import_core14.assert)(Number.isFinite(vertexCount));
       return vertexCount;
     }
   };
 
   // src/lib/clip-space.ts
-  var CLIPSPACE_VERTEX_SHADER = import_core15.glsl`\
+  var CLIPSPACE_VERTEX_SHADER = import_core13.glsl`\
 #version 300 es
 in vec2 aClipSpacePosition;
 in vec2 aTexCoord;
@@ -7873,7 +8594,6 @@ void main(void) {
   };
 
   // src/scenegraph/scenegraph-node.ts
-  var import_core16 = __toESM(require_core(), 1);
   var ScenegraphNode = class {
     id;
     matrix = new Matrix4();
@@ -7885,7 +8605,7 @@ void main(void) {
     props = {};
     constructor(props = {}) {
       const { id } = props;
-      this.id = id || (0, import_core16.uid)(this.constructor.name);
+      this.id = id || uid(this.constructor.name);
       this._setScenegraphNodeProps(props);
     }
     getBounds() {
@@ -7905,17 +8625,14 @@ void main(void) {
       return `{type: ScenegraphNode, id: ${this.id})}`;
     }
     setPosition(position) {
-      (0, import_core16.assert)(position.length === 3, "setPosition requires vector argument");
       this.position = position;
       return this;
     }
     setRotation(rotation) {
-      (0, import_core16.assert)(rotation.length === 3, "setRotation requires vector argument");
       this.rotation = rotation;
       return this;
     }
     setScale(scale2) {
-      (0, import_core16.assert)(scale2.length === 3, "setScale requires vector argument");
       this.scale = scale2;
       return this;
     }
@@ -7967,7 +8684,6 @@ void main(void) {
       return this;
     }
     getCoordinateUniforms(viewMatrix, modelMatrix) {
-      (0, import_core16.assert)(viewMatrix);
       modelMatrix = modelMatrix || this.matrix;
       const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
       const worldInverse = worldMatrix.invert();
@@ -8004,9 +8720,6 @@ void main(void) {
       }
       */
     _setScenegraphNodeProps(props) {
-      if ("display" in props) {
-        this.display = props.display;
-      }
       if ("position" in props) {
         this.setPosition(props.position);
       }
@@ -8024,13 +8737,13 @@ void main(void) {
   };
 
   // src/scenegraph/group-node.ts
-  var import_core19 = __toESM(require_core(), 1);
+  var import_core16 = __toESM(require_core(), 1);
   var GroupNode = class extends ScenegraphNode {
     children;
     constructor(props = {}) {
       props = Array.isArray(props) ? { children: props } : props;
       const { children = [] } = props;
-      import_core19.log.assert(
+      import_core16.log.assert(
         children.every((child) => child instanceof ScenegraphNode),
         "every child must an instance of ScenegraphNode"
       );
@@ -8121,9 +8834,6 @@ void main(void) {
       this.bounds = props.bounds || null;
       this.setProps(props);
     }
-    getBounds() {
-      return this.bounds;
-    }
     destroy() {
       if (this.model) {
         this.model.destroy();
@@ -8132,17 +8842,16 @@ void main(void) {
       this.managedResources.forEach((resource) => resource.destroy());
       this.managedResources = [];
     }
+    getBounds() {
+      return this.bounds;
+    }
     // Expose model methods
     draw(renderPass) {
       return this.model.draw(renderPass);
     }
   };
 
-  // src/geometries/cone-geometry.ts
-  var import_core21 = __toESM(require_core(), 1);
-
   // src/geometries/truncated-cone-geometry.ts
-  var import_core20 = __toESM(require_core(), 1);
   var INDEX_OFFSETS = {
     x: [2, 0, 1],
     y: [0, 1, 2],
@@ -8150,7 +8859,7 @@ void main(void) {
   };
   var TruncatedConeGeometry = class extends Geometry {
     constructor(props = {}) {
-      const { id = (0, import_core20.uid)("truncated-code-geometry") } = props;
+      const { id = uid("truncated-code-geometry") } = props;
       const { indices, attributes } = tesselateTruncatedCone(props);
       super({
         ...props,
@@ -8254,7 +8963,7 @@ void main(void) {
   // src/geometries/cone-geometry.ts
   var ConeGeometry = class extends TruncatedConeGeometry {
     constructor(props = {}) {
-      const { id = (0, import_core21.uid)("cone-geometry"), radius = 1, cap = true } = props;
+      const { id = uid("cone-geometry"), radius = 1, cap = true } = props;
       super({
         ...props,
         id,
@@ -8267,10 +8976,9 @@ void main(void) {
   };
 
   // src/geometries/cube-geometry.ts
-  var import_core22 = __toESM(require_core(), 1);
   var CubeGeometry = class extends Geometry {
     constructor(props = {}) {
-      const { id = (0, import_core22.uid)("cube-geometry"), indices = true } = props;
+      const { id = uid("cube-geometry"), indices = true } = props;
       super(
         indices ? {
           ...props,
@@ -8879,10 +9587,9 @@ void main(void) {
   };
 
   // src/geometries/cylinder-geometry.ts
-  var import_core23 = __toESM(require_core(), 1);
   var CylinderGeometry = class extends TruncatedConeGeometry {
     constructor(props = {}) {
-      const { id = (0, import_core23.uid)("cylinder-geometry"), radius = 1 } = props;
+      const { id = uid("cylinder-geometry"), radius = 1 } = props;
       super({
         ...props,
         id,
@@ -8893,12 +9600,11 @@ void main(void) {
   };
 
   // src/geometries/ico-sphere-geometry.ts
-  var import_core24 = __toESM(require_core(), 1);
   var ICO_POSITIONS = [-1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, 0];
   var ICO_INDICES = [3, 4, 5, 3, 5, 1, 3, 1, 0, 3, 0, 4, 4, 0, 2, 4, 2, 5, 2, 0, 1, 5, 2, 1];
   var IcoSphereGeometry = class extends Geometry {
     constructor(props = {}) {
-      const { id = (0, import_core24.uid)("ico-sphere-geometry") } = props;
+      const { id = uid("ico-sphere-geometry") } = props;
       const { indices, attributes } = tesselateIcosaHedron(props);
       super({
         ...props,
@@ -9039,9 +9745,6 @@ void main(void) {
     };
   }
 
-  // src/geometries/plane-geometry.ts
-  var import_core26 = __toESM(require_core(), 1);
-
   // src/geometry/geometry-utils.ts
   function unpackIndexedGeometry(geometry) {
     const { indices, attributes } = geometry;
@@ -9073,7 +9776,7 @@ void main(void) {
   // src/geometries/plane-geometry.ts
   var PlaneGeometry = class extends Geometry {
     constructor(props = {}) {
-      const { id = (0, import_core26.uid)("plane-geometry") } = props;
+      const { id = uid("plane-geometry") } = props;
       const { indices, attributes } = tesselatePlane(props);
       super({
         ...props,
@@ -9163,10 +9866,9 @@ void main(void) {
   }
 
   // src/geometries/sphere-geometry.ts
-  var import_core27 = __toESM(require_core(), 1);
   var SphereGeometry = class extends Geometry {
     constructor(props = {}) {
-      const { id = (0, import_core27.uid)("sphere-geometry") } = props;
+      const { id = uid("sphere-geometry") } = props;
       const { indices, attributes } = tesselateSphere(props);
       super({
         ...props,
@@ -9241,10 +9943,24 @@ void main(void) {
     };
   }
 
+  // src/application-utils/random.ts
+  function makeRandomGenerator() {
+    let s = 1;
+    let c = 1;
+    return () => {
+      s = Math.sin(c * 17.23);
+      c = Math.cos(s * 27.92);
+      return fract(Math.abs(s * c) * 1432.71);
+    };
+  }
+  function fract(n) {
+    return n - Math.floor(n);
+  }
+
   // src/computation.ts
-  var import_core28 = __toESM(require_core(), 1);
-  var import_core29 = __toESM(require_core(), 1);
-  var import_core30 = __toESM(require_core(), 1);
+  var import_core18 = __toESM(require_core(), 1);
+  var import_core19 = __toESM(require_core(), 1);
+  var import_core20 = __toESM(require_core(), 1);
   var LOG_DRAW_PRIORITY2 = 2;
   var LOG_DRAW_TIMEOUT2 = 1e4;
   var _Computation = class {
@@ -9255,13 +9971,16 @@ void main(void) {
     userData = {};
     /** Bindings (textures, samplers, uniform buffers) */
     bindings = {};
-    /** The underlying GPU "program". @note May be recreated if parameters change */
+    /** The underlying GPU pipeline. */
     pipeline;
+    /** Assembled compute shader source */
+    source;
     /** the underlying compiled compute shader */
+    // @ts-ignore Set in function called from constructor
     shader;
-    source;
     /** ShaderInputs instance */
     shaderInputs;
+    // @ts-ignore Set in function called from constructor
     _uniformStore;
     _pipelineNeedsUpdate = "newly created";
     _getModuleUniforms;
@@ -9273,19 +9992,20 @@ void main(void) {
       }
       this.props = { ..._Computation.defaultProps, ...props };
       props = this.props;
-      this.id = props.id || (0, import_core29.uid)("model");
+      this.id = props.id || uid("model");
       this.device = device;
       Object.assign(this.userData, props.userData);
       const moduleMap = Object.fromEntries(
         this.props.modules?.map((module) => [module.name, module]) || []
       );
-      this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+      this.shaderInputs = props.shaderInputs || new ShaderInputs(moduleMap);
+      this.setShaderInputs(this.shaderInputs);
       this.props.shaderLayout ||= getShaderLayoutFromWGSL(this.props.source);
       const platformInfo = getPlatformInfo2(device);
       const modules = (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || [];
       this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
       this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device);
-      const { source, getUniforms } = this.props.shaderAssembler.assembleShader({
+      const { source, getUniforms } = this.props.shaderAssembler.assembleWGSLShader({
         platformInfo,
         ...this.props,
         modules
@@ -9338,7 +10058,7 @@ void main(void) {
     }
     setShaderInputs(shaderInputs) {
       this.shaderInputs = shaderInputs;
-      this._uniformStore = new import_core28.UniformStore(this.shaderInputs.modules);
+      this._uniformStore = new import_core18.UniformStore(this.shaderInputs.modules);
       for (const moduleName of Object.keys(this.shaderInputs.modules)) {
         const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
         this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
@@ -9351,7 +10071,7 @@ void main(void) {
       const uniforms = this._getModuleUniforms(props);
       const keys = Object.keys(uniforms).filter((k) => {
         const uniform = uniforms[k];
-        return !(0, import_core29.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+        return !isNumericArray(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
       });
       const bindings = {};
       for (const k of keys) {
@@ -9375,7 +10095,7 @@ void main(void) {
       if (this._pipelineNeedsUpdate) {
         let prevShader = null;
         if (this.pipeline) {
-          import_core29.log.log(
+          import_core19.log.log(
             1,
             `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`
           )();
@@ -9402,33 +10122,33 @@ void main(void) {
     _lastLogTime = 0;
     _logOpen = false;
     _logDrawCallStart() {
-      const logDrawTimeout = import_core29.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT2;
-      if (import_core29.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+      const logDrawTimeout = import_core19.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT2;
+      if (import_core19.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
         return;
       }
       this._lastLogTime = Date.now();
       this._logOpen = true;
-      import_core29.log.group(LOG_DRAW_PRIORITY2, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core29.log.level <= 2 })();
+      import_core19.log.group(LOG_DRAW_PRIORITY2, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core19.log.level <= 2 })();
     }
     _logDrawCallEnd() {
       if (this._logOpen) {
         const uniformTable = this.shaderInputs.getDebugTable();
-        import_core29.log.table(LOG_DRAW_PRIORITY2, uniformTable)();
-        import_core29.log.groupEnd(LOG_DRAW_PRIORITY2)();
+        import_core19.log.table(LOG_DRAW_PRIORITY2, uniformTable)();
+        import_core19.log.groupEnd(LOG_DRAW_PRIORITY2)();
         this._logOpen = false;
       }
     }
     _drawCount = 0;
     // TODO - fix typing of luma data types
     _getBufferOrConstantValues(attribute, dataType) {
-      const TypedArrayConstructor = (0, import_core30.getTypedArrayFromDataType)(dataType);
-      const typedArray = attribute instanceof import_core28.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+      const TypedArrayConstructor = (0, import_core20.getTypedArrayFromDataType)(dataType);
+      const typedArray = attribute instanceof import_core18.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
       return typedArray.toString();
     }
   };
   var Computation = _Computation;
   __publicField(Computation, "defaultProps", {
-    ...import_core28.ComputePipeline.defaultProps,
+    ...import_core18.ComputePipeline.defaultProps,
     id: "unnamed",
     handle: void 0,
     userData: {},