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

package/dist/index.cjs

@@ -27,6 +27,7 @@ var dist_exports = {};
 __export(dist_exports, {
   AnimationLoop: () => AnimationLoop,
   AnimationLoopTemplate: () => AnimationLoopTemplate,
+  AsyncTexture: () => AsyncTexture,
   BufferTransform: () => BufferTransform,
   ClipSpace: () => ClipSpace,
   Computation: () => Computation,
@@ -49,7 +50,13 @@ __export(dist_exports, {
   Timeline: () => Timeline,
   TruncatedConeGeometry: () => TruncatedConeGeometry,
   _ShaderInputs: () => ShaderInputs,
-  makeAnimationLoop: () => makeAnimationLoop
+  cancelAnimationFrame: () => cancelAnimationFrame,
+  loadImage: () => loadImage,
+  loadImageBitmap: () => loadImageBitmap,
+  makeAnimationLoop: () => makeAnimationLoop,
+  makeRandomGenerator: () => makeRandomGenerator,
+  requestAnimationFrame: () => requestAnimationFrame,
+  setPathPrefix: () => setPathPrefix
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -226,7 +233,16 @@ var AnimationLoopTemplate = class {
 
 // dist/animation-loop/animation-loop.js
 var import_core = require("@luma.gl/core");
-var import_core2 = require("@luma.gl/core");
+
+// dist/animation-loop/request-animation-frame.js
+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);
+}
+
+// dist/animation-loop/animation-loop.js
 var import_stats = require("@probe.gl/stats");
 var statIdCounter = 0;
 var DEFAULT_ANIMATION_LOOP_PROPS = {
@@ -426,13 +442,13 @@ var AnimationLoop = class {
     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() {
@@ -445,12 +461,13 @@ var AnimationLoop = class {
   // Called on each frame, can be overridden to call onRender multiple times
   // to support e.g. stereoscopic rendering
   _renderFrame(animationProps) {
+    var _a;
     if (this.display) {
       this.display._renderFrame(animationProps);
       return;
     }
     this.props.onRender(this._getAnimationProps());
-    this.device.submit();
+    (_a = this.device) == null ? void 0 : _a.submit();
   }
   _clearNeedsRedraw() {
     this.needsRedraw = false;
@@ -462,13 +479,14 @@ var AnimationLoop = class {
   // Initialize the  object that will be passed to app callbacks
   _initializeAnimationProps() {
     var _a, _b;
-    if (!this.device) {
+    const canvas2 = (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.canvas;
+    if (!this.device || !canvas2) {
       throw new Error("loop");
     }
     this.animationProps = {
       animationLoop: this,
       device: this.device,
-      canvas: (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.canvas,
+      canvas: canvas2,
       timeline: this.timeline,
       // Initial values
       useDevicePixels: this.props.useDevicePixels,
@@ -612,10 +630,10 @@ var AnimationLoop = class {
 };
 
 // dist/animation-loop/make-animation-loop.js
-var import_core3 = require("@luma.gl/core");
+var import_core2 = require("@luma.gl/core");
 function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
   let renderLoop = null;
-  const device = (props == null ? void 0 : props.device) || import_core3.luma.createDevice();
+  const device = (props == null ? void 0 : props.device) || import_core2.luma.createDevice();
   const animationLoop = new AnimationLoop({
     ...props,
     device,
@@ -633,14 +651,24 @@ function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
 }
 
 // dist/model/model.js
+var import_core7 = require("@luma.gl/core");
 var import_core8 = require("@luma.gl/core");
 var import_core9 = require("@luma.gl/core");
 var import_core10 = require("@luma.gl/core");
-var import_core11 = require("@luma.gl/core");
 var import_shadertools2 = require("@luma.gl/shadertools");
 
 // dist/geometry/gpu-geometry.js
-var import_core4 = require("@luma.gl/core");
+var import_core3 = require("@luma.gl/core");
+
+// dist/utils/uid.js
+var uidCounters = {};
+function uid(id = "id") {
+  uidCounters[id] = uidCounters[id] || 1;
+  const count = uidCounters[id]++;
+  return `${id}-${count}`;
+}
+
+// dist/geometry/gpu-geometry.js
 var GPUGeometry = class {
   id;
   userData = {};
@@ -651,14 +679,16 @@ var GPUGeometry = class {
   indices;
   attributes;
   constructor(props) {
-    this.id = props.id || (0, import_core4.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_core4.assert)(this.indices.usage === import_core4.Buffer.INDEX);
+      if (!(this.indices.usage & import_core3.Buffer.INDEX)) {
+        throw new Error("Index buffer must have INDEX usage");
+      }
     }
   }
   destroy() {
@@ -675,7 +705,7 @@ var GPUGeometry = class {
     return this.attributes;
   }
   getIndexes() {
-    return this.indices;
+    return this.indices || null;
   }
   _calculateVertexCount(positions) {
     const vertexCount = positions.byteLength / 12;
@@ -701,7 +731,7 @@ function getIndexBufferFromGeometry(device, geometry) {
     return void 0;
   }
   const data = geometry.indices.value;
-  return device.createBuffer({ usage: import_core4.Buffer.INDEX, data });
+  return device.createBuffer({ usage: import_core3.Buffer.INDEX, data });
 }
 function getAttributeBuffersFromGeometry(device, geometry) {
   const bufferLayout = [];
@@ -722,123 +752,40 @@ function getAttributeBuffersFromGeometry(device, geometry) {
         name = "colors";
         break;
     }
-    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) });
+    if (attribute) {
+      attributes[name] = device.createBuffer({
+        data: attribute.value,
+        id: `${attributeName}-buffer`
+      });
+      const { value, size, normalized } = attribute;
+      bufferLayout.push({ name, format: (0, import_core3.getVertexFormatFromAttribute)(value, size, normalized) });
+    }
   }
   const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
   return { attributes, bufferLayout, vertexCount };
 }
 
-// dist/shader-inputs.js
-var import_core5 = require("@luma.gl/core");
-var import_shadertools = require("@luma.gl/shadertools");
-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 = (0, import_shadertools._resolveModules)(Object.values(modules));
-    import_core5.log.log(1, "Creating ShaderInputs with modules", allModules.map((m) => m.name))();
-    this.modules = modules;
-    this.moduleUniforms = {};
-    this.moduleBindings = {};
-    for (const [name, module2] of Object.entries(modules)) {
-      const moduleName = name;
-      this.moduleUniforms[moduleName] = module2.defaultUniforms || {};
-      this.moduleBindings[moduleName] = {};
-    }
-  }
-  /** Destroy */
-  destroy() {
-  }
-  /**
-   * Set module props
-   */
-  setProps(props) {
-    var _a;
-    for (const name of Object.keys(props)) {
-      const moduleName = name;
-      const moduleProps = props[moduleName];
-      const module2 = this.modules[moduleName];
-      if (!module2) {
-        import_core5.log.warn(`Module ${name} not found`)();
-        continue;
-      }
-      const oldUniforms = this.moduleUniforms[moduleName];
-      const uniforms = ((_a = module2.getUniforms) == null ? void 0 : _a.call(module2, 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() {
-    var _a;
-    const table = {};
-    for (const [moduleName, module2] of Object.entries(this.moduleUniforms)) {
-      for (const [key, value] of Object.entries(module2)) {
-        table[`${moduleName}.${key}`] = {
-          type: (_a = this.modules[moduleName].uniformTypes) == null ? void 0 : _a[key],
-          value: String(value)
-        };
-      }
-    }
-    return table;
-  }
-};
-
 // dist/lib/pipeline-factory.js
-var import_core6 = require("@luma.gl/core");
+var import_core4 = require("@luma.gl/core");
 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_core6.RenderPipeline.defaultProps, ...props };
+    const allProps = { ...import_core4.RenderPipeline.defaultProps, ...props };
     const hash = this._hashRenderPipeline(allProps);
     if (!this._renderPipelineCache[hash]) {
       const pipeline = this.device.createRenderPipeline({
@@ -852,7 +799,7 @@ var _PipelineFactory = class {
     return this._renderPipelineCache[hash].pipeline;
   }
   createComputePipeline(props) {
-    const allProps = { ...import_core6.ComputePipeline.defaultProps, ...props };
+    const allProps = { ...import_core4.ComputePipeline.defaultProps, ...props };
     const hash = this._hashComputePipeline(allProps);
     if (!this._computePipelineCache[hash]) {
       const pipeline = this.device.createComputePipeline({
@@ -867,11 +814,13 @@ var _PipelineFactory = class {
   }
   release(pipeline) {
     const hash = pipeline.hash;
-    const cache = pipeline instanceof import_core6.ComputePipeline ? this._computePipelineCache : this._renderPipelineCache;
+    const cache = pipeline instanceof import_core4.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
@@ -881,7 +830,7 @@ var _PipelineFactory = class {
   }
   /** 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));
@@ -901,21 +850,23 @@ var _PipelineFactory = class {
   }
 };
 var PipelineFactory = _PipelineFactory;
-__publicField(PipelineFactory, "defaultProps", { ...import_core6.RenderPipeline.defaultProps });
+__publicField(PipelineFactory, "defaultProps", { ...import_core4.RenderPipeline.defaultProps });
 
 // dist/lib/shader-factory.js
-var import_core7 = require("@luma.gl/core");
+var import_core5 = require("@luma.gl/core");
 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) {
@@ -938,8 +889,10 @@ var _ShaderFactory = class {
     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();
+        }
       }
     }
   }
@@ -949,7 +902,7 @@ var _ShaderFactory = class {
   }
 };
 var ShaderFactory = _ShaderFactory;
-__publicField(ShaderFactory, "defaultProps", { ...import_core7.Shader.defaultProps });
+__publicField(ShaderFactory, "defaultProps", { ...import_core5.Shader.defaultProps });
 
 // dist/debug/debug-shader-layout.js
 function getDebugTableForShaderLayout(layout, name) {
@@ -996,15 +949,259 @@ function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgb
     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 == null ? void 0 : 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 == null ? void 0 : ctx.putImageData(imageData, 0, 0);
+  }
+}
+
+// dist/utils/deep-equal.js
+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;
+}
+
+// dist/model/split-uniforms-and-bindings.js
+var import_types = require("@math.gl/types");
+function isUniformValue(value) {
+  return (0, import_types.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;
+}
+
+// dist/shader-inputs.js
+var import_core6 = require("@luma.gl/core");
+var import_shadertools = require("@luma.gl/shadertools");
+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 = (0, import_shadertools._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, module2] of Object.entries(modules)) {
+      const moduleName = name;
+      this.moduleUniforms[moduleName] = module2.defaultUniforms || {};
+      this.moduleBindings[moduleName] = {};
+    }
+  }
+  /** Destroy */
+  destroy() {
+  }
+  /**
+   * Set module props
+   */
+  setProps(props) {
+    var _a;
+    for (const name of Object.keys(props)) {
+      const moduleName = name;
+      const moduleProps = props[moduleName] || {};
+      const module2 = this.modules[moduleName];
+      if (!module2) {
+        import_core6.log.warn(`Module ${name} not found`)();
+        continue;
+      }
+      const oldUniforms = this.moduleUniforms[moduleName];
+      const uniforms = ((_a = module2.getUniforms) == null ? void 0 : _a.call(module2, 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() {
+    var _a;
+    const table = {};
+    for (const [moduleName, module2] of Object.entries(this.moduleUniforms)) {
+      for (const [key, value] of Object.entries(module2)) {
+        table[`${moduleName}.${key}`] = {
+          type: (_a = this.modules[moduleName].uniformTypes) == null ? void 0 : _a[key],
+          value: String(value)
+        };
+      }
+    }
+    return table;
+  }
+};
+
+// dist/application-utils/load-file.js
+var pathPrefix = "";
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+async function loadImageBitmap(url, opts) {
+  const image = new Image();
+  image.crossOrigin = (opts == null ? void 0 : 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 == null ? void 0 : opts.crossOrigin) || "anonymous";
+      image.src = url.startsWith("http") ? url : pathPrefix + url;
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+// dist/async-texture/async-texture.js
+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 == null ? void 0 : 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;
+  }
+};
+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;
 }
 
 // dist/model/model.js
@@ -1013,8 +1210,11 @@ var LOG_DRAW_TIMEOUT = 1e4;
 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;
@@ -1054,7 +1254,9 @@ var _Model = class {
   /** 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;
@@ -1069,17 +1271,20 @@ var _Model = class {
     var _a, _b, _c;
     this.props = { ..._Model.defaultProps, ...props };
     props = this.props;
-    this.id = props.id || (0, import_core10.uid)("model");
+    this.id = props.id || uid("model");
     this.device = device;
     Object.assign(this.userData, props.userData);
     const moduleMap = Object.fromEntries(((_a = this.props.modules) == null ? void 0 : _a.map((module2) => [module2.name, module2])) || []);
     this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
     const platformInfo = getPlatformInfo(device);
-    const modules = (((_b = this.props.modules) == null ? void 0 : _b.length) > 0 ? this.props.modules : (_c = this.shaderInputs) == null ? void 0 : _c.getModules()) || [];
+    const modules = (
+      // @ts-expect-error shaderInputs is assigned in setShaderInputs above.
+      (((_b = this.props.modules) == null ? void 0 : _b.length) > 0 ? this.props.modules : (_c = this.shaderInputs) == null ? void 0 : _c.getModules()) || []
+    );
     const isWebGPU = this.device.type === "webgpu";
     if (isWebGPU && this.props.source) {
       this.props.shaderLayout ||= (0, import_shadertools2.getShaderLayoutFromWGSL)(this.props.source);
-      const { source, getUniforms } = this.props.shaderAssembler.assembleShader({
+      const { source, getUniforms } = this.props.shaderAssembler.assembleWGSLShader({
         platformInfo,
         ...this.props,
         modules
@@ -1087,7 +1292,7 @@ var _Model = class {
       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
@@ -1113,7 +1318,7 @@ var _Model = class {
     if (this._gpuGeometry) {
       this._setGeometryAttributes(this._gpuGeometry);
     }
-    if (props.isInstanced) {
+    if ("isInstanced" in props) {
       this.isInstanced = props.isInstanced;
     }
     if (props.instanceCount) {
@@ -1182,8 +1387,11 @@ var _Model = class {
     try {
       this._logDrawCallStart();
       this.pipeline = this._updatePipeline();
-      this.pipeline.setBindings(this.bindings, { disableWarnings: this.props.disableWarnings });
-      if (!(0, import_core10.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;
@@ -1264,7 +1472,7 @@ var _Model = class {
    * @param parameters
    */
   setParameters(parameters) {
-    if (!(0, import_core10.deepEqual)(parameters, this.parameters, 2)) {
+    if (!deepEqual(parameters, this.parameters, 2)) {
       this.parameters = parameters;
       this._setPipelineNeedsUpdate("parameters");
     }
@@ -1292,7 +1500,7 @@ var _Model = class {
   /** Set the shader inputs */
   setShaderInputs(shaderInputs) {
     this.shaderInputs = shaderInputs;
-    this._uniformStore = new import_core9.UniformStore(this.shaderInputs.modules);
+    this._uniformStore = new import_core8.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;
@@ -1332,12 +1540,12 @@ var _Model = class {
    */
   setAttributes(buffers, options) {
     if (buffers.indices) {
-      import_core10.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
+      import_core9.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
     }
     for (const [bufferName, buffer] of Object.entries(buffers)) {
       const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName));
       if (!bufferLayout) {
-        import_core10.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
+        import_core9.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
         continue;
       }
       const attributeNames = getAttributeNames(bufferLayout);
@@ -1350,7 +1558,7 @@ var _Model = class {
         }
       }
       if (!set && !((options == null ? void 0 : options.disableWarnings) ?? this.props.disableWarnings)) {
-        import_core10.log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
+        import_core9.log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
       }
     }
     this.setNeedsRedraw("attributes");
@@ -1369,7 +1577,7 @@ var _Model = class {
       if (attributeInfo) {
         this.vertexArray.setConstantWebGL(attributeInfo.location, value);
       } else if (!((options == null ? void 0 : options.disableWarnings) ?? this.props.disableWarnings)) {
-        import_core10.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
+        import_core9.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
       }
     }
     this.setNeedsRedraw("constants");
@@ -1381,7 +1589,7 @@ var _Model = class {
    * @param uniforms
    */
   setUniforms(uniforms) {
-    if (!(0, import_core10.isObjectEmpty)(uniforms)) {
+    if (!isObjectEmpty(uniforms)) {
       this.pipeline.setUniformsWebGL(uniforms);
       Object.assign(this.uniforms, uniforms);
     }
@@ -1391,21 +1599,39 @@ var _Model = class {
    * @deprecated Updates shader module settings (which results in uniforms being set)
    */
   updateModuleSettings(props) {
-    const { bindings, uniforms } = (0, import_core10.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_core8.TextureView) {
+      if (binding instanceof import_core7.TextureView) {
         timestamp = Math.max(timestamp, binding.texture.updateTimestamp);
-      } else if (binding instanceof import_core8.Buffer || binding instanceof import_core8.Texture) {
+      } else if (binding instanceof import_core7.Buffer || binding instanceof import_core7.Texture) {
         timestamp = Math.max(timestamp, binding.updateTimestamp);
-      } else if (!(binding instanceof import_core8.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_core7.Sampler)) {
         timestamp = Math.max(timestamp, binding.buffer.updateTimestamp);
       }
     }
@@ -1440,7 +1666,7 @@ var _Model = class {
       let prevShaderVs = null;
       let prevShaderFs = null;
       if (this.pipeline) {
-        import_core10.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+        import_core9.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
         prevShaderVs = this.pipeline.vs;
         prevShaderFs = this.pipeline.fs;
       }
@@ -1467,10 +1693,13 @@ var _Model = class {
         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_core11.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
+      this._attributeInfos = (0, import_core10.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
       if (prevShaderVs)
         this.shaderFactory.release(prevShaderVs);
       if (prevShaderFs)
@@ -1482,33 +1711,33 @@ var _Model = class {
   _lastLogTime = 0;
   _logOpen = false;
   _logDrawCallStart() {
-    const logDrawTimeout = import_core10.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
-    if (import_core10.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+    const logDrawTimeout = import_core9.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+    if (import_core9.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
       return;
     }
     this._lastLogTime = Date.now();
     this._logOpen = true;
-    import_core10.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core10.log.level <= 2 })();
+    import_core9.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core9.log.level <= 2 })();
   }
   _logDrawCallEnd() {
     if (this._logOpen) {
       const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
-      import_core10.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
       const uniformTable = this.shaderInputs.getDebugTable();
       for (const [name, value] of Object.entries(this.uniforms)) {
         uniformTable[name] = { value };
       }
-      import_core10.log.table(LOG_DRAW_PRIORITY, uniformTable)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, uniformTable)();
       const attributeTable = this._getAttributeDebugTable();
-      import_core10.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
-      import_core10.log.table(LOG_DRAW_PRIORITY, attributeTable)();
-      import_core10.log.groupEnd(LOG_DRAW_PRIORITY)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, attributeTable)();
+      import_core9.log.groupEnd(LOG_DRAW_PRIORITY)();
       this._logOpen = false;
     }
   }
   _drawCount = 0;
   _logFramebuffer(renderPass) {
-    const debugFramebuffers = import_core10.log.get("framebuffer");
+    const debugFramebuffers = import_core9.log.get("framebuffer");
     this._drawCount++;
     if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
       return;
@@ -1521,10 +1750,11 @@ var _Model = class {
   _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) {
@@ -1540,15 +1770,15 @@ var _Model = class {
   }
   // TODO - fix typing of luma data types
   _getBufferOrConstantValues(attribute, dataType) {
-    const TypedArrayConstructor = (0, import_core11.getTypedArrayFromDataType)(dataType);
-    const typedArray = attribute instanceof import_core8.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+    const TypedArrayConstructor = (0, import_core10.getTypedArrayFromDataType)(dataType);
+    const typedArray = attribute instanceof import_core7.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
     return typedArray.toString();
   }
 };
 var Model = _Model;
 __publicField(Model, "defaultProps", {
-  ...import_core9.RenderPipeline.defaultProps,
-  source: null,
+  ...import_core8.RenderPipeline.defaultProps,
+  source: void 0,
   vs: null,
   fs: null,
   id: "unnamed",
@@ -1599,9 +1829,17 @@ function getAttributeNames(bufferLayout) {
   var _a;
   return bufferLayout.attributes ? (_a = bufferLayout.attributes) == null ? void 0 : _a.map((layout) => layout.attribute) : [bufferLayout.name];
 }
+function isObjectEmpty(obj) {
+  let isEmpty = true;
+  for (const key in obj) {
+    isEmpty = false;
+    break;
+  }
+  return isEmpty;
+}
 
 // dist/transform/buffer-transform.js
-var import_core12 = require("@luma.gl/core");
+var import_core11 = require("@luma.gl/core");
 var import_shadertools3 = require("@luma.gl/shadertools");
 var BufferTransform = class {
   device;
@@ -1613,7 +1851,9 @@ var BufferTransform = class {
     return ((_a = device == null ? void 0 : device.info) == null ? void 0 : _a.type) === "webgl";
   }
   constructor(device, props = Model.defaultProps) {
-    (0, import_core12.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",
@@ -1623,6 +1863,7 @@ var BufferTransform = class {
     });
     this.transformFeedback = this.device.createTransformFeedback({
       layout: this.model.pipeline.shaderLayout,
+      // @ts-expect-error TODO
       buffers: props.feedbackBuffers
     });
     this.model.setTransformFeedback(this.transformFeedback);
@@ -1654,7 +1895,10 @@ var BufferTransform = class {
   }
   readAsync(varyingName) {
     const result = this.getBuffer(varyingName);
-    if (result instanceof import_core12.Buffer) {
+    if (!result) {
+      throw new Error("BufferTransform#getBuffer");
+    }
+    if (result instanceof import_core11.Buffer) {
       return result.readAsync();
     }
     const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result;
@@ -1738,6 +1982,7 @@ var TextureTransform = class {
       binding = {
         sourceBuffers: {},
         sourceTextures: {},
+        // @ts-expect-error
         targetTexture: null
       };
     }
@@ -1770,10 +2015,9 @@ var TextureTransform = class {
 };
 
 // dist/lib/clip-space.js
-var import_core14 = require("@luma.gl/core");
+var import_core12 = require("@luma.gl/core");
 
 // dist/geometry/geometry.js
-var import_core13 = require("@luma.gl/core");
 var Geometry = class {
   id;
   /** Determines how vertices are read from the 'vertex' attributes */
@@ -1784,7 +2028,7 @@ var Geometry = class {
   userData = {};
   constructor(props) {
     const { attributes = {}, indices = null, vertexCount = null } = props;
-    this.id = props.id || (0, import_core13.uid)("geometry");
+    this.id = props.id || uid("geometry");
     this.topology = props.topology;
     if (indices) {
       this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
@@ -1792,12 +2036,16 @@ var Geometry = class {
     this.attributes = {};
     for (const [attributeName, attributeValue] of Object.entries(attributes)) {
       const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
-      (0, import_core13.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_core13.assert)(!this.indices);
+        if (this.indices) {
+          throw new Error("Multiple indices detected");
+        }
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
@@ -1844,11 +2092,10 @@ var Geometry = class {
     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_core13.assert)(Number.isFinite(vertexCount));
     return vertexCount;
   }
 };
@@ -1890,20 +2137,19 @@ var ClipSpace = class extends Model {
 };
 
 // dist/scenegraph/scenegraph-node.js
-var import_core15 = require("@luma.gl/core");
-var import_core16 = require("@math.gl/core");
+var import_core13 = require("@math.gl/core");
 var ScenegraphNode = class {
   id;
-  matrix = new import_core16.Matrix4();
+  matrix = new import_core13.Matrix4();
   display = true;
-  position = new import_core16.Vector3();
-  rotation = new import_core16.Vector3();
-  scale = new import_core16.Vector3(1, 1, 1);
+  position = new import_core13.Vector3();
+  rotation = new import_core13.Vector3();
+  scale = new import_core13.Vector3(1, 1, 1);
   userData = {};
   props = {};
   constructor(props = {}) {
     const { id } = props;
-    this.id = id || (0, import_core15.uid)(this.constructor.name);
+    this.id = id || uid(this.constructor.name);
     this._setScenegraphNodeProps(props);
   }
   getBounds() {
@@ -1923,17 +2169,14 @@ var ScenegraphNode = class {
     return `{type: ScenegraphNode, id: ${this.id})}`;
   }
   setPosition(position) {
-    (0, import_core15.assert)(position.length === 3, "setPosition requires vector argument");
     this.position = position;
     return this;
   }
   setRotation(rotation) {
-    (0, import_core15.assert)(rotation.length === 3, "setRotation requires vector argument");
     this.rotation = rotation;
     return this;
   }
   setScale(scale) {
-    (0, import_core15.assert)(scale.length === 3, "setScale requires vector argument");
     this.scale = scale;
     return this;
   }
@@ -1985,9 +2228,8 @@ var ScenegraphNode = class {
     return this;
   }
   getCoordinateUniforms(viewMatrix, modelMatrix) {
-    (0, import_core15.assert)(viewMatrix);
     modelMatrix = modelMatrix || this.matrix;
-    const worldMatrix = new import_core16.Matrix4(viewMatrix).multiplyRight(modelMatrix);
+    const worldMatrix = new import_core13.Matrix4(viewMatrix).multiplyRight(modelMatrix);
     const worldInverse = worldMatrix.invert();
     const worldInverseTranspose = worldInverse.transpose();
     return {
@@ -2022,9 +2264,6 @@ var ScenegraphNode = class {
     }
     */
   _setScenegraphNodeProps(props) {
-    if ("display" in props) {
-      this.display = props.display;
-    }
     if ("position" in props) {
       this.setPosition(props.position);
     }
@@ -2042,14 +2281,14 @@ var ScenegraphNode = class {
 };
 
 // dist/scenegraph/group-node.js
-var import_core17 = require("@math.gl/core");
-var import_core18 = require("@luma.gl/core");
+var import_core14 = require("@math.gl/core");
+var import_core15 = require("@luma.gl/core");
 var GroupNode = class extends ScenegraphNode {
   children;
   constructor(props = {}) {
     props = Array.isArray(props) ? { children: props } : props;
     const { children = [] } = props;
-    import_core18.log.assert(children.every((child) => child instanceof ScenegraphNode), "every child must an instance of ScenegraphNode");
+    import_core15.log.assert(children.every((child) => child instanceof ScenegraphNode), "every child must an instance of ScenegraphNode");
     super(props);
     this.children = children;
   }
@@ -2064,12 +2303,12 @@ var GroupNode = class extends ScenegraphNode {
         return;
       }
       const [min, max] = bounds;
-      const center = new import_core17.Vector3(min).add(max).divide([2, 2, 2]);
+      const center = new import_core14.Vector3(min).add(max).divide([2, 2, 2]);
       worldMatrix.transformAsPoint(center, center);
-      const halfSize = new import_core17.Vector3(max).subtract(min).divide([2, 2, 2]);
+      const halfSize = new import_core14.Vector3(max).subtract(min).divide([2, 2, 2]);
       worldMatrix.transformAsVector(halfSize, halfSize);
       for (let v = 0; v < 8; v++) {
-        const position = new import_core17.Vector3(v & 1 ? -1 : 1, v & 2 ? -1 : 1, v & 4 ? -1 : 1).multiply(halfSize).add(center);
+        const position = new import_core14.Vector3(v & 1 ? -1 : 1, v & 2 ? -1 : 1, v & 4 ? -1 : 1).multiply(halfSize).add(center);
         for (let i = 0; i < 3; i++) {
           result[0][i] = Math.min(result[0][i], position[i]);
           result[1][i] = Math.max(result[1][i], position[i]);
@@ -2109,8 +2348,8 @@ var GroupNode = class extends ScenegraphNode {
     this.children = [];
     return this;
   }
-  traverse(visitor, { worldMatrix = new import_core17.Matrix4() } = {}) {
-    const modelMatrix = new import_core17.Matrix4(worldMatrix).multiplyRight(this.matrix);
+  traverse(visitor, { worldMatrix = new import_core14.Matrix4() } = {}) {
+    const modelMatrix = new import_core14.Matrix4(worldMatrix).multiplyRight(this.matrix);
     for (const child of this.children) {
       if (child instanceof GroupNode) {
         child.traverse(visitor, { worldMatrix: modelMatrix });
@@ -2137,9 +2376,6 @@ var ModelNode = class extends ScenegraphNode {
     this.bounds = props.bounds || null;
     this.setProps(props);
   }
-  getBounds() {
-    return this.bounds;
-  }
   destroy() {
     if (this.model) {
       this.model.destroy();
@@ -2148,17 +2384,16 @@ var ModelNode = class extends ScenegraphNode {
     this.managedResources.forEach((resource) => resource.destroy());
     this.managedResources = [];
   }
+  getBounds() {
+    return this.bounds;
+  }
   // Expose model methods
   draw(renderPass) {
     return this.model.draw(renderPass);
   }
 };
 
-// dist/geometries/cone-geometry.js
-var import_core20 = require("@luma.gl/core");
-
 // dist/geometries/truncated-cone-geometry.js
-var import_core19 = require("@luma.gl/core");
 var INDEX_OFFSETS = {
   x: [2, 0, 1],
   y: [0, 1, 2],
@@ -2166,7 +2401,7 @@ var INDEX_OFFSETS = {
 };
 var TruncatedConeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core19.uid)("truncated-code-geometry") } = props;
+    const { id = uid("truncated-code-geometry") } = props;
     const { indices, attributes } = tesselateTruncatedCone(props);
     super({
       ...props,
@@ -2261,7 +2496,7 @@ function tesselateTruncatedCone(props = {}) {
 // dist/geometries/cone-geometry.js
 var ConeGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core20.uid)("cone-geometry"), radius = 1, cap = true } = props;
+    const { id = uid("cone-geometry"), radius = 1, cap = true } = props;
     super({
       ...props,
       id,
@@ -2274,10 +2509,9 @@ var ConeGeometry = class extends TruncatedConeGeometry {
 };
 
 // dist/geometries/cube-geometry.js
-var import_core21 = require("@luma.gl/core");
 var CubeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core21.uid)("cube-geometry"), indices = true } = props;
+    const { id = uid("cube-geometry"), indices = true } = props;
     super(indices ? {
       ...props,
       id,
@@ -2884,10 +3118,9 @@ var NON_INDEXED_ATTRIBUTES = {
 };
 
 // dist/geometries/cylinder-geometry.js
-var import_core22 = require("@luma.gl/core");
 var CylinderGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core22.uid)("cylinder-geometry"), radius = 1 } = props;
+    const { id = uid("cylinder-geometry"), radius = 1 } = props;
     super({
       ...props,
       id,
@@ -2898,13 +3131,12 @@ var CylinderGeometry = class extends TruncatedConeGeometry {
 };
 
 // dist/geometries/ico-sphere-geometry.js
-var import_core23 = require("@luma.gl/core");
-var import_core24 = require("@math.gl/core");
+var import_core16 = require("@math.gl/core");
 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_core23.uid)("ico-sphere-geometry") } = props;
+    const { id = uid("ico-sphere-geometry") } = props;
     const { indices, attributes } = tesselateIcosaHedron(props);
     super({
       ...props,
@@ -2997,7 +3229,7 @@ function tesselateIcosaHedron(props) {
     const u3 = 1 - phi3 / PI2;
     const vec1 = [x3 - x2, y3 - y2, z3 - z2];
     const vec2 = [x1 - x2, y1 - y2, z1 - z2];
-    const normal = new import_core24.Vector3(vec1).cross(vec2).normalize();
+    const normal = new import_core16.Vector3(vec1).cross(vec2).normalize();
     let newIndex;
     if ((u1 === 0 || u2 === 0 || u3 === 0) && (u1 === 0 || u1 > 0.5) && (u2 === 0 || u2 > 0.5) && (u3 === 0 || u3 > 0.5)) {
       positions.push(positions[in1 + 0], positions[in1 + 1], positions[in1 + 2]);
@@ -3045,9 +3277,6 @@ function tesselateIcosaHedron(props) {
   };
 }
 
-// dist/geometries/plane-geometry.js
-var import_core25 = require("@luma.gl/core");
-
 // dist/geometry/geometry-utils.js
 function unpackIndexedGeometry(geometry) {
   const { indices, attributes } = geometry;
@@ -3079,7 +3308,7 @@ function unpackIndexedGeometry(geometry) {
 // dist/geometries/plane-geometry.js
 var PlaneGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core25.uid)("plane-geometry") } = props;
+    const { id = uid("plane-geometry") } = props;
     const { indices, attributes } = tesselatePlane(props);
     super({
       ...props,
@@ -3169,10 +3398,9 @@ function tesselatePlane(props) {
 }
 
 // dist/geometries/sphere-geometry.js
-var import_core26 = require("@luma.gl/core");
 var SphereGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core26.uid)("sphere-geometry") } = props;
+    const { id = uid("sphere-geometry") } = props;
     const { indices, attributes } = tesselateSphere(props);
     super({
       ...props,
@@ -3247,11 +3475,26 @@ function tesselateSphere(props) {
   };
 }
 
+// dist/application-utils/random.js
+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);
+}
+
 // dist/computation.js
-var import_core27 = require("@luma.gl/core");
-var import_core28 = require("@luma.gl/core");
-var import_core29 = require("@luma.gl/core");
+var import_core17 = require("@luma.gl/core");
+var import_core18 = require("@luma.gl/core");
+var import_core19 = require("@luma.gl/core");
 var import_shadertools5 = require("@luma.gl/shadertools");
+var import_types2 = require("@math.gl/types");
 var LOG_DRAW_PRIORITY2 = 2;
 var LOG_DRAW_TIMEOUT2 = 1e4;
 var _Computation = class {
@@ -3262,13 +3505,16 @@ var _Computation = class {
   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;
@@ -3281,17 +3527,18 @@ var _Computation = class {
     }
     this.props = { ..._Computation.defaultProps, ...props };
     props = this.props;
-    this.id = props.id || (0, import_core28.uid)("model");
+    this.id = props.id || uid("model");
     this.device = device;
     Object.assign(this.userData, props.userData);
     const moduleMap = Object.fromEntries(((_a = this.props.modules) == null ? void 0 : _a.map((module2) => [module2.name, module2])) || []);
-    this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+    this.shaderInputs = props.shaderInputs || new ShaderInputs(moduleMap);
+    this.setShaderInputs(this.shaderInputs);
     this.props.shaderLayout ||= (0, import_shadertools5.getShaderLayoutFromWGSL)(this.props.source);
     const platformInfo = getPlatformInfo2(device);
     const modules = (((_b = this.props.modules) == null ? void 0 : _b.length) > 0 ? this.props.modules : (_c = this.shaderInputs) == null ? void 0 : _c.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
@@ -3344,7 +3591,7 @@ var _Computation = class {
   }
   setShaderInputs(shaderInputs) {
     this.shaderInputs = shaderInputs;
-    this._uniformStore = new import_core27.UniformStore(this.shaderInputs.modules);
+    this._uniformStore = new import_core17.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;
@@ -3357,7 +3604,7 @@ var _Computation = class {
     const uniforms = this._getModuleUniforms(props);
     const keys = Object.keys(uniforms).filter((k) => {
       const uniform = uniforms[k];
-      return !(0, import_core28.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+      return !(0, import_types2.isNumericArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
     });
     const bindings = {};
     for (const k of keys) {
@@ -3381,7 +3628,7 @@ var _Computation = class {
     if (this._pipelineNeedsUpdate) {
       let prevShader = null;
       if (this.pipeline) {
-        import_core28.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+        import_core18.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
         prevShader = this.shader;
       }
       this._pipelineNeedsUpdate = false;
@@ -3405,33 +3652,33 @@ var _Computation = class {
   _lastLogTime = 0;
   _logOpen = false;
   _logDrawCallStart() {
-    const logDrawTimeout = import_core28.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT2;
-    if (import_core28.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+    const logDrawTimeout = import_core18.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT2;
+    if (import_core18.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
       return;
     }
     this._lastLogTime = Date.now();
     this._logOpen = true;
-    import_core28.log.group(LOG_DRAW_PRIORITY2, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core28.log.level <= 2 })();
+    import_core18.log.group(LOG_DRAW_PRIORITY2, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core18.log.level <= 2 })();
   }
   _logDrawCallEnd() {
     if (this._logOpen) {
       const uniformTable = this.shaderInputs.getDebugTable();
-      import_core28.log.table(LOG_DRAW_PRIORITY2, uniformTable)();
-      import_core28.log.groupEnd(LOG_DRAW_PRIORITY2)();
+      import_core18.log.table(LOG_DRAW_PRIORITY2, uniformTable)();
+      import_core18.log.groupEnd(LOG_DRAW_PRIORITY2)();
       this._logOpen = false;
     }
   }
   _drawCount = 0;
   // TODO - fix typing of luma data types
   _getBufferOrConstantValues(attribute, dataType) {
-    const TypedArrayConstructor = (0, import_core29.getTypedArrayFromDataType)(dataType);
-    const typedArray = attribute instanceof import_core27.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+    const TypedArrayConstructor = (0, import_core19.getTypedArrayFromDataType)(dataType);
+    const typedArray = attribute instanceof import_core17.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
     return typedArray.toString();
   }
 };
 var Computation = _Computation;
 __publicField(Computation, "defaultProps", {
-  ...import_core27.ComputePipeline.defaultProps,
+  ...import_core17.ComputePipeline.defaultProps,
   id: "unnamed",
   handle: void 0,
   userData: {},