@luma.gl/shadertools 9.3.6 → 9.4.0-alpha.1

package/dist/index.cjs

@@ -25,15 +25,22 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  STORAGE_COLOR_DEFAULT_BYTE_STRIDES: () => STORAGE_COLOR_DEFAULT_BYTE_STRIDES,
+  STORAGE_COLOR_FORMAT: () => STORAGE_COLOR_FORMAT,
+  STORAGE_COLOR_FORMAT_BYTE_LENGTHS: () => STORAGE_COLOR_FORMAT_BYTE_LENGTHS,
   ShaderAssembler: () => ShaderAssembler,
   _getDependencyGraph: () => getDependencyGraph,
   _resolveModules: () => resolveModules,
   assembleGLSLShaderPair: () => assembleGLSLShaderPair,
   capitalize: () => capitalize,
   checkShaderModuleDeprecations: () => checkShaderModuleDeprecations,
+  clipShaderPlugin: () => clipShaderPlugin,
+  colors: () => colors,
   combineInjects: () => combineInjects,
   convertToVec4: () => convertToVec4,
+  dggs: () => dggs,
   dirlight: () => dirlight,
+  filterShaderPlugin: () => filterShaderPlugin,
   floatColors: () => floatColors,
   fp32: () => fp32,
   fp64: () => fp64,
@@ -59,6 +66,7 @@ __export(dist_exports, {
   initializeShaderModules: () => initializeShaderModules,
   lambertMaterial: () => lambertMaterial,
   lighting: () => lighting,
+  mergeShaderPluginModules: () => mergeShaderPluginModules,
   normalizeByteColor3: () => normalizeByteColor3,
   normalizeByteColor4: () => normalizeByteColor4,
   pbrMaterial: () => pbrMaterial,
@@ -67,13 +75,16 @@ __export(dist_exports, {
   picking: () => picking,
   preprocess: () => preprocess,
   random: () => random,
+  resolveShaderPlugins: () => resolveShaderPlugins,
   resolveUseByteColors: () => resolveUseByteColors,
   skin: () => skin,
+  storageColors: () => storageColors,
   toHalfFloat: () => toHalfFloat,
   typeToChannelCount: () => typeToChannelCount,
   typeToChannelSuffix: () => typeToChannelSuffix,
   validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout,
-  warnIfGLSLUniformBlocksAreNotStd140: () => warnIfGLSLUniformBlocksAreNotStd140
+  warnIfGLSLUniformBlocksAreNotStd140: () => warnIfGLSLUniformBlocksAreNotStd140,
+  waterMaterial: () => waterMaterial
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -218,7 +229,7 @@ function getHookStage(hook) {
       throw new Error(type);
   }
 }
-function injectShader(source4, stage, inject, injectStandardStubs = false) {
+function injectShader(source4, stage, inject, injectStandardStubs = false, language = "glsl", entryPoints = {}) {
   const isVertex = stage === "vertex";
   for (const key in inject) {
     const fragmentData = inject[key];
@@ -231,33 +242,33 @@ function injectShader(source4, stage, inject, injectStandardStubs = false) {
 `;
     switch (key) {
       case "vs:#decl":
-        if (isVertex) {
+        if (language === "wgsl" || isVertex) {
           source4 = source4.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "vs:#main-start":
-        if (isVertex) {
-          source4 = source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+        if (language === "wgsl" || isVertex) {
+          source4 = language === "wgsl" ? injectWGSLStageMain(source4, "vertex", fragmentString, "start", entryPoints.vertex) : source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "vs:#main-end":
-        if (isVertex) {
-          source4 = source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+        if (language === "wgsl" || isVertex) {
+          source4 = language === "wgsl" ? injectWGSLStageMain(source4, "vertex", fragmentString, "end", entryPoints.vertex) : source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       case "fs:#decl":
-        if (!isVertex) {
+        if (language === "wgsl" || !isVertex) {
           source4 = source4.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "fs:#main-start":
-        if (!isVertex) {
-          source4 = source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+        if (language === "wgsl" || !isVertex) {
+          source4 = language === "wgsl" ? injectWGSLStageMain(source4, "fragment", fragmentString, "start", entryPoints.fragment) : source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "fs:#main-end":
-        if (!isVertex) {
-          source4 = source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+        if (language === "wgsl" || !isVertex) {
+          source4 = language === "wgsl" ? injectWGSLStageMain(source4, "fragment", fragmentString, "end", entryPoints.fragment) : source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       default:
@@ -281,6 +292,49 @@ ${inject[key]}` : inject[key];
   });
   return result;
 }
+function injectWGSLStageMain(source4, stage, fragmentString, position, entryPoint) {
+  const bodyRange = getWGSLStageFunctionBodyRange(source4, stage, entryPoint);
+  if (!bodyRange) {
+    return source4;
+  }
+  if (position === "start") {
+    const insertionIndex = bodyRange.openBraceIndex + 1;
+    return `${source4.slice(0, insertionIndex)}
+${fragmentString}${source4.slice(insertionIndex)}`;
+  }
+  return `${source4.slice(0, bodyRange.closeBraceIndex)}${fragmentString}${source4.slice(bodyRange.closeBraceIndex)}`;
+}
+function getWGSLStageFunctionBodyRange(source4, stage, entryPoint) {
+  const stageAttribute = stage === "vertex" ? "@vertex" : "@fragment";
+  const stageIndex = source4.indexOf(stageAttribute);
+  if (stageIndex < 0) {
+    return null;
+  }
+  const functionIndex = entryPoint ? source4.search(new RegExp(`\\bfn\\s+${escapeRegExp(entryPoint)}\\s*\\(`)) : source4.indexOf("fn", stageIndex);
+  if (functionIndex < 0) {
+    return null;
+  }
+  const openBraceIndex = source4.indexOf("{", functionIndex);
+  if (openBraceIndex < 0) {
+    return null;
+  }
+  let braceDepth = 0;
+  for (let index = openBraceIndex; index < source4.length; index++) {
+    const character = source4[index];
+    if (character === "{") {
+      braceDepth++;
+    } else if (character === "}") {
+      braceDepth--;
+      if (braceDepth === 0) {
+        return { openBraceIndex, closeBraceIndex: index };
+      }
+    }
+  }
+  return null;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // dist/lib/shader-module/shader-module.js
 function initializeShaderModules(modules) {
@@ -392,6 +446,97 @@ function resolveModules(modules) {
   return getShaderDependencies(modules);
 }
 
+// dist/lib/shader-plugin.js
+var import_core = require("@luma.gl/core");
+var SHADER_PLUGIN_INJECTION_TARGET_REGEX = /^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][\w-]*)$/;
+function resolveShaderPlugins(plugins = [], shaderLanguage) {
+  const modules = [];
+  const defines = {};
+  const injections = {};
+  const vertexInputs = {};
+  const varyings = {};
+  for (const plugin of plugins) {
+    appendShaderPluginVariant({ modules, defines, injections, vertexInputs, varyings }, plugin);
+    appendShaderPluginVariant({ modules, defines, injections, vertexInputs, varyings }, plugin[shaderLanguage]);
+  }
+  for (const name of Object.keys(varyings)) {
+    if (vertexInputs[name]) {
+      throw new Error(`ShaderPlugin name "${name}" cannot be both a vertex input and a varying`);
+    }
+  }
+  return { modules, defines, injections, vertexInputs, varyings };
+}
+function mergeShaderPluginModules(modules = [], pluginModules = []) {
+  const mergedModules = [...modules];
+  const seenModuleNames = new Set(mergedModules.map((module2) => module2.name));
+  for (const pluginModule of pluginModules) {
+    if (!seenModuleNames.has(pluginModule.name)) {
+      mergedModules.push(pluginModule);
+      seenModuleNames.add(pluginModule.name);
+    }
+  }
+  return mergedModules;
+}
+function appendShaderPluginVariant(resolved, variant) {
+  var _a;
+  if (!variant) {
+    return;
+  }
+  if ((_a = variant.modules) == null ? void 0 : _a.length) {
+    resolved.modules.push(...variant.modules);
+  }
+  if (variant.defines) {
+    Object.assign(resolved.defines, variant.defines);
+  }
+  for (const [name, type] of Object.entries(variant.vertexInputs || {})) {
+    assertShaderPluginInterfaceName(name, "vertex input");
+    const existingType = resolved.vertexInputs[name];
+    if (existingType && existingType !== type) {
+      throw new Error(`ShaderPlugin vertex input "${name}" has conflicting types "${existingType}" and "${type}"`);
+    }
+    resolved.vertexInputs[name] = type;
+  }
+  for (const [name, varying] of Object.entries(variant.varyings || {})) {
+    assertShaderPluginInterfaceName(name, "varying");
+    const normalizedVarying = normalizeShaderPluginVarying(name, varying);
+    const existingVarying = resolved.varyings[name];
+    if (existingVarying && (existingVarying.type !== normalizedVarying.type || existingVarying.interpolation !== normalizedVarying.interpolation)) {
+      throw new Error(`ShaderPlugin varying "${name}" has conflicting declarations "${existingVarying.type}/${existingVarying.interpolation}" and "${normalizedVarying.type}/${normalizedVarying.interpolation}"`);
+    }
+    resolved.varyings[name] = normalizedVarying;
+  }
+  for (const injection of variant.injections || []) {
+    assertNamedShaderPluginInjectionTarget(injection.target);
+    if (!resolved.injections[injection.target]) {
+      resolved.injections[injection.target] = [];
+    }
+    const injections = resolved.injections[injection.target];
+    injections.push({
+      injection: injection.injection,
+      order: injection.order ?? 0
+    });
+  }
+}
+function assertShaderPluginInterfaceName(name, kind) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || name.startsWith("_luma_")) {
+    throw new Error(`ShaderPlugin ${kind} "${name}" must be a valid non-reserved identifier`);
+  }
+}
+function normalizeShaderPluginVarying(name, varying) {
+  const { primitiveType } = import_core.shaderTypeDecoder.getAttributeShaderTypeInfo(varying.type);
+  const integerType = primitiveType === "i32" || primitiveType === "u32";
+  const interpolation = varying.interpolation || (integerType ? "flat" : "smooth");
+  if (integerType && interpolation === "smooth") {
+    throw new Error(`ShaderPlugin integer varying "${name}" must use flat interpolation`);
+  }
+  return { type: varying.type, interpolation };
+}
+function assertNamedShaderPluginInjectionTarget(target) {
+  if (!SHADER_PLUGIN_INJECTION_TARGET_REGEX.test(target)) {
+    throw new Error(`ShaderPlugin injection target "${target}" must be a named shader anchor or hook`);
+  }
+}
+
 // dist/lib/shader-module/shader-module-uniform-layout.js
 var GLSL_UNIFORM_BLOCK_FIELD_REGEXP = /^(?:uniform\s+)?(?:(?:lowp|mediump|highp)\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/;
 var GLSL_UNIFORM_BLOCK_REGEXP = /((?:layout\s*\([^)]*\)\s*)*)uniform\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}\s*([A-Za-z_][A-Za-z0-9_]*)?\s*;/g;
@@ -684,11 +829,12 @@ function makeVariableTextRegExp(qualifier) {
 }
 
 // dist/lib/shader-assembly/shader-hooks.js
-function getShaderHooks(hookFunctions, hookInjections) {
+function getShaderHooks(hookFunctions, hookInjections, shaderLanguage = "glsl") {
   let result = "";
   for (const hookName in hookFunctions) {
     const hookFunction = hookFunctions[hookName];
-    result += `void ${hookFunction.signature} {
+    const functionPrefix = shaderLanguage === "wgsl" ? "fn" : "void";
+    result += `${functionPrefix} ${hookFunction.signature} {
 `;
     if (hookFunction.header) {
       result += `  ${hookFunction.header}`;
@@ -721,7 +867,9 @@ function normalizeShaderHooks(hookFunctions) {
       hook = hookFunction;
     }
     hook = hook.trim();
-    const [shaderStage, signature] = hook.split(":");
+    const stageSeparatorIndex = hook.indexOf(":");
+    const shaderStage = hook.slice(0, stageSeparatorIndex);
+    const signature = hook.slice(stageSeparatorIndex + 1);
     const name = hook.replace(/\(.+/, "");
     const normalizedHook = Object.assign(opts, { signature });
     switch (shaderStage) {
@@ -1051,140 +1199,856 @@ function getStorageTextureAccess(resourceType) {
   return match == null ? void 0 : match[1];
 }
 
-// dist/lib/shader-assembly/assemble-shaders.js
-var INJECT_SHADER_DECLARATIONS = `
+// dist/lib/preprocessor/preprocessor.js
+var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
+var IF_REGEXP = /^\s*\#\s*if\s+(.+?)\s*(?:\/\/.*)?$/;
+var IFDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*$`);
+var IFNDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifndef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
+var ELSE_REGEXP = /^\s*\#\s*else\s*(?:\/\/.*)?$/;
+var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
+var IFDEF_WITH_COMMENT_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
+var ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
+function preprocess(source4, options) {
+  var _a, _b;
+  const lines = source4.split("\n");
+  const output = [];
+  const conditionalStack = [];
+  let conditional = true;
+  for (const line of lines) {
+    const matchIfExpression = line.match(IF_REGEXP);
+    const matchIf = line.match(IFDEF_WITH_COMMENT_REGEXP) || line.match(IFDEF_REGEXP);
+    const matchIfNot = line.match(IFNDEF_REGEXP);
+    const matchElse = line.match(ELSE_REGEXP);
+    const matchEnd = line.match(ENDIF_WITH_COMMENT_REGEXP) || line.match(ENDIF_REGEXP);
+    if (matchIfExpression) {
+      const branchTaken = evaluateIfExpression(matchIfExpression[1], (options == null ? void 0 : options.defines) || {});
+      const active = conditional && branchTaken;
+      conditionalStack.push({ parentActive: conditional, branchTaken, active });
+      conditional = active;
+    } else if (matchIf || matchIfNot) {
+      const defineName = (_a = matchIf || matchIfNot) == null ? void 0 : _a[1];
+      const defineValue = Boolean((_b = options == null ? void 0 : options.defines) == null ? void 0 : _b[defineName]);
+      const branchTaken = matchIf ? defineValue : !defineValue;
+      const active = conditional && branchTaken;
+      conditionalStack.push({ parentActive: conditional, branchTaken, active });
+      conditional = active;
+    } else if (matchElse) {
+      const currentConditional = conditionalStack[conditionalStack.length - 1];
+      if (!currentConditional) {
+        throw new Error("Encountered #else without matching #if, #ifdef or #ifndef");
+      }
+      currentConditional.active = currentConditional.parentActive && !currentConditional.branchTaken;
+      currentConditional.branchTaken = true;
+      conditional = currentConditional.active;
+    } else if (matchEnd) {
+      conditionalStack.pop();
+      conditional = conditionalStack.length ? conditionalStack[conditionalStack.length - 1].active : true;
+    } else if (conditional) {
+      output.push(line);
+    }
+  }
+  if (conditionalStack.length > 0) {
+    throw new Error("Unterminated conditional block in shader source");
+  }
+  return output.join("\n");
+}
+function evaluateIfExpression(expression, defines) {
+  const trimmedExpression = expression.trim();
+  if (/^[+-]?\d+(?:\.\d+)?$/.test(trimmedExpression)) {
+    return Number(trimmedExpression) !== 0;
+  }
+  if (trimmedExpression === "true") {
+    return true;
+  }
+  if (trimmedExpression === "false") {
+    return false;
+  }
+  const negatedDefineMatch = trimmedExpression.match(new RegExp(`^!\\s*${DEFINE_NAME_PATTERN}$`));
+  if (negatedDefineMatch) {
+    return !Boolean(defines[negatedDefineMatch[1]]);
+  }
+  const defineMatch = trimmedExpression.match(new RegExp(`^${DEFINE_NAME_PATTERN}$`));
+  if (defineMatch) {
+    return Boolean(defines[defineMatch[1]]);
+  }
+  const definedMatch = trimmedExpression.match(new RegExp(`^defined\\s*\\(\\s*${DEFINE_NAME_PATTERN}\\s*\\)$`));
+  if (definedMatch) {
+    return defines[definedMatch[1]] !== void 0;
+  }
+  const negatedDefinedMatch = trimmedExpression.match(new RegExp(`^!\\s*defined\\s*\\(\\s*${DEFINE_NAME_PATTERN}\\s*\\)$`));
+  if (negatedDefinedMatch) {
+    return defines[negatedDefinedMatch[1]] === void 0;
+  }
+  throw new Error(`Unsupported #if expression "${expression}"`);
+}
 
-${DECLARATION_INJECT_MARKER}
-`;
-var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
-var FRAGMENT_SHADER_PROLOGUE = (
-  /* glsl */
-  `precision highp float;
-`
-);
-function assembleWGSLShader(options) {
-  const modules = getShaderModuleDependencies(options.modules || []);
-  const { source: source4, bindingAssignments } = assembleShaderWGSL(options.platformInfo, {
-    ...options,
-    source: options.source,
-    stage: "vertex",
-    modules
-  });
+// dist/lib/shader-assembly/shader-plugin-vertex-inputs.js
+var import_core2 = require("@luma.gl/core");
+function getShaderPluginVertexInputDeclarationsGLSL(source4, vertexInputs) {
+  const declarations = [];
+  for (const [name, type] of Object.entries(vertexInputs)) {
+    assertGLSLVertexInputIsNew(source4, name);
+    declarations.push(`in ${getGLSLAttributeType(type)} ${name};`);
+  }
+  return declarations.join("\n");
+}
+function assembleShaderPluginVertexInputsWGSL(source4, vertexEntryPoint, vertexInputs) {
+  const entries = Object.entries(vertexInputs);
+  if (entries.length === 0) {
+    return { source: source4, declarations: "", initialization: "" };
+  }
+  const functionRange = getWGSLFunctionParameterRange(source4, vertexEntryPoint);
+  const parameterSource = source4.slice(functionRange.openParenthesis + 1, functionRange.closeParenthesis);
+  const interfaceInfo = getWGSLVertexInterfaceInfo(source4, parameterSource);
+  const usedLocations = new Set(interfaceInfo.locations);
+  const generatedParameters = [];
+  const declarations = [];
+  const initialization = [];
+  for (const [name, type] of entries) {
+    if (interfaceInfo.names.has(name) || hasWGSLModuleVariable(source4, name)) {
+      throw new Error(`ShaderPlugin vertex input "${name}" conflicts with an existing WGSL shader input or variable`);
+    }
+    const location = getFirstUnusedLocation(usedLocations);
+    usedLocations.add(location);
+    const parameterName = `_luma_${name}`;
+    generatedParameters.push(`@location(${location}) ${parameterName}: ${type}`);
+    declarations.push(`var<private> ${name}: ${type};`);
+    initialization.push(`${name} = ${parameterName};`);
+  }
+  const separator = parameterSource.trim() ? ",\n  " : "\n  ";
+  const suffix = parameterSource.trim() ? "" : "\n";
+  const injectedParameters = `${parameterSource}${separator}${generatedParameters.join(",\n  ")}${suffix}`;
+  const transformedSource = source4.slice(0, functionRange.openParenthesis + 1) + injectedParameters + source4.slice(functionRange.closeParenthesis);
   return {
-    source: source4,
-    getUniforms: assembleGetUniforms(modules),
-    bindingAssignments,
-    bindingTable: getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments)
+    source: transformedSource,
+    declarations: declarations.join("\n"),
+    initialization: initialization.join("\n")
   };
 }
-function assembleGLSLShaderPair(options) {
-  const { vs: vs4, fs: fs5 } = options;
-  const modules = getShaderModuleDependencies(options.modules || []);
-  return {
-    vs: assembleShaderGLSL(options.platformInfo, {
-      ...options,
-      source: vs4,
-      stage: "vertex",
-      modules
-    }),
-    fs: assembleShaderGLSL(options.platformInfo, {
-      ...options,
-      // @ts-expect-error
-      source: fs5,
-      stage: "fragment",
-      modules
-    }),
-    getUniforms: assembleGetUniforms(modules)
-  };
+function getGLSLAttributeType(type) {
+  const { primitiveType, components } = import_core2.shaderTypeDecoder.getAttributeShaderTypeInfo(type);
+  const scalarType = primitiveType === "i32" ? "int" : primitiveType === "u32" ? "uint" : "float";
+  if (components === 1) {
+    return scalarType;
+  }
+  const prefix = scalarType === "int" ? "i" : scalarType === "uint" ? "u" : "";
+  return `${prefix}vec${components}`;
+}
+function assertGLSLVertexInputIsNew(source4, name) {
+  const escapedName = escapeRegExp2(name);
+  const declaration = new RegExp(`\\b(?:in|attribute)\\s+(?:(?:lowp|mediump|highp)\\s+)?[A-Za-z_][A-Za-z0-9_]*\\s+${escapedName}\\s*(?:\\[|;)`);
+  if (declaration.test(source4)) {
+    throw new Error(`ShaderPlugin vertex input "${name}" conflicts with an existing GLSL input`);
+  }
+}
+function getWGSLFunctionParameterRange(source4, entryPoint) {
+  const functionPattern = new RegExp(`\\bfn\\s+${escapeRegExp2(entryPoint)}\\s*\\(`, "g");
+  const match = functionPattern.exec(source4);
+  if (!match) {
+    throw new Error(`ShaderPlugin vertex inputs require WGSL vertex entry point "${entryPoint}"`);
+  }
+  const openParenthesis = source4.indexOf("(", match.index);
+  const closeParenthesis = findMatchingDelimiter(source4, openParenthesis, "(", ")");
+  if (closeParenthesis < 0) {
+    throw new Error(`Unable to parse WGSL vertex entry point "${entryPoint}" parameters`);
+  }
+  return { openParenthesis, closeParenthesis };
+}
+function getWGSLVertexInterfaceInfo(source4, parameterSource) {
+  const locations = getWGSLLocations(parameterSource);
+  const names = new Set(getWGSLDeclaredNames(parameterSource));
+  const parameterTypes = getWGSLParameterTypes(parameterSource);
+  for (const parameterType of parameterTypes) {
+    const structBody = getWGSLStructBody(source4, parameterType);
+    if (structBody === null) {
+      continue;
+    }
+    locations.push(...getWGSLLocations(structBody));
+    for (const name of getWGSLDeclaredNames(structBody)) {
+      names.add(name);
+    }
+  }
+  return { locations, names };
 }
-function assembleShaderWGSL(platformInfo, options) {
-  var _a;
-  const {
-    // id,
-    source: source4,
-    stage,
-    modules,
-    // defines = {},
-    hookFunctions = [],
-    inject = {},
-    log: log2
-  } = options;
-  assert(typeof source4 === "string", "shader source must be a string");
-  const coreSource = source4;
-  let assembledSource = "";
-  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
-  const hookInjections = {};
-  const declInjections = {};
-  const mainInjections = {};
-  for (const key in inject) {
-    const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
-    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
-    if (match) {
-      const hash = match[2];
-      const name = match[3];
-      if (hash) {
-        if (name === "decl") {
-          declInjections[key] = [injection];
-        } else {
-          mainInjections[key] = [injection];
-        }
-      } else {
-        hookInjections[key] = [injection];
-      }
-    } else {
-      mainInjections[key] = [injection];
+function getWGSLLocations(source4) {
+  const locations = [];
+  const locationPattern = /@location\s*\(\s*(\d+)\s*\)/g;
+  let match = locationPattern.exec(source4);
+  while (match) {
+    locations.push(Number(match[1]));
+    match = locationPattern.exec(source4);
+  }
+  return locations;
+}
+function getWGSLDeclaredNames(source4) {
+  const names = [];
+  const namePattern = /(?:^|,)\s*(?:@[A-Za-z_][\w]*(?:\([^)]*\))?\s*)*([A-Za-z_][\w]*)\s*:/gm;
+  let match = namePattern.exec(source4);
+  while (match) {
+    names.push(match[1]);
+    match = namePattern.exec(source4);
+  }
+  return names;
+}
+function getWGSLParameterTypes(source4) {
+  const types = [];
+  const typePattern = /:\s*([A-Za-z_][\w]*)\b/g;
+  let match = typePattern.exec(source4);
+  while (match) {
+    types.push(match[1]);
+    match = typePattern.exec(source4);
+  }
+  return types;
+}
+function getWGSLStructBody(source4, structName) {
+  const structPattern = new RegExp(`\\bstruct\\s+${escapeRegExp2(structName)}\\s*\\{`, "g");
+  const match = structPattern.exec(source4);
+  if (!match) {
+    return null;
+  }
+  const openBrace = source4.indexOf("{", match.index);
+  const closeBrace = findMatchingDelimiter(source4, openBrace, "{", "}");
+  return closeBrace < 0 ? null : source4.slice(openBrace + 1, closeBrace);
+}
+function hasWGSLModuleVariable(source4, name) {
+  const escapedName = escapeRegExp2(name);
+  const variablePattern = new RegExp(`\\b(?:var(?:<[^>]+>)?|let|const)\\s+${escapedName}\\b`, "g");
+  let match = variablePattern.exec(source4);
+  while (match) {
+    if (getBraceDepthAt(source4, match.index) === 0) {
+      return true;
     }
+    match = variablePattern.exec(source4);
   }
-  const modulesToInject = modules;
-  const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
-  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(applicationRelocation.source);
-  const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
-  const bindingAssignments = [];
-  for (const module2 of modulesToInject) {
-    if (log2) {
-      checkShaderModuleDeprecations(module2, coreSource, log2);
+  return false;
+}
+function getFirstUnusedLocation(usedLocations) {
+  let location = 0;
+  while (usedLocations.has(location)) {
+    location++;
+  }
+  return location;
+}
+function findMatchingDelimiter(source4, openIndex, openCharacter, closeCharacter) {
+  let depth = 0;
+  let blockCommentDepth = 0;
+  let lineComment = false;
+  for (let index = openIndex; index < source4.length; index++) {
+    const character = source4[index];
+    const nextCharacter = source4[index + 1];
+    if (lineComment) {
+      if (character === "\n")
+        lineComment = false;
+      continue;
     }
-    const relocation = relocateWGSLModuleBindings(getShaderModuleSource(module2, "wgsl", log2), module2, {
-      usedBindingsByGroup,
-      bindingRegistry: options._bindingRegistry,
-      reservedBindingKeysByGroup
-    });
-    bindingAssignments.push(...relocation.bindingAssignments);
-    const moduleSource = relocation.source;
-    assembledSource += moduleSource;
-    const injections = ((_a = module2.injections) == null ? void 0 : _a[stage]) || {};
-    for (const key in injections) {
-      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
-      if (match) {
-        const name = match[2];
-        const injectionType = name === "decl" ? declInjections : mainInjections;
-        injectionType[key] = injectionType[key] || [];
-        injectionType[key].push(injections[key]);
-      } else {
-        hookInjections[key] = hookInjections[key] || [];
-        hookInjections[key].push(injections[key]);
+    if (blockCommentDepth > 0) {
+      if (character === "/" && nextCharacter === "*") {
+        blockCommentDepth++;
+        index++;
+      } else if (character === "*" && nextCharacter === "/") {
+        blockCommentDepth--;
+        index++;
       }
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index++;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockCommentDepth = 1;
+      index++;
+      continue;
     }
+    if (character === openCharacter)
+      depth++;
+    if (character === closeCharacter && --depth === 0)
+      return index;
   }
-  assembledSource += INJECT_SHADER_DECLARATIONS;
-  assembledSource = injectShader(assembledSource, stage, declInjections);
-  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
-  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
-  assembledSource += applicationRelocation.source;
-  assembledSource = injectShader(assembledSource, stage, mainInjections);
-  assertNoUnresolvedAutoBindings(assembledSource);
-  return { source: assembledSource, bindingAssignments };
+  return -1;
 }
-function assembleShaderGLSL(platformInfo, options) {
-  var _a;
-  const { source: source4, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
-  assert(typeof source4 === "string", "shader source must be a string");
-  const sourceVersion = language === "glsl" ? getShaderInfo(source4).version : -1;
-  const targetVersion = platformInfo.shaderLanguageVersion;
-  const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
-  const sourceLines = source4.split("\n");
-  const coreSource = sourceLines.slice(1).join("\n");
-  const allDefines = {};
+function getBraceDepthAt(source4, endIndex) {
+  let depth = 0;
+  let blockCommentDepth = 0;
+  let lineComment = false;
+  for (let index = 0; index < endIndex; index++) {
+    const character = source4[index];
+    const nextCharacter = source4[index + 1];
+    if (lineComment) {
+      if (character === "\n")
+        lineComment = false;
+      continue;
+    }
+    if (blockCommentDepth > 0) {
+      if (character === "/" && nextCharacter === "*") {
+        blockCommentDepth++;
+        index++;
+      } else if (character === "*" && nextCharacter === "/") {
+        blockCommentDepth--;
+        index++;
+      }
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index++;
+    } else if (character === "/" && nextCharacter === "*") {
+      blockCommentDepth = 1;
+      index++;
+    } else if (character === "{") {
+      depth++;
+    } else if (character === "}") {
+      depth--;
+    }
+  }
+  return depth;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// dist/lib/shader-assembly/shader-plugin-varyings.js
+var import_core3 = require("@luma.gl/core");
+function assembleShaderPluginVaryingsGLSL(source4, stage, varyings) {
+  const declarations = [];
+  const initialization = [];
+  for (const [name, varying] of Object.entries(varyings)) {
+    assertGLSLVaryingIsNew(source4, name);
+    const qualifier = varying.interpolation === "flat" ? "flat " : "";
+    const direction = stage === "vertex" ? "out" : "in";
+    declarations.push(`${qualifier}${direction} ${getGLSLAttributeType(varying.type)} ${name};`);
+    if (stage === "vertex") {
+      initialization.push(`${name} = ${getGLSLZeroValue(varying.type)};`);
+    }
+  }
+  return { declarations: declarations.join("\n"), initialization: initialization.join("\n") };
+}
+function assembleShaderPluginVaryingsWGSL(source4, vertexEntryPoint, fragmentEntryPoint, varyings) {
+  const entries = Object.entries(varyings);
+  if (entries.length === 0) {
+    return {
+      source: source4,
+      declarations: "",
+      vertexInitialization: "",
+      fragmentInitialization: ""
+    };
+  }
+  let transformedSource = source4;
+  let vertexFunction = getWGSLFunctionRange(transformedSource, vertexEntryPoint, "vertex");
+  const vertexOutputType = getWGSLNamedReturnType(transformedSource, vertexFunction);
+  let fragmentFunction = getWGSLFunctionRange(transformedSource, fragmentEntryPoint, "fragment");
+  const fragmentInput = getWGSLFragmentStructInput(transformedSource, fragmentFunction);
+  const vertexOutputStruct = getWGSLStructRange(transformedSource, vertexOutputType);
+  const fragmentInputStruct = getWGSLStructRange(transformedSource, fragmentInput.type);
+  const interfaceNames = /* @__PURE__ */ new Set([
+    ...getWGSLDeclaredNames2(vertexFunction.parameters),
+    ...getWGSLDeclaredNames2(vertexOutputStruct.body),
+    ...getWGSLDeclaredNames2(fragmentFunction.parameters),
+    ...getWGSLDeclaredNames2(fragmentInputStruct.body)
+  ]);
+  const usedLocations = /* @__PURE__ */ new Set([
+    ...getWGSLLocations2(vertexOutputStruct.body),
+    ...getWGSLLocations2(fragmentInputStruct.body)
+  ]);
+  const fields = [];
+  const declarations = [];
+  const vertexInitialization = [];
+  const fragmentInitialization = [];
+  for (const [name, varying] of entries) {
+    if (interfaceNames.has(name) || hasWGSLModuleVariable2(transformedSource, name)) {
+      throw new Error(`ShaderPlugin varying "${name}" conflicts with existing WGSL stage I/O or a module variable`);
+    }
+    const location = getFirstUnusedLocation2(usedLocations);
+    usedLocations.add(location);
+    const interpolation = varying.interpolation === "flat" ? " @interpolate(flat)" : "";
+    fields.push(`  @location(${location})${interpolation} ${name}: ${varying.type},`);
+    declarations.push(`var<private> ${name}: ${varying.type};`);
+    vertexInitialization.push(`${name} = ${getWGSLZeroValue(varying.type)};`);
+    fragmentInitialization.push(`${name} = ${fragmentInput.name}.${name};`);
+  }
+  assertWGSLStructConstructorsAreLocal(transformedSource, vertexOutputType, vertexFunction.openBrace, vertexFunction.closeBrace);
+  transformedSource = appendWGSLConstructorArgumentsInFunction(transformedSource, vertexOutputType, vertexFunction, entries.map(([name]) => name));
+  vertexFunction = getWGSLFunctionRange(transformedSource, vertexEntryPoint, "vertex");
+  transformedSource = rewriteWGSLVertexReturns(transformedSource, vertexFunction, entries.map(([name]) => name));
+  const structNames = vertexOutputType === fragmentInput.type ? [vertexOutputType] : [vertexOutputType, fragmentInput.type];
+  const structInsertions = structNames.map((structName) => getWGSLStructRange(transformedSource, structName).closeBrace).sort((left, right) => right - left);
+  for (const insertionIndex of structInsertions) {
+    transformedSource = transformedSource.slice(0, insertionIndex) + `${fields.join("\n")}
+` + transformedSource.slice(insertionIndex);
+  }
+  fragmentFunction = getWGSLFunctionRange(transformedSource, fragmentEntryPoint, "fragment");
+  const fragmentInputPattern = new RegExp(`\\b${escapeRegExp3(fragmentInput.name)}\\s*:`);
+  if (!fragmentInputPattern.test(fragmentFunction.parameters)) {
+    throw new Error(`Unable to preserve WGSL fragment input "${fragmentInput.name}"`);
+  }
+  return {
+    source: transformedSource,
+    declarations: declarations.join("\n"),
+    vertexInitialization: vertexInitialization.join("\n"),
+    fragmentInitialization: fragmentInitialization.join("\n")
+  };
+}
+function getWGSLFunctionRange(source4, entryPoint, stage) {
+  const functionPattern = new RegExp(`\\bfn\\s+${escapeRegExp3(entryPoint)}\\s*\\(`, "g");
+  const match = functionPattern.exec(source4);
+  if (!match) {
+    throw new Error(`ShaderPlugin varyings require WGSL ${stage} entry point "${entryPoint}"`);
+  }
+  const openParenthesis = source4.indexOf("(", match.index);
+  const closeParenthesis = findMatchingDelimiter2(source4, openParenthesis, "(", ")");
+  const openBrace = source4.indexOf("{", closeParenthesis);
+  const closeBrace = findMatchingDelimiter2(source4, openBrace, "{", "}");
+  if (closeParenthesis < 0 || openBrace < 0 || closeBrace < 0) {
+    throw new Error(`Unable to parse WGSL ${stage} entry point "${entryPoint}"`);
+  }
+  return {
+    openParenthesis,
+    closeParenthesis,
+    openBrace,
+    closeBrace,
+    parameters: source4.slice(openParenthesis + 1, closeParenthesis)
+  };
+}
+function getWGSLNamedReturnType(source4, functionRange) {
+  const resultSource = source4.slice(functionRange.closeParenthesis + 1, functionRange.openBrace);
+  const match = /->\s*([A-Za-z_][\w]*)\s*$/.exec(resultSource.trim());
+  if (!match || getWGSLStructRangeOrNull(source4, match[1]) === null) {
+    throw new Error("ShaderPlugin varyings require the WGSL vertex entry point to return a named struct");
+  }
+  return match[1];
+}
+function getWGSLFragmentStructInput(source4, functionRange) {
+  const candidates = [];
+  for (const parameter of splitTopLevel(functionRange.parameters, ",")) {
+    const match = /(?:@[A-Za-z_][\w]*(?:\([^)]*\))?\s*)*([A-Za-z_][\w]*)\s*:\s*([A-Za-z_][\w]*)\s*$/.exec(parameter.trim());
+    if (match && getWGSLStructRangeOrNull(source4, match[2])) {
+      candidates.push({ name: match[1], type: match[2] });
+    }
+  }
+  if (candidates.length !== 1) {
+    throw new Error(`ShaderPlugin varyings require exactly one named WGSL fragment input struct; found ${candidates.length}`);
+  }
+  return candidates[0];
+}
+function getWGSLStructRange(source4, structName) {
+  const range = getWGSLStructRangeOrNull(source4, structName);
+  if (!range) {
+    throw new Error(`Unable to find WGSL stage I/O struct "${structName}"`);
+  }
+  return range;
+}
+function getWGSLStructRangeOrNull(source4, structName) {
+  const structPattern = new RegExp(`\\bstruct\\s+${escapeRegExp3(structName)}\\s*\\{`, "g");
+  const match = structPattern.exec(source4);
+  if (!match) {
+    return null;
+  }
+  const openBrace = source4.indexOf("{", match.index);
+  const closeBrace = findMatchingDelimiter2(source4, openBrace, "{", "}");
+  return closeBrace < 0 ? null : { openBrace, closeBrace, body: source4.slice(openBrace + 1, closeBrace) };
+}
+function assertWGSLStructConstructorsAreLocal(source4, structName, functionStart, functionEnd) {
+  const constructorPattern = new RegExp(`\\b${escapeRegExp3(structName)}\\s*\\(`, "g");
+  let match = constructorPattern.exec(source4);
+  while (match) {
+    if (match.index < functionStart || match.index > functionEnd) {
+      throw new Error(`ShaderPlugin varying output struct "${structName}" is constructed outside the selected vertex entry point`);
+    }
+    match = constructorPattern.exec(source4);
+  }
+}
+function appendWGSLConstructorArgumentsInFunction(source4, structName, functionRange, varyingNames) {
+  const constructorPattern = new RegExp(`\\b${escapeRegExp3(structName)}\\s*\\(`, "g");
+  const insertions = [];
+  let match = constructorPattern.exec(source4);
+  while (match) {
+    if (match.index > functionRange.openBrace && match.index < functionRange.closeBrace) {
+      const openParenthesis = source4.indexOf("(", match.index);
+      const closeParenthesis = findMatchingDelimiter2(source4, openParenthesis, "(", ")");
+      if (closeParenthesis < 0 || closeParenthesis > functionRange.closeBrace) {
+        throw new Error(`Unable to parse WGSL output constructor "${structName}"`);
+      }
+      insertions.push({ openParenthesis, closeParenthesis });
+    }
+    match = constructorPattern.exec(source4);
+  }
+  for (const insertion of insertions.sort((left, right) => right.closeParenthesis - left.closeParenthesis)) {
+    const existingArguments = source4.slice(insertion.openParenthesis + 1, insertion.closeParenthesis).trim();
+    const separator = existingArguments ? ", " : "";
+    source4 = source4.slice(0, insertion.closeParenthesis) + separator + varyingNames.join(", ") + source4.slice(insertion.closeParenthesis);
+  }
+  return source4;
+}
+function rewriteWGSLVertexReturns(source4, functionRange, varyingNames) {
+  const returns = findWGSLReturnStatements(source4, functionRange.openBrace + 1, functionRange.closeBrace);
+  for (let returnIndex = returns.length - 1; returnIndex >= 0; returnIndex--) {
+    const statement = returns[returnIndex];
+    const expression = source4.slice(statement.expressionStart, statement.semicolon).trim();
+    if (!expression) {
+      throw new Error("ShaderPlugin varying vertex entry point cannot use an empty return");
+    }
+    const outputName = `_luma_vertexOutput${returnIndex}`;
+    const assignments = varyingNames.map((name) => `${outputName}.${name} = ${name};`).join("\n");
+    const replacement = `{
+var ${outputName} = ${expression};
+${assignments}
+return ${outputName};
+}`;
+    source4 = source4.slice(0, statement.start) + replacement + source4.slice(statement.semicolon + 1);
+  }
+  return source4;
+}
+function findWGSLReturnStatements(source4, startIndex, endIndex) {
+  const statements = [];
+  let index = startIndex;
+  while (index < endIndex) {
+    index = skipWGSLTrivia(source4, index, endIndex);
+    if (source4.slice(index, index + 6) === "return" && !/[A-Za-z0-9_]/.test(source4[index + 6] || "")) {
+      const expressionStart = index + 6;
+      const semicolon = findStatementSemicolon(source4, expressionStart, endIndex);
+      if (semicolon < 0) {
+        throw new Error("Unable to parse WGSL return statement in selected vertex entry point");
+      }
+      statements.push({ start: index, expressionStart, semicolon });
+      index = semicolon + 1;
+    } else {
+      index++;
+    }
+  }
+  return statements;
+}
+function findStatementSemicolon(source4, startIndex, endIndex) {
+  let parenthesisDepth = 0;
+  let bracketDepth = 0;
+  for (let index = startIndex; index < endIndex; index++) {
+    const skippedIndex = skipWGSLTrivia(source4, index, endIndex);
+    if (skippedIndex !== index) {
+      index = skippedIndex - 1;
+      continue;
+    }
+    const character = source4[index];
+    if (character === "(")
+      parenthesisDepth++;
+    if (character === ")")
+      parenthesisDepth--;
+    if (character === "[")
+      bracketDepth++;
+    if (character === "]")
+      bracketDepth--;
+    if (character === ";" && parenthesisDepth === 0 && bracketDepth === 0)
+      return index;
+  }
+  return -1;
+}
+function skipWGSLTrivia(source4, startIndex, endIndex) {
+  let index = startIndex;
+  if (source4[index] === "/" && source4[index + 1] === "/") {
+    const newline = source4.indexOf("\n", index + 2);
+    return newline < 0 || newline > endIndex ? endIndex : newline + 1;
+  }
+  if (source4[index] === "/" && source4[index + 1] === "*") {
+    let depth = 1;
+    index += 2;
+    while (index < endIndex && depth > 0) {
+      if (source4[index] === "/" && source4[index + 1] === "*") {
+        depth++;
+        index += 2;
+      } else if (source4[index] === "*" && source4[index + 1] === "/") {
+        depth--;
+        index += 2;
+      } else {
+        index++;
+      }
+    }
+  }
+  return index;
+}
+function splitTopLevel(source4, delimiter) {
+  const parts = [];
+  let startIndex = 0;
+  let parenthesisDepth = 0;
+  let angleDepth = 0;
+  for (let index = 0; index < source4.length; index++) {
+    const character = source4[index];
+    if (character === "(")
+      parenthesisDepth++;
+    if (character === ")")
+      parenthesisDepth--;
+    if (character === "<")
+      angleDepth++;
+    if (character === ">")
+      angleDepth--;
+    if (character === delimiter && parenthesisDepth === 0 && angleDepth === 0) {
+      parts.push(source4.slice(startIndex, index));
+      startIndex = index + 1;
+    }
+  }
+  parts.push(source4.slice(startIndex));
+  return parts;
+}
+function getWGSLLocations2(source4) {
+  const locations = [];
+  const locationPattern = /@location\s*\(\s*(\d+)\s*\)/g;
+  let match = locationPattern.exec(source4);
+  while (match) {
+    locations.push(Number(match[1]));
+    match = locationPattern.exec(source4);
+  }
+  return locations;
+}
+function getWGSLDeclaredNames2(source4) {
+  const names = [];
+  const namePattern = /(?:^|,)\s*(?:@[A-Za-z_][\w]*(?:\([^)]*\))?\s*)*([A-Za-z_][\w]*)\s*:/gm;
+  let match = namePattern.exec(source4);
+  while (match) {
+    names.push(match[1]);
+    match = namePattern.exec(source4);
+  }
+  return names;
+}
+function hasWGSLModuleVariable2(source4, name) {
+  const variablePattern = new RegExp(`\\b(?:var(?:<[^>]+>)?|let|const)\\s+${escapeRegExp3(name)}\\b`, "g");
+  let match = variablePattern.exec(source4);
+  while (match) {
+    if (getBraceDepthAt2(source4, match.index) === 0) {
+      return true;
+    }
+    match = variablePattern.exec(source4);
+  }
+  return false;
+}
+function getFirstUnusedLocation2(usedLocations) {
+  let location = 0;
+  while (usedLocations.has(location))
+    location++;
+  return location;
+}
+function getGLSLZeroValue(type) {
+  const { primitiveType, components } = import_core3.shaderTypeDecoder.getAttributeShaderTypeInfo(type);
+  const scalar = primitiveType === "u32" ? "0u" : primitiveType === "i32" ? "0" : "0.0";
+  return components === 1 ? scalar : `${getGLSLAttributeType(type)}(${scalar})`;
+}
+function getWGSLZeroValue(type) {
+  const { primitiveType, components } = import_core3.shaderTypeDecoder.getAttributeShaderTypeInfo(type);
+  const scalar = `${primitiveType}(0)`;
+  return components === 1 ? scalar : `${type}(${scalar})`;
+}
+function assertGLSLVaryingIsNew(source4, name) {
+  const declaration = new RegExp(`\\b(?:flat\\s+|smooth\\s+)?(?:in|out|varying)\\s+(?:(?:lowp|mediump|highp)\\s+)?[A-Za-z_][A-Za-z0-9_]*\\s+${escapeRegExp3(name)}\\s*(?:\\[|;)`);
+  if (declaration.test(source4)) {
+    throw new Error(`ShaderPlugin varying "${name}" conflicts with existing GLSL stage I/O`);
+  }
+}
+function findMatchingDelimiter2(source4, openIndex, openCharacter, closeCharacter) {
+  let depth = 0;
+  let blockCommentDepth = 0;
+  let lineComment = false;
+  for (let index = openIndex; index < source4.length; index++) {
+    const character = source4[index];
+    const nextCharacter = source4[index + 1];
+    if (lineComment) {
+      if (character === "\n")
+        lineComment = false;
+      continue;
+    }
+    if (blockCommentDepth > 0) {
+      if (character === "/" && nextCharacter === "*") {
+        blockCommentDepth++;
+        index++;
+      } else if (character === "*" && nextCharacter === "/") {
+        blockCommentDepth--;
+        index++;
+      }
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index++;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockCommentDepth = 1;
+      index++;
+      continue;
+    }
+    if (character === openCharacter)
+      depth++;
+    if (character === closeCharacter && --depth === 0)
+      return index;
+  }
+  return -1;
+}
+function getBraceDepthAt2(source4, endIndex) {
+  let depth = 0;
+  for (let index = 0; index < endIndex; index++) {
+    const skippedIndex = skipWGSLTrivia(source4, index, endIndex);
+    if (skippedIndex !== index) {
+      index = skippedIndex - 1;
+      continue;
+    }
+    if (source4[index] === "{")
+      depth++;
+    if (source4[index] === "}")
+      depth--;
+  }
+  return depth;
+}
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// dist/lib/shader-assembly/assemble-shaders.js
+var INJECT_SHADER_DECLARATIONS = `
+
+${DECLARATION_INJECT_MARKER}
+`;
+var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
+var FRAGMENT_SHADER_PROLOGUE = (
+  /* glsl */
+  `precision highp float;
+`
+);
+function assembleWGSLShader(options) {
+  const modules = getShaderModuleDependencies(options.modules || []);
+  const { source: source4, bindingAssignments } = assembleShaderWGSL(options.platformInfo, {
+    ...options,
+    source: options.source,
+    stage: "vertex",
+    modules
+  });
+  return {
+    source: source4,
+    getUniforms: assembleGetUniforms(modules),
+    bindingAssignments,
+    bindingTable: getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments)
+  };
+}
+function assembleGLSLShaderPair(options) {
+  const { vs: vs4, fs: fs5 } = options;
+  const modules = getShaderModuleDependencies(options.modules || []);
+  return {
+    vs: assembleShaderGLSL(options.platformInfo, {
+      ...options,
+      source: vs4,
+      stage: "vertex",
+      modules
+    }),
+    fs: assembleShaderGLSL(options.platformInfo, {
+      ...options,
+      // @ts-expect-error
+      source: fs5,
+      stage: "fragment",
+      modules
+    }),
+    getUniforms: assembleGetUniforms(modules)
+  };
+}
+function assembleShaderWGSL(platformInfo, options) {
+  const {
+    // id,
+    source: source4,
+    stage,
+    modules,
+    // defines = {},
+    defines = {},
+    hookFunctions = [],
+    inject = {},
+    pluginInjections = {},
+    pluginVertexInputs = {},
+    pluginVaryings = {},
+    vertexEntryPoint = "vertexMain",
+    fragmentEntryPoint = "fragmentMain",
+    log: log2
+  } = options;
+  assert(typeof source4 === "string", "shader source must be a string");
+  const preprocessedSource = preprocess(source4, { defines });
+  const pluginVertexInputAssembly = assembleShaderPluginVertexInputsWGSL(preprocessedSource, vertexEntryPoint, pluginVertexInputs);
+  const pluginVaryingAssembly = assembleShaderPluginVaryingsWGSL(pluginVertexInputAssembly.source, vertexEntryPoint, fragmentEntryPoint, pluginVaryings);
+  const coreSource = pluginVaryingAssembly.source;
+  let assembledSource = "";
+  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+  const hookInjections = {};
+  const declInjections = {};
+  const mainInjections = {};
+  appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
+  for (const key in inject) {
+    const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
+    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
+    if (match) {
+      const hash = match[2];
+      const name = match[3];
+      if (hash) {
+        if (name === "decl") {
+          declInjections[key] = [injection];
+        } else {
+          mainInjections[key] = [injection];
+        }
+      } else {
+        hookInjections[key] = [injection];
+      }
+    } else {
+      mainInjections[key] = [injection];
+    }
+  }
+  appendGeneratedVertexInputInjections(pluginVertexInputAssembly.declarations, pluginVertexInputAssembly.initialization, declInjections, mainInjections);
+  appendGeneratedVaryingInjections(pluginVaryingAssembly, declInjections, mainInjections);
+  const modulesToInject = modules;
+  const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(applicationRelocation.source);
+  const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup, defines);
+  const bindingAssignments = [];
+  for (const module2 of modulesToInject) {
+    if (log2) {
+      checkShaderModuleDeprecations(module2, coreSource, log2);
+    }
+    const preprocessedModuleSource = preprocess(getShaderModuleSource(module2, "wgsl", log2), {
+      defines
+    });
+    const relocation = relocateWGSLModuleBindings(preprocessedModuleSource, module2, {
+      usedBindingsByGroup,
+      bindingRegistry: options._bindingRegistry,
+      reservedBindingKeysByGroup
+    });
+    bindingAssignments.push(...relocation.bindingAssignments);
+    const relocatedModuleSource = relocation.source;
+    assembledSource += relocatedModuleSource;
+    const injections = getWGSLModuleInjections(module2);
+    for (const key in injections) {
+      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
+      if (match) {
+        const name = match[2];
+        const injectionType = name === "decl" ? declInjections : mainInjections;
+        injectionType[key] = injectionType[key] || [];
+        injectionType[key].push(injections[key]);
+      } else {
+        hookInjections[key] = hookInjections[key] || [];
+        hookInjections[key].push(injections[key]);
+      }
+    }
+  }
+  assembledSource += INJECT_SHADER_DECLARATIONS;
+  assembledSource = injectShader(assembledSource, stage, getWGSLDeclarationInjections(declInjections), false, "wgsl", { vertex: vertexEntryPoint, fragment: fragmentEntryPoint });
+  assembledSource += getWGSLShaderHooks(hookFunctionMap, hookInjections);
+  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
+  assembledSource += applicationRelocation.source;
+  assembledSource = injectShader(assembledSource, stage, mainInjections, false, "wgsl", {
+    vertex: vertexEntryPoint,
+    fragment: fragmentEntryPoint
+  });
+  assertNoUnresolvedAutoBindings(assembledSource);
+  return { source: assembledSource, bindingAssignments };
+}
+function assembleShaderGLSL(platformInfo, options) {
+  var _a;
+  const { source: source4, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, pluginInjections = {}, pluginVertexInputs = {}, pluginVaryings = {}, prologue = true, log: log2 } = options;
+  assert(typeof source4 === "string", "shader source must be a string");
+  const sourceVersion = language === "glsl" ? getShaderInfo(source4).version : -1;
+  const targetVersion = platformInfo.shaderLanguageVersion;
+  const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
+  const sourceLines = source4.split("\n");
+  const coreSource = sourceLines.slice(1).join("\n");
+  const allDefines = {};
   modules.forEach((module2) => {
     Object.assign(allDefines, module2.defines);
   });
@@ -1214,6 +2078,7 @@ ${getApplicationDefines(allDefines)}
   const hookInjections = {};
   const declInjections = {};
   const mainInjections = {};
+  appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
   for (const key in inject) {
     const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
     const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
@@ -1233,6 +2098,32 @@ ${getApplicationDefines(allDefines)}
       mainInjections[key] = [injection];
     }
   }
+  if (stage === "vertex") {
+    const declarations = getShaderPluginVertexInputDeclarationsGLSL(coreSource, pluginVertexInputs);
+    if (declarations) {
+      declInjections["vs:#decl"] = declInjections["vs:#decl"] || [];
+      declInjections["vs:#decl"].push({
+        injection: declarations,
+        order: Number.MIN_SAFE_INTEGER
+      });
+    }
+  }
+  const pluginVaryingAssembly = assembleShaderPluginVaryingsGLSL(coreSource, stage, pluginVaryings);
+  if (pluginVaryingAssembly.declarations) {
+    const declarationTarget = stage === "vertex" ? "vs:#decl" : "fs:#decl";
+    declInjections[declarationTarget] = declInjections[declarationTarget] || [];
+    declInjections[declarationTarget].push({
+      injection: pluginVaryingAssembly.declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (pluginVaryingAssembly.initialization) {
+    mainInjections["vs:#main-start"] = mainInjections["vs:#main-start"] || [];
+    mainInjections["vs:#main-start"].push({
+      injection: pluginVaryingAssembly.initialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
   for (const module2 of modules) {
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
@@ -1278,23 +2169,94 @@ function assembleGetUniforms(modules) {
     return uniforms;
   };
 }
-function getApplicationDefines(defines = {}) {
-  let sourceText = "";
-  for (const define in defines) {
-    const value = defines[define];
-    if (value || Number.isFinite(value)) {
-      sourceText += `#define ${define.toUpperCase()} ${defines[define]}
-`;
+function appendInjections(injections, hookInjections, declInjections, mainInjections) {
+  for (const key in injections) {
+    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
+    if (match) {
+      const hash = match[2];
+      const name = match[3];
+      const injectionType = hash ? name === "decl" ? declInjections : mainInjections : hookInjections;
+      injectionType[key] = injectionType[key] || [];
+      injectionType[key].push(...injections[key]);
+    } else {
+      mainInjections[key] = mainInjections[key] || [];
+      mainInjections[key].push(...injections[key]);
     }
   }
-  return sourceText;
 }
-function getShaderModuleSource(module2, stage, log2) {
-  let moduleSource;
-  switch (stage) {
-    case "vertex":
-      moduleSource = module2.vs || "";
-      break;
+function appendGeneratedVertexInputInjections(declarations, initialization, declarationInjections, mainInjections) {
+  if (declarations) {
+    declarationInjections["vs:#decl"] = declarationInjections["vs:#decl"] || [];
+    declarationInjections["vs:#decl"].push({
+      injection: declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (initialization) {
+    mainInjections["vs:#main-start"] = mainInjections["vs:#main-start"] || [];
+    mainInjections["vs:#main-start"].push({
+      injection: initialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+}
+function appendGeneratedVaryingInjections(assembly, declarationInjections, mainInjections) {
+  if (assembly.declarations) {
+    declarationInjections["vs:#decl"] = declarationInjections["vs:#decl"] || [];
+    declarationInjections["vs:#decl"].push({
+      injection: assembly.declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (assembly.vertexInitialization) {
+    mainInjections["vs:#main-start"] = mainInjections["vs:#main-start"] || [];
+    mainInjections["vs:#main-start"].push({
+      injection: assembly.vertexInitialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (assembly.fragmentInitialization) {
+    mainInjections["fs:#main-start"] = mainInjections["fs:#main-start"] || [];
+    mainInjections["fs:#main-start"].push({
+      injection: assembly.fragmentInitialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+}
+function getWGSLModuleInjections(module2) {
+  var _a, _b;
+  return {
+    ...((_a = module2.instance) == null ? void 0 : _a.normalizedInjections.vertex) || {},
+    ...((_b = module2.instance) == null ? void 0 : _b.normalizedInjections.fragment) || {}
+  };
+}
+function getWGSLDeclarationInjections(declarationInjections) {
+  const unifiedDeclarations = [
+    ...declarationInjections["vs:#decl"] || [],
+    ...declarationInjections["fs:#decl"] || []
+  ];
+  return unifiedDeclarations.length ? { "vs:#decl": unifiedDeclarations } : {};
+}
+function getWGSLShaderHooks(hookFunctionMap, hookInjections) {
+  return getShaderHooks(hookFunctionMap.vertex, hookInjections, "wgsl") + getShaderHooks(hookFunctionMap.fragment, hookInjections, "wgsl");
+}
+function getApplicationDefines(defines = {}) {
+  let sourceText = "";
+  for (const define in defines) {
+    const value = defines[define];
+    if (value || Number.isFinite(value)) {
+      sourceText += `#define ${define.toUpperCase()} ${defines[define]}
+`;
+    }
+  }
+  return sourceText;
+}
+function getShaderModuleSource(module2, stage, log2) {
+  let moduleSource;
+  switch (stage) {
+    case "vertex":
+      moduleSource = module2.vs || "";
+      break;
     case "fragment":
       moduleSource = module2.fs || "";
       break;
@@ -1409,13 +2371,13 @@ function relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGro
   relocationState.sawSupportedBindingDeclaration = true;
   return match;
 }
-function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
+function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup, defines) {
   const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
   if (!bindingRegistry) {
     return reservedBindingKeysByGroup;
   }
   for (const module2 of modules) {
-    for (const binding of getModuleWGSLBindingDeclarations(module2)) {
+    for (const binding of getModuleWGSLBindingDeclarations(module2, defines)) {
       const registryKey = getBindingRegistryKey(binding.group, module2.name, binding.name);
       const location = bindingRegistry.get(registryKey);
       if (location !== void 0) {
@@ -1446,9 +2408,9 @@ function claimReservedBindingLocation(reservedBindingKeysByGroup, group, locatio
   }
   return true;
 }
-function getModuleWGSLBindingDeclarations(module2) {
+function getModuleWGSLBindingDeclarations(module2, defines) {
   const declarations = [];
-  const moduleSource = module2.source || "";
+  const moduleSource = preprocess(module2.source || "", { defines });
   for (const match of getWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES)) {
     declarations.push({
       name: match.name,
@@ -1539,53 +2501,6 @@ function formatWGSLSourceSnippet(source4) {
   return source4.replace(/\s+/g, " ").trim();
 }
 
-// dist/lib/preprocessor/preprocessor.js
-var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
-var IFDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*$`);
-var IFNDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifndef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
-var ELSE_REGEXP = /^\s*\#\s*else\s*(?:\/\/.*)?$/;
-var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
-var IFDEF_WITH_COMMENT_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
-var ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
-function preprocess(source4, options) {
-  var _a, _b;
-  const lines = source4.split("\n");
-  const output = [];
-  const conditionalStack = [];
-  let conditional = true;
-  for (const line of lines) {
-    const matchIf = line.match(IFDEF_WITH_COMMENT_REGEXP) || line.match(IFDEF_REGEXP);
-    const matchIfNot = line.match(IFNDEF_REGEXP);
-    const matchElse = line.match(ELSE_REGEXP);
-    const matchEnd = line.match(ENDIF_WITH_COMMENT_REGEXP) || line.match(ENDIF_REGEXP);
-    if (matchIf || matchIfNot) {
-      const defineName = (_a = matchIf || matchIfNot) == null ? void 0 : _a[1];
-      const defineValue = Boolean((_b = options == null ? void 0 : options.defines) == null ? void 0 : _b[defineName]);
-      const branchTaken = matchIf ? defineValue : !defineValue;
-      const active = conditional && branchTaken;
-      conditionalStack.push({ parentActive: conditional, branchTaken, active });
-      conditional = active;
-    } else if (matchElse) {
-      const currentConditional = conditionalStack[conditionalStack.length - 1];
-      if (!currentConditional) {
-        throw new Error("Encountered #else without matching #ifdef or #ifndef");
-      }
-      currentConditional.active = currentConditional.parentActive && !currentConditional.branchTaken;
-      currentConditional.branchTaken = true;
-      conditional = currentConditional.active;
-    } else if (matchEnd) {
-      conditionalStack.pop();
-      conditional = conditionalStack.length ? conditionalStack[conditionalStack.length - 1].active : true;
-    } else if (conditional) {
-      output.push(line);
-    }
-  }
-  if (conditionalStack.length > 0) {
-    throw new Error("Unterminated conditional block in shader source");
-  }
-  return output.join("\n");
-}
-
 // dist/lib/shader-assembler.js
 var _ShaderAssembler = class {
   /** Hook functions */
@@ -1596,14 +2511,15 @@ var _ShaderAssembler = class {
   _wgslBindingRegistry = /* @__PURE__ */ new Map();
   /**
    * A default shader assembler instance - the natural place to register default modules and hooks
-   * @returns
+   * @returns Shared default shader assembler.
    */
   static getDefaultShaderAssembler() {
     _ShaderAssembler.defaultShaderAssembler = _ShaderAssembler.defaultShaderAssembler || new _ShaderAssembler();
     return _ShaderAssembler.defaultShaderAssembler;
   }
   /**
-   * Add a default module that does not have to be provided with every call to assembleShaders()
+   * Add a default module that does not have to be provided with every assembly call.
+   * @param module Shader module to include in later assembly calls.
    */
   addDefaultModule(module2) {
     if (!this._defaultModules.find((m) => m.name === (typeof module2 === "string" ? module2 : module2.name))) {
@@ -1612,6 +2528,7 @@ var _ShaderAssembler = class {
   }
   /**
    * Remove a default module
+   * @param module Shader module to remove from later assembly calls.
    */
   removeDefaultModule(module2) {
     const moduleName = typeof module2 === "string" ? module2 : module2.name;
@@ -1619,8 +2536,8 @@ var _ShaderAssembler = class {
   }
   /**
    * Register a shader hook
-   * @param hook
-   * @param opts
+   * @param hook Stage-prefixed hook signature, such as `vs:OFFSET_POSITION(inout vec4 position)`.
+   * @param opts Optional hook metadata such as always-on header and footer source.
    */
   addShaderHook(hook, opts) {
     if (opts) {
@@ -1630,29 +2547,24 @@ var _ShaderAssembler = class {
   }
   /**
    * Assemble a WGSL unified shader
-   * @param platformInfo
-   * @param props
-   * @returns
+   * @param props WGSL source, platform information, shader modules, defines, and injections.
+   * @returns Assembled WGSL source, resolved modules, uniforms, and binding debug metadata.
    */
   assembleWGSLShader(props) {
     const modules = this._getModuleList(props.modules);
     const hookFunctions = this._hookFunctions;
-    const { source: source4, getUniforms: getUniforms4, bindingAssignments } = assembleWGSLShader({
+    const defines = getShaderPreprocessorDefines(props, modules);
+    const preprocessedApplicationSource = props.platformInfo.shaderLanguage === "wgsl" && props.source ? preprocess(props.source, { defines }) : props.source;
+    const { source: assembledSource, getUniforms: getUniforms4, bindingAssignments } = assembleWGSLShader({
       ...props,
       // @ts-expect-error
-      source: props.source,
+      source: preprocessedApplicationSource,
+      defines,
       _bindingRegistry: this._wgslBindingRegistry,
       modules,
       hookFunctions
     });
-    const defines = {
-      ...modules.reduce((accumulator, module2) => {
-        Object.assign(accumulator, module2.defines);
-        return accumulator;
-      }, {}),
-      ...props.defines
-    };
-    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source4, { defines }) : source4;
+    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(assembledSource, { defines }) : assembledSource;
     return {
       source: preprocessedSource,
       getUniforms: getUniforms4,
@@ -1663,9 +2575,8 @@ var _ShaderAssembler = class {
   }
   /**
    * Assemble a pair of shaders into a single shader program
-   * @param platformInfo
-   * @param props
-   * @returns
+   * @param props GLSL vertex and fragment source, platform information, shader modules, defines, and injections.
+   * @returns Assembled GLSL source, resolved modules, and combined uniform getter.
    */
   assembleGLSLShaderPair(props) {
     const modules = this._getModuleList(props.modules);
@@ -1710,6 +2621,22 @@ var _ShaderAssembler = class {
 var ShaderAssembler = _ShaderAssembler;
 /** Default ShaderAssembler instance */
 __publicField(ShaderAssembler, "defaultShaderAssembler");
+function getShaderPreprocessorDefines(props, modules) {
+  return {
+    ...getPlatformPreprocessorDefines(props.platformInfo),
+    ...modules.reduce((accumulator, module2) => {
+      Object.assign(accumulator, module2.defines);
+      return accumulator;
+    }, {}),
+    ...props.defines
+  };
+}
+function getPlatformPreprocessorDefines(platformInfo) {
+  const limits = platformInfo.limits || {};
+  return {
+    LUMA_SUPPORTS_VERTEX_STORAGE_BUFFERS: platformInfo.type === "webgpu" && (limits["maxStorageBuffersInVertexStage"] || 0) > 0
+  };
+}
 
 // dist/lib/glsl-utils/shader-utils.js
 var FS_GLES = (
@@ -1909,14 +2836,14 @@ function generateShaderForModule(module2, options) {
 }
 
 // dist/modules/math/fp16/fp16-utils.js
-var import_core = require("@math.gl/core");
+var import_core4 = require("@math.gl/core");
 var float16Tables = null;
 var buffer = new ArrayBuffer(4);
 var floatView = new Float32Array(buffer);
 var uint32View = new Uint32Array(buffer);
 function toHalfFloat(val) {
   float16Tables ||= generateFloat16Tables();
-  val = (0, import_core.clamp)(val, -65504, 65504);
+  val = (0, import_core4.clamp)(val, -65504, 65504);
   floatView[0] = val;
   const f = uint32View[0];
   const e = f >> 23 & 511;
@@ -2435,11 +3362,278 @@ var fp64arithmeticWGSL = (
 
 @group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
 
+struct Fp64Bits {
+  sign: u32,
+  exponent: i32,
+  significand: vec2u,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
 fn fp64_nan(seed: f32) -> f32 {
   let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
   return bitcast<f32>(nanBits);
 }
 
+fn fp64_u64_is_zero(value: vec2u) -> bool {
+  return value.x == 0u && value.y == 0u;
+}
+
+fn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {
+  if (a.x != b.x) {
+    return select(-1, 1, a.x > b.x);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {
+  let low = a.y + b.y;
+  let carry = select(0u, 1u, low < a.y);
+  return vec2u(a.x + b.x + carry, low);
+}
+
+fn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {
+  let borrow = select(0u, 1u, a.y < b.y);
+  return vec2u(a.x - b.x - borrow, a.y - b.y);
+}
+
+fn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);
+  }
+  if (shift == 32u) {
+    return vec2u(value.y, 0u);
+  }
+  if (shift < 64u) {
+    return vec2u(value.y << (shift - 32u), 0u);
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));
+  }
+  if (shift == 32u) {
+    return vec2u(0u, value.x);
+  }
+  if (shift < 64u) {
+    return vec2u(0u, value.x >> (shift - 32u));
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {
+  if (bitIndex >= 64u) {
+    return false;
+  }
+  if (bitIndex >= 32u) {
+    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;
+  }
+  return ((value.y >> bitIndex) & 1u) != 0u;
+}
+
+fn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {
+  if (bitCount == 0u) {
+    return false;
+  }
+  if (bitCount >= 64u) {
+    return !fp64_u64_is_zero(value);
+  }
+  if (bitCount > 32u) {
+    let highBitCount = bitCount - 32u;
+    let highMask = (1u << highBitCount) - 1u;
+    return value.y != 0u || (value.x & highMask) != 0u;
+  }
+  if (bitCount == 32u) {
+    return value.y != 0u;
+  }
+  let lowMask = (1u << bitCount) - 1u;
+  return (value.y & lowMask) != 0u;
+}
+
+fn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {
+  var shifted = fp64_u64_shift_right(value, shift);
+  if (fp64_u64_has_bits_below(value, shift)) {
+    shifted.y = shifted.y | 1u;
+  }
+  return shifted;
+}
+
+fn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {
+  if (value.x != 0u) {
+    return countLeadingZeros(value.x);
+  }
+  return 32u + countLeadingZeros(value.y);
+}
+
+fn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {
+  if (shift == 0u) {
+    return value.y;
+  }
+
+  let truncated = fp64_u64_shift_right(value, shift);
+  var rounded = truncated.y;
+  let guard = fp64_u64_get_bit(value, shift - 1u);
+  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);
+  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {
+    rounded = rounded + 1u;
+  }
+  return rounded;
+}
+
+fn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {
+  if (fp64_u64_is_zero(significand)) {
+    return sign << 31u;
+  }
+
+  let leadingZeros = fp64_u64_count_leading_zeros(significand);
+  let mostSignificantBit = 63u - leadingZeros;
+  var exponent = baseExponent + i32(mostSignificantBit);
+
+  if (exponent > 127) {
+    return (sign << 31u) | 0x7f800000u;
+  }
+
+  if (exponent >= -126) {
+    let shift = i32(mostSignificantBit) - 23;
+    var significand24: u32;
+    if (shift > 0) {
+      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));
+    } else {
+      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;
+    }
+
+    if (significand24 >= 0x1000000u) {
+      significand24 = significand24 >> 1u;
+      exponent = exponent + 1;
+      if (exponent > 127) {
+        return (sign << 31u) | 0x7f800000u;
+      }
+    }
+
+    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);
+  }
+
+  let scaleExponent = baseExponent + 149;
+  var mantissa: u32;
+  if (scaleExponent >= 0) {
+    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;
+  } else {
+    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));
+  }
+
+  if (mantissa >= 0x800000u) {
+    return (sign << 31u) | 0x00800000u;
+  }
+  return (sign << 31u) | mantissa;
+}
+
+fn fp64_decode_bits(bits: vec2u) -> Fp64Bits {
+  let sign = bits.x >> 31u;
+  let exponentBits = (bits.x >> 20u) & 0x7ffu;
+  let fractionHigh = bits.x & 0xfffffu;
+  let fractionLow = bits.y;
+  let fraction = vec2u(fractionHigh, fractionLow);
+
+  if (exponentBits == 0x7ffu) {
+    let isInf = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);
+  }
+
+  if (exponentBits == 0u) {
+    let isZero = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, -1022, fraction, isZero, false, false);
+  }
+
+  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);
+}
+
+fn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {
+  if (a.exponent != b.exponent) {
+    return select(-1, 1, a.exponent > b.exponent);
+  }
+  return fp64_u64_compare(a.significand, b.significand);
+}
+
+fn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+fn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+// Subtract two raw binary64 values and round the exact result once to f32.
+// The input words are canonical high/low words: .x contains sign/exponent/high
+// fraction bits, and .y contains the low 32 fraction bits.
+fn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {
+  let a = fp64_decode_bits(aBits);
+  let b = fp64_decode_bits(bBits);
+  let bSubtractionSign = b.sign ^ 1u;
+
+  if (a.isNan || b.isNan) {
+    return 0x7fc00000u;
+  }
+  if (a.isInf && b.isInf) {
+    if (a.sign == bSubtractionSign) {
+      return (a.sign << 31u) | 0x7f800000u;
+    }
+    return 0x7fc00000u;
+  }
+  if (a.isInf) {
+    return (a.sign << 31u) | 0x7f800000u;
+  }
+  if (b.isInf) {
+    return (bSubtractionSign << 31u) | 0x7f800000u;
+  }
+  if (a.isZero && b.isZero) {
+    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);
+  }
+
+  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);
+  if (a.sign == bSubtractionSign) {
+    if (magnitudeComparison >= 0) {
+      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+    }
+    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);
+  }
+
+  if (magnitudeComparison == 0) {
+    return 0u;
+  }
+  if (magnitudeComparison > 0) {
+    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+  }
+  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);
+}
+
+fn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {
+  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));
+}
+
 fn fp64_runtime_zero() -> f32 {
   return fp64arithmetic.ONE * 0.0;
 }
@@ -3342,59 +4536,2054 @@ var fp64 = {
   fp64ifyMatrix4
 };
 
-// dist/modules/color/float-colors.js
-var GLSL_UNIFORMS = (
-  /* glsl */
-  `layout(std140) uniform floatColorsUniforms {
+// dist/modules/geospatial/dggs/dggs-wgsl.js
+var dggsWGSL = (
+  /* wgsl */
+  `const DGGS_H3_CELL_MODE: u32 = 1u;
+const DGGS_H3_MAX_RESOLUTION: u32 = 15u;
+const DGGS_H3_MAX_BASE_CELL: u32 = 121u;
+const DGGS_H3_UNUSED_DIGIT: u32 = 7u;
+const DGGS_H3_RES0_U_GNOMONIC: f32 = 0.381966011250105;
+const DGGS_H3_RSQRT7: f32 = 0.3779644730092272;
+const DGGS_H3_ONETHIRD: f32 = 0.3333333333333333;
+const DGGS_H3_AP7_ROT_RADS: f32 = 0.3334731722518321;
+const DGGS_H3_SQRT3_2: f32 = 0.8660254037844386;
+const DGGS_S2_MAX_LEVEL: u32 = 30u;
+const DGGS_GEOHASH_MAX_LENGTH: u32 = 12u;
+const DGGS_GEOHASH_LENGTH_BIT_OFFSET: u32 = 60u;
+const DGGS_QUADKEY_MAX_LENGTH: u32 = 29u;
+const DGGS_QUADKEY_LENGTH_BIT_OFFSET: u32 = 58u;
+const DGGS_A5_FIRST_HILBERT_RESOLUTION: u32 = 2u;
+const DGGS_A5_MAX_RESOLUTION: u32 = 30u;
+const DGGS_A5_HILBERT_START_BIT: u32 = 58u;
+const DGGS_PI: f32 = 3.141592653589793;
+const DGGS_TWO_PI: f32 = 6.283185307179586;
+const DGGS_TWO_PI_OVER_5: f32 = 1.2566370614359172;
+const DGGS_PI_OVER_5: f32 = 0.6283185307179586;
+const DGGS_PI_OVER_2: f32 = 1.5707963267948966;
+const DGGS_A5_DISTANCE_TO_EDGE: f32 = 0.6180339887498949;
+const DGGS_A5_REFLECTED_TRIANGLE_SCALE: f32 = 3.23606797749979;
+const DGGS_A5_LONGITUDE_OFFSET: f32 = 93.0;
+const DGGS_RADIANS_TO_DEGREES: f32 = 57.29577951308232;
+const DGGS_DEGREES_TO_RADIANS: f32 = 0.017453292519943295;
+const DGGS_U64_HIGH_WORD_FLOAT_SCALE: f32 = 4294967296.0;
+
+// DGGS 64-bit helper functions use canonical word order vec2u(high, low).
+// Arrow BigInt64/BigUint64 buffers are read as little-endian vec2u(low, high),
+// so storage-buffer reads should pass through dggs_u64_from_little_endian_words().
+fn dggs_u64_make(high: u32, low: u32) -> vec2u {
+  return vec2u(high, low);
+}
+
+fn dggs_u64_from_little_endian_words(words: vec2u) -> vec2u {
+  return words.yx;
+}
+
+fn dggs_u64_to_little_endian_words(value: vec2u) -> vec2u {
+  return value.yx;
+}
+
+fn dggs_u64_high(value: vec2u) -> u32 {
+  return value.x;
+}
+
+fn dggs_u64_low(value: vec2u) -> u32 {
+  return value.y;
+}
+
+fn dggs_u64_is_zero(value: vec2u) -> bool {
+  return value.x == 0u && value.y == 0u;
+}
+
+fn dggs_u64_equal(a: vec2u, b: vec2u) -> bool {
+  return a.x == b.x && a.y == b.y;
+}
+
+fn dggs_u64_compare(a: vec2u, b: vec2u) -> i32 {
+  if (a.x != b.x) {
+    return select(-1, 1, a.x > b.x);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn dggs_u64_less(a: vec2u, b: vec2u) -> bool {
+  return dggs_u64_compare(a, b) < 0;
+}
+
+fn dggs_u64_add(a: vec2u, b: vec2u) -> vec2u {
+  let low = a.y + b.y;
+  let carry = select(0u, 1u, low < a.y);
+  return vec2u(a.x + b.x + carry, low);
+}
+
+fn dggs_u64_subtract(a: vec2u, b: vec2u) -> vec2u {
+  let borrow = select(0u, 1u, a.y < b.y);
+  return vec2u(a.x - b.x - borrow, a.y - b.y);
+}
+
+fn dggs_u64_to_f32(value: vec2u) -> f32 {
+  return f32(value.x) * DGGS_U64_HIGH_WORD_FLOAT_SCALE + f32(value.y);
+}
+
+fn dggs_i64_from_little_endian_words(words: vec2u) -> vec2u {
+  return dggs_u64_from_little_endian_words(words);
+}
+
+fn dggs_i64_to_little_endian_words(value: vec2u) -> vec2u {
+  return dggs_u64_to_little_endian_words(value);
+}
+
+fn dggs_i64_is_negative(value: vec2u) -> bool {
+  return (value.x & 0x80000000u) != 0u;
+}
+
+fn dggs_i64_negate(value: vec2u) -> vec2u {
+  return dggs_u64_add(vec2u(~value.x, ~value.y), vec2u(0u, 1u));
+}
+
+fn dggs_i64_compare(a: vec2u, b: vec2u) -> i32 {
+  let highA = bitcast<i32>(a.x);
+  let highB = bitcast<i32>(b.x);
+  if (highA != highB) {
+    return select(-1, 1, highA > highB);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn dggs_i64_less(a: vec2u, b: vec2u) -> bool {
+  return dggs_i64_compare(a, b) < 0;
+}
+
+fn dggs_i64_subtract(a: vec2u, b: vec2u) -> vec2u {
+  return dggs_u64_subtract(a, b);
+}
+
+fn dggs_i64_to_f32(value: vec2u) -> f32 {
+  if (dggs_i64_is_negative(value)) {
+    return -dggs_u64_to_f32(dggs_i64_negate(value));
+  }
+  return dggs_u64_to_f32(value);
+}
+
+fn dggs_u32_mask_low(bitCount: u32) -> u32 {
+  if (bitCount == 0u) {
+    return 0u;
+  }
+  if (bitCount >= 32u) {
+    return 0xffffffffu;
+  }
+  return (1u << bitCount) - 1u;
+}
+
+fn dggs_u64_shift_left(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);
+  }
+  if (shift == 32u) {
+    return vec2u(value.y, 0u);
+  }
+  if (shift < 64u) {
+    return vec2u(value.y << (shift - 32u), 0u);
+  }
+  return vec2u(0u);
+}
+
+fn dggs_u64_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));
+  }
+  if (shift == 32u) {
+    return vec2u(0u, value.x);
+  }
+  if (shift < 64u) {
+    return vec2u(0u, value.x >> (shift - 32u));
+  }
+  return vec2u(0u);
+}
+
+fn dggs_u64_extract_bits(value: vec2u, bitOffset: u32, bitCount: u32) -> u32 {
+  if (bitCount == 0u || bitOffset >= 64u) {
+    return 0u;
+  }
+  let shifted = dggs_u64_shift_right(value, bitOffset);
+  return shifted.y & dggs_u32_mask_low(bitCount);
+}
+
+fn dggs_u64_set_bits(value: vec2u, bitOffset: u32, bitCount: u32, bits: u32) -> vec2u {
+  if (bitCount == 0u || bitOffset >= 64u) {
+    return value;
+  }
+  let bitMask = dggs_u32_mask_low(bitCount);
+  let fieldMask = dggs_u64_shift_left(vec2u(0u, bitMask), bitOffset);
+  let fieldBits = dggs_u64_shift_left(vec2u(0u, bits & bitMask), bitOffset);
+  return (value & vec2u(~fieldMask.x, ~fieldMask.y)) | fieldBits;
+}
+
+fn dggs_u64_count_trailing_zeros(value: vec2u) -> u32 {
+  if (value.y != 0u) {
+    return countTrailingZeros(value.y);
+  }
+  if (value.x != 0u) {
+    return 32u + countTrailingZeros(value.x);
+  }
+  return 64u;
+}
+
+struct DggsA5Cell {
+  origin : u32,
+  segment : u32,
+  resolution : u32,
+  valid : u32,
+  quintantShift : u32,
+  hilbertResolution : u32,
+};
+
+struct DggsA5Anchor {
+  q : u32,
+  offset : vec2i,
+  flips : vec2i,
+  orientation : u32,
+  quintant : u32,
+};
+
+struct DggsA5FaceTriangle {
+  a : vec2f,
+  b : vec2f,
+  c : vec2f,
+};
+
+struct DggsA5SphericalTriangle {
+  a : vec3f,
+  b : vec3f,
+  c : vec3f,
+};
+
+struct DggsH3FaceIJK {
+  face : u32,
+  coord : vec3i,
+  valid : u32,
+};
+
+struct DggsH3BoundaryVertex {
+  face : u32,
+  coord : vec3i,
+  resolution : u32,
+  valid : u32,
+};
+
+fn dggs_boundary_point_to_fp64_split(point : vec2f) -> vec4f {
+  return vec4f(point.x, point.y, 0.0, 0.0);
+}
+
+fn dggs_a5_positive_mod_i32(value : i32, modulus : i32) -> i32 {
+  return ((value % modulus) + modulus) % modulus;
+}
+
+fn dggs_a5_has_bit(index : vec2u, bitOffset : u32) -> bool {
+  return dggs_u64_extract_bits(index, bitOffset, 1u) != 0u;
+}
+
+fn dggs_a5_get_resolution(index : vec2u) -> u32 {
+  if (dggs_u64_is_zero(index)) {
+    return 0u;
+  }
+  if (
+    dggs_a5_has_bit(index, 0u) ||
+    dggs_u64_extract_bits(index, 0u, 3u) == 4u ||
+    dggs_u64_extract_bits(index, 0u, 5u) == 16u
+  ) {
+    return DGGS_A5_MAX_RESOLUTION;
+  }
+
+  var resolution = DGGS_A5_MAX_RESOLUTION - 1u;
+  var shifted = dggs_u64_shift_right(index, 1u);
+  if (dggs_u64_is_zero(shifted)) {
+    return 0u;
+  }
+
+  var remaining = shifted.y;
+  if (remaining == 0u) {
+    shifted = dggs_u64_shift_right(shifted, 32u);
+    resolution -= 16u;
+    remaining = shifted.y;
+  }
+  if ((remaining & 0xffffu) == 0u) {
+    remaining >>= 16u;
+    resolution -= 8u;
+  }
+  if (resolution >= 6u && (remaining & 0xffu) == 0u) {
+    remaining >>= 8u;
+    resolution -= 4u;
+  }
+  if (resolution >= 4u && (remaining & 0xfu) == 0u) {
+    remaining >>= 4u;
+    resolution -= 2u;
+  }
+  loop {
+    if ((remaining & 1u) != 0u) {
+      break;
+    }
+    if (resolution == 0u) {
+      break;
+    }
+    resolution -= 1u;
+    remaining >>= select(2u, 1u, resolution < DGGS_A5_FIRST_HILBERT_RESOLUTION);
+  }
+  return resolution;
+}
+
+fn dggs_a5_get_origin_first_quintant(origin : u32) -> u32 {
+  let values = array<u32, 12>(
+    4u, 2u, 3u, 0u, 2u, 4u, 2u, 2u, 3u, 0u, 3u, 0u
+  );
+  return values[min(origin, 11u)];
+}
+
+fn dggs_a5_get_origin_step(origin : u32) -> i32 {
+  let values = array<i32, 12>(
+    -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1
+  );
+  return values[min(origin, 11u)];
+}
+
+fn dggs_a5_get_origin_orientation(origin : u32, faceRelativeQuintant : u32) -> u32 {
+  // Orientation codes: uv=0, vu=1, uw=2, wu=3, vw=4, wv=5.
+  let values = array<u32, 60>(
+    1u, 2u, 4u, 4u, 4u,
+    1u, 0u, 5u, 3u, 2u,
+    3u, 0u, 5u, 3u, 2u,
+    3u, 0u, 5u, 3u, 2u,
+    3u, 2u, 4u, 1u, 2u,
+    1u, 0u, 5u, 3u, 2u,
+    3u, 2u, 4u, 1u, 2u,
+    3u, 2u, 4u, 1u, 2u,
+    3u, 0u, 5u, 3u, 2u,
+    1u, 0u, 5u, 3u, 2u,
+    1u, 0u, 5u, 3u, 2u,
+    3u, 2u, 4u, 1u, 2u
+  );
+  return values[min(origin, 11u) * 5u + min(faceRelativeQuintant, 4u)];
+}
+
+fn dggs_a5_get_origin_angle(origin : u32) -> f32 {
+  if (origin == 0u || origin == 9u) {
+    return 0.0;
+  }
+  return DGGS_PI_OVER_5;
+}
+
+fn dggs_a5_get_origin_quaternion(origin : u32) -> vec4f {
+  let values = array<vec4f, 12>(
+    vec4f(0.0, 0.0, 0.0, 1.0),
+    vec4f(0.0, 0.525731112119, 0.0, 0.850650808352),
+    vec4f(-0.5, 0.688190960236, 0.0, 0.525731112119),
+    vec4f(-0.809016994375, -0.262865556060, 0.0, 0.525731112119),
+    vec4f(-0.5, 0.162459848116, 0.0, 0.850650808352),
+    vec4f(-0.309016994375, -0.425325404176, 0.0, 0.850650808352),
+    vec4f(0.309016994375, -0.425325404176, 0.0, 0.850650808352),
+    vec4f(0.809016994375, -0.262865556060, 0.0, 0.525731112119),
+    vec4f(0.0, -0.850650808352, 0.0, 0.525731112119),
+    vec4f(0.0, -1.0, 0.0, 0.0),
+    vec4f(0.5, 0.688190960236, 0.0, 0.525731112119),
+    vec4f(0.5, 0.162459848116, 0.0, 0.850650808352)
+  );
+  return values[min(origin, 11u)];
+}
+
+fn dggs_a5_quaternion_rotate(point : vec3f, quaternion : vec4f) -> vec3f {
+  let q = quaternion.xyz;
+  let t = 2.0 * cross(q, point);
+  return point + quaternion.w * t + cross(q, t);
+}
+
+fn dggs_a5_deserialize(index : vec2u) -> DggsA5Cell {
+  if (dggs_u64_is_zero(index)) {
+    return DggsA5Cell(0u, 0u, 0u, 0u, DGGS_A5_HILBERT_START_BIT, 0u);
+  }
+
+  let resolution = dggs_a5_get_resolution(index);
+  var quintantShift = DGGS_A5_HILBERT_START_BIT;
+  var quintantOffset = 0u;
+  if (resolution == DGGS_A5_MAX_RESOLUTION) {
+    var markerBits = 5u;
+    if (dggs_a5_has_bit(index, 0u)) {
+      markerBits = 1u;
+    } else if (dggs_a5_has_bit(index, 2u)) {
+      markerBits = 3u;
+    }
+    quintantShift = DGGS_A5_HILBERT_START_BIT + markerBits;
+    quintantOffset = select(select(40u, 32u, markerBits == 3u), 0u, markerBits == 1u);
+  }
+
+  let topBits = dggs_u64_shift_right(index, quintantShift).y + quintantOffset;
+  if (resolution == 0u) {
+    if (topBits >= 12u) {
+      return DggsA5Cell(0u, 0u, resolution, 0u, quintantShift, 0u);
+    }
+    return DggsA5Cell(topBits, 0u, resolution, 1u, quintantShift, 0u);
+  }
+
+  let origin = topBits / 5u;
+  if (origin >= 12u) {
+    return DggsA5Cell(0u, 0u, resolution, 0u, quintantShift, 0u);
+  }
+  let segment = (topBits + dggs_a5_get_origin_first_quintant(origin)) % 5u;
+  let hilbertResolution = select(0u, resolution - 1u, resolution >= 2u);
+  return DggsA5Cell(origin, segment, resolution, 1u, quintantShift, hilbertResolution);
+}
+
+fn dggs_a5_segment_to_anchor_info(cell : DggsA5Cell) -> DggsA5Anchor {
+  let firstQuintant = dggs_a5_get_origin_first_quintant(cell.origin);
+  let faceRelativeQuintant = (cell.segment + 5u - firstQuintant) % 5u;
+  let orientation = dggs_a5_get_origin_orientation(cell.origin, faceRelativeQuintant);
+  let step = dggs_a5_get_origin_step(cell.origin);
+  let quintant = u32(dggs_a5_positive_mod_i32(
+    i32(firstQuintant) + step * i32(faceRelativeQuintant),
+    5
+  ));
+  return DggsA5Anchor(0u, vec2i(0), vec2i(1), orientation, quintant);
+}
+
+fn dggs_a5_is_reverse_orientation(orientation : u32) -> bool {
+  return orientation == 1u || orientation == 3u || orientation == 4u;
+}
+
+fn dggs_a5_is_invert_j_orientation(orientation : u32) -> bool {
+  return orientation == 5u || orientation == 4u;
+}
+
+fn dggs_a5_is_flip_ij_orientation(orientation : u32) -> bool {
+  return orientation == 3u || orientation == 2u;
+}
+
+fn dggs_a5_pattern_value(index : u32, flipIj : bool) -> u32 {
+  let pattern = array<u32, 8>(0u, 1u, 3u, 4u, 5u, 6u, 7u, 2u);
+  let flippedPattern = array<u32, 8>(0u, 1u, 2u, 7u, 3u, 4u, 5u, 6u);
+  return select(pattern[min(index, 7u)], flippedPattern[min(index, 7u)], flipIj);
+}
+
+fn dggs_a5_quaternary_to_flips(digit : u32) -> vec2i {
+  if (digit == 1u) {
+    return vec2i(1, -1);
+  }
+  if (digit == 3u) {
+    return vec2i(-1, 1);
+  }
+  return vec2i(1, 1);
+}
+
+fn dggs_a5_quaternary_to_kj(digit : u32, flips : vec2i) -> vec2i {
+  var p = vec2i(0);
+  var q = vec2i(0);
+  if (flips.x == 1 && flips.y == 1) {
+    p = vec2i(1, 0);
+    q = vec2i(0, 1);
+  } else if (flips.x == -1 && flips.y == 1) {
+    p = vec2i(0, -1);
+    q = vec2i(-1, 0);
+  } else if (flips.x == 1 && flips.y == -1) {
+    p = vec2i(0, 1);
+    q = vec2i(1, 0);
+  } else {
+    p = vec2i(-1, 0);
+    q = vec2i(0, -1);
+  }
+
+  if (digit == 1u) {
+    return p;
+  }
+  if (digit == 2u) {
+    return p + q;
+  }
+  if (digit == 3u) {
+    return q + 2 * p;
+  }
+  return vec2i(0);
+}
+
+fn dggs_a5_kj_to_ij(kj : vec2i) -> vec2i {
+  return vec2i(kj.x - kj.y, kj.y);
+}
+
+fn dggs_a5_shift_digits(
+  digits : ptr<function, array<u32, 29>>,
+  digitIndex : u32,
+  flips : vec2i,
+  invertJ : bool,
+  flipIj : bool
+) {
+  if (digitIndex == 0u) {
+    return;
+  }
+  let parentK = (*digits)[digitIndex];
+  let childK = (*digits)[digitIndex - 1u];
+  let flipSum = flips.x + flips.y;
+  var needsShift = true;
+  var first = true;
+  if (invertJ != (flipSum == 0)) {
+    needsShift = parentK == 1u || parentK == 2u;
+    first = parentK == 1u;
+  } else {
+    needsShift = parentK < 2u;
+    first = parentK == 0u;
+  }
+  if (!needsShift) {
+    return;
+  }
+  let source = select(childK + 4u, childK, first);
+  let destination = dggs_a5_pattern_value(source, flipIj);
+  (*digits)[digitIndex - 1u] = destination % 4u;
+  (*digits)[digitIndex] = u32(dggs_a5_positive_mod_i32(
+    i32(parentK) + 4 + i32(destination / 4u) - i32(source / 4u),
+    4
+  ));
+}
+
+fn dggs_a5_make_anchor(index : vec2u, cell : DggsA5Cell, anchorInfo : DggsA5Anchor) -> DggsA5Anchor {
+  if (cell.hilbertResolution == 0u) {
+    return anchorInfo;
+  }
+
+  let reverse = dggs_a5_is_reverse_orientation(anchorInfo.orientation);
+  let invertJ = dggs_a5_is_invert_j_orientation(anchorInfo.orientation);
+  let flipIj = dggs_a5_is_flip_ij_orientation(anchorInfo.orientation);
+  let hilbertBits = 2u * cell.hilbertResolution;
+  let sBitOffset = cell.quintantShift - hilbertBits;
+  var digits : array<u32, 29>;
+  var digitIndex = 0u;
+  loop {
+    if (digitIndex >= cell.hilbertResolution) {
+      break;
+    }
+    var digit = dggs_u64_extract_bits(index, sBitOffset + 2u * digitIndex, 2u);
+    if (reverse) {
+      digit = 3u - digit;
+    }
+    digits[digitIndex] = digit;
+    digitIndex += 1u;
+  }
+
+  var flips = vec2i(1, 1);
+  digitIndex = cell.hilbertResolution;
+  loop {
+    if (digitIndex == 0u) {
+      break;
+    }
+    digitIndex -= 1u;
+    dggs_a5_shift_digits(&digits, digitIndex, flips, invertJ, flipIj);
+    flips *= dggs_a5_quaternary_to_flips(digits[digitIndex]);
+  }
+
+  flips = vec2i(1, 1);
+  var offset = vec2i(0);
+  digitIndex = cell.hilbertResolution;
+  loop {
+    if (digitIndex == 0u) {
+      break;
+    }
+    digitIndex -= 1u;
+    offset *= 2;
+    offset += dggs_a5_quaternary_to_kj(digits[digitIndex], flips);
+    flips *= dggs_a5_quaternary_to_flips(digits[digitIndex]);
+  }
+
+  var anchorOffset = dggs_a5_kj_to_ij(offset);
+  if (flipIj) {
+    let originalOffset = anchorOffset;
+    anchorOffset = originalOffset.yx;
+    if (flips.x == -1) {
+      anchorOffset += vec2i(-1, 1);
+    }
+    if (flips.y == -1) {
+      anchorOffset -= vec2i(-1, 1);
+    }
+  }
+  if (invertJ) {
+    let i = anchorOffset.x;
+    let j = i32(1u << cell.hilbertResolution) - (i + anchorOffset.y);
+    flips.x = -flips.x;
+    anchorOffset.y = j;
+  }
+
+  return DggsA5Anchor(
+    digits[0],
+    anchorOffset,
+    flips,
+    anchorInfo.orientation,
+    anchorInfo.quintant
+  );
+}
+
+fn dggs_a5_rotate_face_point(point : vec2f, quintant : u32) -> vec2f {
+  let angle = f32(quintant) * DGGS_TWO_PI_OVER_5;
+  let cosine = cos(angle);
+  let sine = sin(angle);
+  return vec2f(point.x * cosine - point.y * sine, point.x * sine + point.y * cosine);
+}
+
+fn dggs_a5_get_base_pentagon_vertex(vertexIndex : u32) -> vec2f {
+  let vertices = array<vec2f, 5>(
+    vec2f(0.0, 0.0),
+    vec2f(0.199381847431, 0.375413822391),
+    vec2f(0.618033988750, 0.449027976580),
+    vec2f(0.817415836181, 0.073614154188),
+    vec2f(0.418652141319, -0.073614154188)
+  );
+  return vertices[min(vertexIndex, 4u)];
+}
+
+fn dggs_a5_get_base_triangle_vertex(vertexIndex : u32) -> vec2f {
+  let vertices = array<vec2f, 3>(
+    vec2f(0.0, 0.0),
+    vec2f(0.618033988750, 0.449027976580),
+    vec2f(0.618033988750, -0.449027976580)
+  );
+  return vertices[min(vertexIndex, 2u)];
+}
+
+fn dggs_a5_get_face_vertex(vertexIndex : u32) -> vec2f {
+  return dggs_a5_rotate_face_point(dggs_a5_get_base_triangle_vertex(1u), 4u - min(vertexIndex, 4u));
+}
+
+fn dggs_a5_get_triangle_vertex(quintant : u32, vertexIndex : u32) -> vec2f {
+  return dggs_a5_rotate_face_point(dggs_a5_get_base_triangle_vertex(vertexIndex), quintant);
+}
+
+fn dggs_a5_get_pentagon_vertex(
+  anchor : DggsA5Anchor,
+  hilbertResolution : u32,
+  vertexIndex : u32
+) -> vec2f {
+  let flipSum = anchor.flips.x + anchor.flips.y;
+  let reflectsY = ((flipSum == -2 || flipSum == 2) && anchor.q > 1u) ||
+    (flipSum == 0 && (anchor.q == 0u || anchor.q == 3u));
+  let sourceIndex = select(vertexIndex, 4u - vertexIndex, reflectsY);
+  var point = dggs_a5_get_base_pentagon_vertex(sourceIndex);
+
+  if (anchor.flips.x == 1 && anchor.flips.y == -1) {
+    point = -point;
+  }
+  if (reflectsY) {
+    point.y = -point.y;
+  }
+  if (anchor.flips.x == -1 && anchor.flips.y == -1) {
+    point = -point;
+  } else if (anchor.flips.x == -1) {
+    point += vec2f(-0.618033988750, 0.449027976580);
+  } else if (anchor.flips.y == -1) {
+    point += vec2f(0.618033988750, -0.449027976580);
+  }
+
+  let translation = vec2f(
+    f32(anchor.offset.x) * 0.618033988750 + f32(anchor.offset.y) * 0.618033988750,
+    f32(anchor.offset.x) * 0.449027976580 + f32(anchor.offset.y) * -0.449027976580
+  );
+  point = (point + translation) / f32(1u << hilbertResolution);
+  return dggs_a5_rotate_face_point(point, anchor.quintant);
+}
+
+fn dggs_a5_get_shape_vertex_count(cell : DggsA5Cell) -> u32 {
+  return select(5u, 3u, cell.resolution == 1u);
+}
+
+fn dggs_a5_get_reversed_shape_index(vertexIndex : u32, shapeVertexCount : u32) -> u32 {
+  if (vertexIndex == 0u || vertexIndex >= shapeVertexCount) {
+    return 0u;
+  }
+  return shapeVertexCount - vertexIndex;
+}
+
+fn dggs_a5_get_cell_shape_face_point(index : vec2u, cell : DggsA5Cell, shapeIndex : u32) -> vec2f {
+  let anchorInfo = dggs_a5_segment_to_anchor_info(cell);
+  if (cell.resolution == 0u) {
+    return dggs_a5_get_face_vertex(shapeIndex);
+  }
+  if (cell.resolution == 1u) {
+    return dggs_a5_get_triangle_vertex(anchorInfo.quintant, shapeIndex);
+  }
+  let anchor = dggs_a5_make_anchor(index, cell, anchorInfo);
+  return dggs_a5_get_pentagon_vertex(anchor, cell.hilbertResolution, shapeIndex);
+}
+
+fn dggs_a5_get_cell_center_face_point(index : vec2u, cell : DggsA5Cell) -> vec2f {
+  let shapeVertexCount = dggs_a5_get_shape_vertex_count(cell);
+  var center = vec2f(0.0);
+  var vertexIndex = 0u;
+  loop {
+    if (vertexIndex >= shapeVertexCount) {
+      break;
+    }
+    center += dggs_a5_get_cell_shape_face_point(index, cell, vertexIndex);
+    vertexIndex += 1u;
+  }
+  return center / f32(shapeVertexCount);
+}
+
+fn dggs_a5_to_polar(point : vec2f) -> vec2f {
+  return vec2f(length(point), atan2(point.y, point.x));
+}
+
+fn dggs_a5_to_cartesian(thetaPhi : vec2f) -> vec3f {
+  let sinPhi = sin(thetaPhi.y);
+  return vec3f(sinPhi * cos(thetaPhi.x), sinPhi * sin(thetaPhi.x), cos(thetaPhi.y));
+}
+
+fn dggs_a5_normalize_vec3(point : vec3f) -> vec3f {
+  let magnitude = length(point);
+  if (magnitude < 1.0e-12) {
+    return vec3f(0.0, 0.0, 1.0);
+  }
+  return point / magnitude;
+}
+
+fn dggs_a5_get_face_triangle_index(polar : vec2f) -> u32 {
+  return u32(dggs_a5_positive_mod_i32(i32(floor(polar.y / DGGS_PI_OVER_5)), 10));
+}
+
+fn dggs_a5_normalize_gamma(gamma : f32) -> f32 {
+  let segment = gamma / DGGS_TWO_PI_OVER_5;
+  return (segment - round(segment)) * DGGS_TWO_PI_OVER_5;
+}
+
+fn dggs_a5_should_reflect(polar : vec2f) -> bool {
+  return polar.x * cos(dggs_a5_normalize_gamma(polar.y)) > DGGS_A5_DISTANCE_TO_EDGE;
+}
+
+fn dggs_a5_get_base_face_triangle(faceTriangleIndex : u32) -> DggsA5FaceTriangle {
+  let quintant = ((faceTriangleIndex + 1u) / 2u) % 5u;
+  let center = dggs_a5_get_triangle_vertex(quintant, 0u);
+  let corner1 = dggs_a5_get_triangle_vertex(quintant, 1u);
+  let corner2 = dggs_a5_get_triangle_vertex(quintant, 2u);
+  let edgeMidpoint = (corner1 + corner2) * 0.5;
+  if ((faceTriangleIndex & 1u) == 0u) {
+    return DggsA5FaceTriangle(center, edgeMidpoint, corner1);
+  }
+  return DggsA5FaceTriangle(center, corner2, edgeMidpoint);
+}
+
+fn dggs_a5_get_face_triangle_vertex(triangle : DggsA5FaceTriangle, vertexIndex : u32) -> vec2f {
+  if (vertexIndex == 0u) {
+    return triangle.a;
+  }
+  if (vertexIndex == 1u) {
+    return triangle.b;
+  }
+  return triangle.c;
+}
+
+fn dggs_a5_get_reflected_face_triangle(
+  faceTriangleIndex : u32,
+  squashed : bool
+) -> DggsA5FaceTriangle {
+  let baseTriangle = dggs_a5_get_base_face_triangle(faceTriangleIndex);
+  let even = (faceTriangleIndex & 1u) == 0u;
+  let midpoint = select(baseTriangle.c, baseTriangle.b, even);
+  let scale = select(2.0, DGGS_A5_REFLECTED_TRIANGLE_SCALE, squashed);
+  let reflectedA = -baseTriangle.a + midpoint * scale;
+  return DggsA5FaceTriangle(reflectedA, baseTriangle.c, baseTriangle.b);
+}
+
+fn dggs_a5_get_face_triangle(
+  faceTriangleIndex : u32,
+  reflected : bool,
+  squashed : bool
+) -> DggsA5FaceTriangle {
+  if (reflected) {
+    return dggs_a5_get_reflected_face_triangle(faceTriangleIndex, squashed);
+  }
+  return dggs_a5_get_base_face_triangle(faceTriangleIndex);
+}
+
+fn dggs_a5_face_triangle_to_spherical_triangle(
+  faceTriangleIndex : u32,
+  origin : u32,
+  reflected : bool
+) -> DggsA5SphericalTriangle {
+  let faceTriangle = dggs_a5_get_face_triangle(faceTriangleIndex, reflected, true);
+  let originAngle = dggs_a5_get_origin_angle(origin);
+  let quaternion = dggs_a5_get_origin_quaternion(origin);
+
+  let polarA = dggs_a5_to_polar(faceTriangle.a);
+  let polarB = dggs_a5_to_polar(faceTriangle.b);
+  let polarC = dggs_a5_to_polar(faceTriangle.c);
+  let sphericalA = dggs_a5_quaternion_rotate(
+    dggs_a5_to_cartesian(vec2f(polarA.y + originAngle, atan(polarA.x))),
+    quaternion
+  );
+  let sphericalB = dggs_a5_quaternion_rotate(
+    dggs_a5_to_cartesian(vec2f(polarB.y + originAngle, atan(polarB.x))),
+    quaternion
+  );
+  let sphericalC = dggs_a5_quaternion_rotate(
+    dggs_a5_to_cartesian(vec2f(polarC.y + originAngle, atan(polarC.x))),
+    quaternion
+  );
+  return DggsA5SphericalTriangle(
+    dggs_a5_normalize_vec3(sphericalA),
+    dggs_a5_normalize_vec3(sphericalB),
+    dggs_a5_normalize_vec3(sphericalC)
+  );
+}
+
+fn dggs_a5_face_to_barycentric(point : vec2f, triangle : DggsA5FaceTriangle) -> vec3f {
+  let d31 = triangle.a - triangle.c;
+  let d23 = triangle.c - triangle.b;
+  let d3p = point - triangle.c;
+  let determinant = d23.x * d31.y - d23.y * d31.x;
+  if (abs(determinant) < 1.0e-12) {
+    return vec3f(1.0, 0.0, 0.0);
+  }
+  let b0 = (d23.x * d3p.y - d23.y * d3p.x) / determinant;
+  let b1 = (d31.x * d3p.y - d31.y * d3p.x) / determinant;
+  return vec3f(b0, b1, 1.0 - (b0 + b1));
+}
+
+fn dggs_a5_triangle_area(a : vec3f, b : vec3f, c : vec3f) -> f32 {
+  let midA = dggs_a5_normalize_vec3((b + c) * 0.5);
+  let midB = dggs_a5_normalize_vec3((c + a) * 0.5);
+  let midC = dggs_a5_normalize_vec3((a + b) * 0.5);
+  let tripleProduct = dot(midA, cross(midB, midC));
+  let clamped = clamp(tripleProduct, -1.0, 1.0);
+  if (abs(clamped) < 1.0e-8) {
+    return 2.0 * clamped;
+  }
+  return asin(clamped) * 2.0;
+}
+
+fn dggs_a5_spherical_triangle_area(triangle : DggsA5SphericalTriangle) -> f32 {
+  return dggs_a5_triangle_area(triangle.a, triangle.b, triangle.c);
+}
+
+fn dggs_a5_vector_difference(a : vec3f, b : vec3f) -> f32 {
+  let midpoint = dggs_a5_normalize_vec3((a + b) * 0.5);
+  let crossProduct = cross(a, midpoint);
+  let distance = length(crossProduct);
+  if (distance < 1.0e-8) {
+    return 0.5 * length(a - b);
+  }
+  return distance;
+}
+
+fn dggs_a5_slerp(a : vec3f, b : vec3f, t : f32) -> vec3f {
+  let cosineGamma = clamp(dot(a, b), -1.0, 1.0);
+  let gamma = acos(cosineGamma);
+  if (gamma < 1.0e-8) {
+    return dggs_a5_normalize_vec3(mix(a, b, t));
+  }
+  let sinGamma = sin(gamma);
+  if (abs(sinGamma) < 1.0e-8) {
+    return dggs_a5_normalize_vec3(mix(a, b, t));
+  }
+  let weightA = sin((1.0 - t) * gamma) / sinGamma;
+  let weightB = sin(t * gamma) / sinGamma;
+  return dggs_a5_normalize_vec3(weightA * a + weightB * b);
+}
+
+fn dggs_a5_safe_acos(value : f32) -> f32 {
+  if (value < 1.0e-3) {
+    return 2.0 * value + value * value * value / 3.0;
+  }
+  return acos(clamp(1.0 - 2.0 * value * value, -1.0, 1.0));
+}
+
+fn dggs_a5_polyhedral_inverse_edge(a : vec3f, b : vec3f, edgeHeight : f32) -> vec3f {
+  let difference = dggs_a5_vector_difference(a, b);
+  let denominator = max(dggs_a5_safe_acos(difference), 1.0e-8);
+  let interpolation = dggs_a5_safe_acos(clamp(edgeHeight, 0.0, 1.0) * difference) / denominator;
+  return dggs_a5_slerp(a, b, clamp(interpolation, 0.0, 1.0));
+}
+
+fn dggs_a5_polyhedral_inverse(
+  facePoint : vec2f,
+  faceTriangle : DggsA5FaceTriangle,
+  sphericalTriangle : DggsA5SphericalTriangle
+) -> vec3f {
+  let barycentric = dggs_a5_face_to_barycentric(facePoint, faceTriangle);
+  if (barycentric.x > 0.9999999) {
+    return sphericalTriangle.a;
+  }
+  if (barycentric.y > 0.9999999) {
+    return sphericalTriangle.b;
+  }
+  if (barycentric.z > 0.9999999) {
+    return sphericalTriangle.c;
+  }
+  if (abs(barycentric.z) < 1.0e-6) {
+    return dggs_a5_polyhedral_inverse_edge(
+      sphericalTriangle.a,
+      sphericalTriangle.b,
+      1.0 - barycentric.x
+    );
+  }
+  if (abs(barycentric.y) < 1.0e-6) {
+    return dggs_a5_polyhedral_inverse_edge(
+      sphericalTriangle.a,
+      sphericalTriangle.c,
+      1.0 - barycentric.x
+    );
+  }
+
+  let crossBC = cross(sphericalTriangle.b, sphericalTriangle.c);
+  let areaABC = dggs_a5_spherical_triangle_area(sphericalTriangle);
+  let h = max(1.0 - barycentric.x, 1.0e-8);
+  let areaRatio = barycentric.z / h;
+  let alpha = areaRatio * areaABC;
+  let sineAlpha = sin(alpha);
+  let halfSineAlpha = sin(alpha * 0.5);
+  let chordCoefficient = 2.0 * halfSineAlpha * halfSineAlpha;
+  let dotAB = dot(sphericalTriangle.a, sphericalTriangle.b);
+  let dotBC = dot(sphericalTriangle.b, sphericalTriangle.c);
+  let dotCA = dot(sphericalTriangle.c, sphericalTriangle.a);
+  let lengthBC = length(crossBC);
+  let volume = dot(sphericalTriangle.a, crossBC);
+  let f = sineAlpha * volume + chordCoefficient * (dotAB * dotBC - dotCA);
+  let g = chordCoefficient * lengthBC * (1.0 + dotAB);
+  let edgeAngle = max(acos(clamp(dotBC, -1.0, 1.0)), 1.0e-8);
+  let q = 2.0 / edgeAngle * atan2(g, f);
+  let pointOnBC = dggs_a5_slerp(sphericalTriangle.b, sphericalTriangle.c, q);
+  let k = dggs_a5_vector_difference(sphericalTriangle.a, pointOnBC);
+  let denominator = max(dggs_a5_safe_acos(k), 1.0e-8);
+  let t = dggs_a5_safe_acos(h * k) / denominator;
+  return dggs_a5_slerp(sphericalTriangle.a, pointOnBC, t);
+}
+
+fn dggs_a5_authalic_inverse(phi : f32) -> f32 {
+  let sinPhi = sin(phi);
+  let cosPhi = cos(phi);
+  let coefficientX = 2.0 * (cosPhi - sinPhi) * (cosPhi + sinPhi);
+  var u0 = coefficientX * 4.92842354825238055e-17 + 2.19128723067677184e-14;
+  var u1 = coefficientX * u0 + 1.02018123778161003e-11;
+  u0 = coefficientX * u1 - u0 + 5.08622073997266026e-9;
+  u1 = coefficientX * u0 - u1 + 0.00000288319780486075558;
+  u0 = coefficientX * u1 - u0 + 0.00223920899635416575;
+  return phi + 2.0 * sinPhi * cosPhi * u0;
+}
+
+fn dggs_a5_normalize_longitude(longitude : f32) -> f32 {
+  var result = longitude;
+  loop {
+    if (result < -180.0) {
+      result += 360.0;
+    } else {
+      break;
+    }
+  }
+  loop {
+    if (result >= 180.0) {
+      result -= 360.0;
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+
+fn dggs_a5_normalize_longitude_to_center(longitude : f32, centerLongitude : f32) -> f32 {
+  var result = longitude;
+  loop {
+    if (result - centerLongitude > 180.0) {
+      result -= 360.0;
+    } else {
+      break;
+    }
+  }
+  loop {
+    if (result - centerLongitude < -180.0) {
+      result += 360.0;
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+
+fn dggs_a5_sphere_to_lnglat(cartesian : vec3f) -> vec2f {
+  let point = dggs_a5_normalize_vec3(cartesian);
+  let theta = atan2(point.y, point.x);
+  let phi = acos(clamp(point.z, -1.0, 1.0));
+  let longitude = dggs_a5_normalize_longitude(theta * DGGS_RADIANS_TO_DEGREES - DGGS_A5_LONGITUDE_OFFSET);
+  let authalicLatitude = DGGS_PI_OVER_2 - phi;
+  let latitude = dggs_a5_authalic_inverse(authalicLatitude) * DGGS_RADIANS_TO_DEGREES;
+  return vec2f(longitude, latitude);
+}
+
+fn dggs_a5_face_to_lnglat(facePoint : vec2f, origin : u32) -> vec2f {
+  let polar = dggs_a5_to_polar(facePoint);
+  let faceTriangleIndex = dggs_a5_get_face_triangle_index(polar);
+  let reflected = dggs_a5_should_reflect(polar);
+  let faceTriangle = dggs_a5_get_face_triangle(faceTriangleIndex, reflected, false);
+  let sphericalTriangle = dggs_a5_face_triangle_to_spherical_triangle(
+    faceTriangleIndex,
+    origin,
+    reflected
+  );
+  return dggs_a5_sphere_to_lnglat(
+    dggs_a5_polyhedral_inverse(facePoint, faceTriangle, sphericalTriangle)
+  );
+}
+
+fn dggs_a5_get_boundary_point(index : vec2u, vertexIndex : u32) -> vec2f {
+  let cell = dggs_a5_deserialize(index);
+  if (cell.valid == 0u || dggs_u64_is_zero(index)) {
+    return vec2f(0.0);
+  }
+
+  let shapeVertexCount = dggs_a5_get_shape_vertex_count(cell);
+  let shapeIndex = dggs_a5_get_reversed_shape_index(vertexIndex, shapeVertexCount);
+  let facePoint = dggs_a5_get_cell_shape_face_point(index, cell, shapeIndex);
+  let centerPoint = dggs_a5_get_cell_center_face_point(index, cell);
+  var lngLat = dggs_a5_face_to_lnglat(facePoint, cell.origin);
+  let centerLngLat = dggs_a5_face_to_lnglat(centerPoint, cell.origin);
+  lngLat.x = dggs_a5_normalize_longitude_to_center(lngLat.x, centerLngLat.x);
+  return lngLat;
+}
+
+fn dggs_a5_get_boundary_point_fp64_split(index : vec2u, vertexIndex : u32) -> vec4f {
+  return dggs_boundary_point_to_fp64_split(dggs_a5_get_boundary_point(index, vertexIndex));
+}
+
+fn dggs_h3_get_mode(index: vec2u) -> u32 {
+  return dggs_u64_extract_bits(index, 59u, 4u);
+}
+
+fn dggs_h3_is_cell_mode(index: vec2u) -> bool {
+  return dggs_h3_get_mode(index) == DGGS_H3_CELL_MODE;
+}
+
+fn dggs_h3_get_resolution(index: vec2u) -> u32 {
+  return dggs_u64_extract_bits(index, 52u, 4u);
+}
+
+fn dggs_h3_get_base_cell(index: vec2u) -> u32 {
+  return dggs_u64_extract_bits(index, 45u, 7u);
+}
+
+fn dggs_h3_digit_bit_offset(resolution: u32) -> u32 {
+  return 3u * (DGGS_H3_MAX_RESOLUTION - resolution);
+}
+
+fn dggs_h3_get_digit(index: vec2u, resolution: u32) -> u32 {
+  if (resolution == 0u || resolution > DGGS_H3_MAX_RESOLUTION) {
+    return DGGS_H3_UNUSED_DIGIT;
+  }
+  return dggs_u64_extract_bits(index, dggs_h3_digit_bit_offset(resolution), 3u);
+}
+
+fn dggs_h3_is_valid_cell_id(index: vec2u) -> bool {
+  let cellResolution = dggs_h3_get_resolution(index);
+  if (
+    !dggs_h3_is_cell_mode(index) ||
+    cellResolution > DGGS_H3_MAX_RESOLUTION ||
+    dggs_h3_get_base_cell(index) > DGGS_H3_MAX_BASE_CELL
+  ) {
+    return false;
+  }
+
+  var digitResolution = 1u;
+  loop {
+    if (digitResolution > DGGS_H3_MAX_RESOLUTION) {
+      break;
+    }
+
+    let digit = dggs_h3_get_digit(index, digitResolution);
+    if (digitResolution <= cellResolution) {
+      if (digit == DGGS_H3_UNUSED_DIGIT) {
+        return false;
+      }
+    } else if (digit != DGGS_H3_UNUSED_DIGIT) {
+      return false;
+    }
+    digitResolution += 1u;
+  }
+  return true;
+}
+
+fn dggs_h3_get_parent(index: vec2u, parentResolution: u32) -> vec2u {
+  let currentResolution = dggs_h3_get_resolution(index);
+  let targetResolution = min(parentResolution, currentResolution);
+  var parent = dggs_u64_set_bits(index, 52u, 4u, targetResolution);
+  var resolution = targetResolution + 1u;
+  loop {
+    if (resolution > DGGS_H3_MAX_RESOLUTION) {
+      break;
+    }
+    parent = dggs_u64_set_bits(
+      parent,
+      dggs_h3_digit_bit_offset(resolution),
+      3u,
+      DGGS_H3_UNUSED_DIGIT
+    );
+    resolution += 1u;
+  }
+  return parent;
+}
+
+fn dggs_h3_positive_angle_rads(angle: f32) -> f32 {
+  var result = angle;
+  if (result < 0.0) {
+    result += DGGS_TWO_PI;
+  }
+  if (result >= DGGS_TWO_PI) {
+    result -= DGGS_TWO_PI;
+  }
+  return result;
+}
+
+fn dggs_h3_constrain_longitude(longitude: f32) -> f32 {
+  var result = longitude;
+  loop {
+    if (result <= DGGS_PI) {
+      break;
+    }
+    result -= DGGS_TWO_PI;
+  }
+  loop {
+    if (result >= -DGGS_PI) {
+      break;
+    }
+    result += DGGS_TWO_PI;
+  }
+  return result;
+}
+
+fn dggs_h3_is_resolution_class_iii(resolution: u32) -> bool {
+  return (resolution & 1u) != 0u;
+}
+
+fn dggs_h3_is_base_cell_pentagon(baseCell: u32) -> bool {
+  return baseCell == 4u ||
+    baseCell == 14u ||
+    baseCell == 24u ||
+    baseCell == 38u ||
+    baseCell == 49u ||
+    baseCell == 58u ||
+    baseCell == 63u ||
+    baseCell == 72u ||
+    baseCell == 83u ||
+    baseCell == 97u ||
+    baseCell == 107u ||
+    baseCell == 117u;
+}
+
+fn dggs_h3_get_base_cell_home(baseCell: u32) -> DggsH3FaceIJK {
+  let values = array<vec4i, 122>(
+    vec4i(1, 1, 0, 0),
+    vec4i(2, 1, 1, 0),
+    vec4i(1, 0, 0, 0),
+    vec4i(2, 1, 0, 0),
+    vec4i(0, 2, 0, 0),
+    vec4i(1, 1, 1, 0),
+    vec4i(1, 0, 0, 1),
+    vec4i(2, 0, 0, 0),
+    vec4i(0, 1, 0, 0),
+    vec4i(2, 0, 1, 0),
+    vec4i(1, 0, 1, 0),
+    vec4i(1, 0, 1, 1),
+    vec4i(3, 1, 0, 0),
+    vec4i(3, 1, 1, 0),
+    vec4i(11, 2, 0, 0),
+    vec4i(4, 1, 0, 0),
+    vec4i(0, 0, 0, 0),
+    vec4i(6, 0, 1, 0),
+    vec4i(0, 0, 0, 1),
+    vec4i(2, 0, 1, 1),
+    vec4i(7, 0, 0, 1),
+    vec4i(2, 0, 0, 1),
+    vec4i(0, 1, 1, 0),
+    vec4i(6, 0, 0, 1),
+    vec4i(10, 2, 0, 0),
+    vec4i(6, 0, 0, 0),
+    vec4i(3, 0, 0, 0),
+    vec4i(11, 1, 0, 0),
+    vec4i(4, 1, 1, 0),
+    vec4i(3, 0, 1, 0),
+    vec4i(0, 0, 1, 1),
+    vec4i(4, 0, 0, 0),
+    vec4i(5, 0, 1, 0),
+    vec4i(0, 0, 1, 0),
+    vec4i(7, 0, 1, 0),
+    vec4i(11, 1, 1, 0),
+    vec4i(7, 0, 0, 0),
+    vec4i(10, 1, 0, 0),
+    vec4i(12, 2, 0, 0),
+    vec4i(6, 1, 0, 1),
+    vec4i(7, 1, 0, 1),
+    vec4i(4, 0, 0, 1),
+    vec4i(3, 0, 0, 1),
+    vec4i(3, 0, 1, 1),
+    vec4i(4, 0, 1, 0),
+    vec4i(6, 1, 0, 0),
+    vec4i(11, 0, 0, 0),
+    vec4i(8, 0, 0, 1),
+    vec4i(5, 0, 0, 1),
+    vec4i(14, 2, 0, 0),
+    vec4i(5, 0, 0, 0),
+    vec4i(12, 1, 0, 0),
+    vec4i(10, 1, 1, 0),
+    vec4i(4, 0, 1, 1),
+    vec4i(12, 1, 1, 0),
+    vec4i(7, 1, 0, 0),
+    vec4i(11, 0, 1, 0),
+    vec4i(10, 0, 0, 0),
+    vec4i(13, 2, 0, 0),
+    vec4i(10, 0, 0, 1),
+    vec4i(11, 0, 0, 1),
+    vec4i(9, 0, 1, 0),
+    vec4i(8, 0, 1, 0),
+    vec4i(6, 2, 0, 0),
+    vec4i(8, 0, 0, 0),
+    vec4i(9, 0, 0, 1),
+    vec4i(14, 1, 0, 0),
+    vec4i(5, 1, 0, 1),
+    vec4i(16, 0, 1, 1),
+    vec4i(8, 1, 0, 1),
+    vec4i(5, 1, 0, 0),
+    vec4i(12, 0, 0, 0),
+    vec4i(7, 2, 0, 0),
+    vec4i(12, 0, 1, 0),
+    vec4i(10, 0, 1, 0),
+    vec4i(9, 0, 0, 0),
+    vec4i(13, 1, 0, 0),
+    vec4i(16, 0, 0, 1),
+    vec4i(15, 0, 1, 1),
+    vec4i(15, 0, 1, 0),
+    vec4i(16, 0, 1, 0),
+    vec4i(14, 1, 1, 0),
+    vec4i(13, 1, 1, 0),
+    vec4i(5, 2, 0, 0),
+    vec4i(8, 1, 0, 0),
+    vec4i(14, 0, 0, 0),
+    vec4i(9, 1, 0, 1),
+    vec4i(14, 0, 0, 1),
+    vec4i(17, 0, 0, 1),
+    vec4i(12, 0, 0, 1),
+    vec4i(16, 0, 0, 0),
+    vec4i(17, 0, 1, 1),
+    vec4i(15, 0, 0, 1),
+    vec4i(16, 1, 0, 1),
+    vec4i(9, 1, 0, 0),
+    vec4i(15, 0, 0, 0),
+    vec4i(13, 0, 0, 0),
+    vec4i(8, 2, 0, 0),
+    vec4i(13, 0, 1, 0),
+    vec4i(17, 1, 0, 1),
+    vec4i(19, 0, 1, 0),
+    vec4i(14, 0, 1, 0),
+    vec4i(19, 0, 1, 1),
+    vec4i(17, 0, 1, 0),
+    vec4i(13, 0, 0, 1),
+    vec4i(17, 0, 0, 0),
+    vec4i(16, 1, 0, 0),
+    vec4i(9, 2, 0, 0),
+    vec4i(15, 1, 0, 1),
+    vec4i(15, 1, 0, 0),
+    vec4i(18, 0, 1, 1),
+    vec4i(18, 0, 0, 1),
+    vec4i(19, 0, 0, 1),
+    vec4i(17, 1, 0, 0),
+    vec4i(19, 0, 0, 0),
+    vec4i(18, 0, 1, 0),
+    vec4i(18, 1, 0, 1),
+    vec4i(19, 2, 0, 0),
+    vec4i(19, 1, 0, 0),
+    vec4i(18, 0, 0, 0),
+    vec4i(19, 1, 0, 1),
+    vec4i(18, 1, 0, 0)
+  );
+  let value = values[min(baseCell, DGGS_H3_MAX_BASE_CELL)];
+  return DggsH3FaceIJK(
+    u32(value.x),
+    value.yzw,
+    select(1u, 0u, baseCell > DGGS_H3_MAX_BASE_CELL)
+  );
+}
+
+fn dggs_h3_get_face_center_geo(face: u32) -> vec2f {
+  let values = array<vec2f, 20>(
+    vec2f(0.803582649718989942, 1.248397419617396099),
+    vec2f(1.307747883455638156, 2.536945009877921159),
+    vec2f(1.054751253523952054, -1.347517358900396623),
+    vec2f(0.600191595538186799, -0.450603909469755746),
+    vec2f(0.491715428198773866, 0.401988202911306943),
+    vec2f(0.172745327415618701, 1.678146885280433686),
+    vec2f(0.605929321571350690, 2.953923329812411617),
+    vec2f(0.427370518328979641, -1.888876200336285401),
+    vec2f(-0.079066118549212831, -0.733429513380867741),
+    vec2f(-0.230961644455383637, 0.506495587332349035),
+    vec2f(0.079066118549212831, 2.408163140208925497),
+    vec2f(0.230961644455383637, -2.635097066257444203),
+    vec2f(-0.172745327415618701, -1.463445768309359553),
+    vec2f(-0.605929321571350690, -0.187669323777381622),
+    vec2f(-0.427370518328979641, 1.252716453253507838),
+    vec2f(-0.600191595538186799, 2.690988744120037492),
+    vec2f(-0.491715428198773866, -2.739604450678486295),
+    vec2f(-0.803582649718989942, -1.893195233972397139),
+    vec2f(-1.307747883455638156, -0.604647643711872080),
+    vec2f(-1.054751253523952054, 1.794075294689396615)
+  );
+  return values[min(face, 19u)];
+}
+
+fn dggs_h3_get_face_axis_azimuths(face: u32) -> vec3f {
+  let values = array<vec3f, 20>(
+    vec3f(5.619958268523939882, 3.525563166130744542, 1.431168063737548730),
+    vec3f(5.760339081714187279, 3.665943979320991689, 1.571548876927796127),
+    vec3f(0.780213654393430055, 4.969003859179821079, 2.874608756786625655),
+    vec3f(0.430469363979999913, 4.619259568766391033, 2.524864466373195467),
+    vec3f(6.130269123335111400, 4.035874020941915804, 1.941478918548720291),
+    vec3f(2.692877706530642877, 0.598482604137447119, 4.787272808923838195),
+    vec3f(2.982963003477243874, 0.888567901084048369, 5.077358105870439581),
+    vec3f(3.532912002790141181, 1.438516900396945656, 5.627307105183336758),
+    vec3f(3.494305004259568154, 1.399909901866372864, 5.588700106652763840),
+    vec3f(3.003214169499538391, 0.908819067106342928, 5.097609271892733906),
+    vec3f(5.930472956509811562, 3.836077854116615875, 1.741682751723420374),
+    vec3f(0.138378484090254847, 4.327168688876645809, 2.232773586483450311),
+    vec3f(0.448714947059150361, 4.637505151845541521, 2.543110049452346120),
+    vec3f(0.158629650112549365, 4.347419854898940135, 2.253024752505744869),
+    vec3f(5.891865957979238535, 3.797470855586042958, 1.703075753192847583),
+    vec3f(2.711123289609793325, 0.616728187216597771, 4.805518392002988683),
+    vec3f(3.294508837434268316, 1.200113735041072948, 5.388903939827463911),
+    vec3f(3.804819692245439833, 1.710424589852244509, 5.899214794638635174),
+    vec3f(3.664438879055192436, 1.570043776661997111, 5.758833981448388027),
+    vec3f(2.361378999196363184, 0.266983896803167583, 4.455774101589558636)
+  );
+  return values[min(face, 19u)];
+}
+
+fn dggs_h3_get_max_dim_by_cii_resolution(resolution: u32) -> i32 {
+  let values = array<i32, 17>(
+    2, -1, 14, -1, 98, -1, 686, -1, 4802, -1, 33614, -1, 235298, -1, 1647086, -1, 11529602
+  );
+  return values[min(resolution, 16u)];
+}
+
+fn dggs_h3_get_unit_vector(digit: u32) -> vec3i {
+  if (digit == 1u) {
+    return vec3i(0, 0, 1);
+  }
+  if (digit == 2u) {
+    return vec3i(0, 1, 0);
+  }
+  if (digit == 3u) {
+    return vec3i(0, 1, 1);
+  }
+  if (digit == 4u) {
+    return vec3i(1, 0, 0);
+  }
+  if (digit == 5u) {
+    return vec3i(1, 0, 1);
+  }
+  if (digit == 6u) {
+    return vec3i(1, 1, 0);
+  }
+  return vec3i(0);
+}
+
+fn dggs_h3_ijk_normalize(coord: vec3i) -> vec3i {
+  var normalized = coord;
+  if (normalized.x < 0) {
+    normalized.y -= normalized.x;
+    normalized.z -= normalized.x;
+    normalized.x = 0;
+  }
+  if (normalized.y < 0) {
+    normalized.x -= normalized.y;
+    normalized.z -= normalized.y;
+    normalized.y = 0;
+  }
+  if (normalized.z < 0) {
+    normalized.x -= normalized.z;
+    normalized.y -= normalized.z;
+    normalized.z = 0;
+  }
+
+  let minimumValue = min(normalized.x, min(normalized.y, normalized.z));
+  if (minimumValue > 0) {
+    normalized -= vec3i(minimumValue);
+  }
+  return normalized;
+}
+
+fn dggs_h3_neighbor(coord: vec3i, digit: u32) -> vec3i {
+  if (digit > 0u && digit < DGGS_H3_UNUSED_DIGIT) {
+    return dggs_h3_ijk_normalize(coord + dggs_h3_get_unit_vector(digit));
+  }
+  return coord;
+}
+
+fn dggs_h3_down_ap3(coord: vec3i) -> vec3i {
+  let iVector = vec3i(2, 0, 1) * coord.x;
+  let jVector = vec3i(1, 2, 0) * coord.y;
+  let kVector = vec3i(0, 1, 2) * coord.z;
+  return dggs_h3_ijk_normalize(iVector + jVector + kVector);
+}
+
+fn dggs_h3_down_ap3r(coord: vec3i) -> vec3i {
+  let iVector = vec3i(2, 1, 0) * coord.x;
+  let jVector = vec3i(0, 2, 1) * coord.y;
+  let kVector = vec3i(1, 0, 2) * coord.z;
+  return dggs_h3_ijk_normalize(iVector + jVector + kVector);
+}
+
+fn dggs_h3_down_ap7(coord: vec3i) -> vec3i {
+  let iVector = vec3i(3, 0, 1) * coord.x;
+  let jVector = vec3i(1, 3, 0) * coord.y;
+  let kVector = vec3i(0, 1, 3) * coord.z;
+  return dggs_h3_ijk_normalize(iVector + jVector + kVector);
+}
+
+fn dggs_h3_down_ap7r(coord: vec3i) -> vec3i {
+  let iVector = vec3i(3, 1, 0) * coord.x;
+  let jVector = vec3i(0, 3, 1) * coord.y;
+  let kVector = vec3i(1, 0, 3) * coord.z;
+  return dggs_h3_ijk_normalize(iVector + jVector + kVector);
+}
+
+fn dggs_h3_get_center_face_ijk(index: vec2u) -> DggsH3FaceIJK {
+  if (!dggs_h3_is_valid_cell_id(index)) {
+    return DggsH3FaceIJK(0u, vec3i(0), 0u);
+  }
+
+  let baseCell = dggs_h3_get_base_cell(index);
+  if (dggs_h3_is_base_cell_pentagon(baseCell)) {
+    return DggsH3FaceIJK(0u, vec3i(0), 0u);
+  }
+
+  var faceIJK = dggs_h3_get_base_cell_home(baseCell);
+  let cellResolution = dggs_h3_get_resolution(index);
+  var resolution = 1u;
+  loop {
+    if (resolution > cellResolution) {
+      break;
+    }
+
+    if (dggs_h3_is_resolution_class_iii(resolution)) {
+      faceIJK.coord = dggs_h3_down_ap7(faceIJK.coord);
+    } else {
+      faceIJK.coord = dggs_h3_down_ap7r(faceIJK.coord);
+    }
+    faceIJK.coord = dggs_h3_neighbor(faceIJK.coord, dggs_h3_get_digit(index, resolution));
+    resolution += 1u;
+  }
+
+  return faceIJK;
+}
+
+fn dggs_h3_get_vertex_offset(resolution: u32, vertexIndex: u32) -> vec3i {
+  let pointIndex = vertexIndex % 6u;
+  if (dggs_h3_is_resolution_class_iii(resolution)) {
+    let vertices = array<vec3i, 6>(
+      vec3i(5, 4, 0),
+      vec3i(1, 5, 0),
+      vec3i(0, 5, 4),
+      vec3i(0, 1, 5),
+      vec3i(4, 0, 5),
+      vec3i(5, 0, 1)
+    );
+    return vertices[pointIndex];
+  }
+
+  let vertices = array<vec3i, 6>(
+    vec3i(2, 1, 0),
+    vec3i(1, 2, 0),
+    vec3i(0, 2, 1),
+    vec3i(0, 1, 2),
+    vec3i(1, 0, 2),
+    vec3i(2, 0, 1)
+  );
+  return vertices[pointIndex];
+}
+
+fn dggs_h3_get_boundary_vertex(index: vec2u, vertexIndex: u32) -> DggsH3BoundaryVertex {
+  let center = dggs_h3_get_center_face_ijk(index);
+  if (center.valid == 0u) {
+    return DggsH3BoundaryVertex(0u, vec3i(0), 0u, 0u);
+  }
+
+  let cellResolution = dggs_h3_get_resolution(index);
+  var adjustedResolution = cellResolution;
+  var centerCoord = dggs_h3_down_ap3r(dggs_h3_down_ap3(center.coord));
+  if (dggs_h3_is_resolution_class_iii(cellResolution)) {
+    centerCoord = dggs_h3_down_ap7r(centerCoord);
+    adjustedResolution += 1u;
+  }
+
+  let vertexCoord = dggs_h3_ijk_normalize(
+    centerCoord + dggs_h3_get_vertex_offset(cellResolution, vertexIndex)
+  );
+  let maximumDimension = dggs_h3_get_max_dim_by_cii_resolution(adjustedResolution) * 3;
+  let vertexDimension = vertexCoord.x + vertexCoord.y + vertexCoord.z;
+  if (vertexDimension >= maximumDimension) {
+    return DggsH3BoundaryVertex(center.face, vertexCoord, adjustedResolution, 0u);
+  }
+
+  return DggsH3BoundaryVertex(center.face, vertexCoord, adjustedResolution, 1u);
+}
+
+fn dggs_h3_is_single_face_boundary(index: vec2u) -> bool {
+  var vertexIndex = 0u;
+  loop {
+    if (vertexIndex >= 6u) {
+      break;
+    }
+    if (dggs_h3_get_boundary_vertex(index, vertexIndex).valid == 0u) {
+      return false;
+    }
+    vertexIndex += 1u;
+  }
+  return true;
+}
+
+fn dggs_h3_ijk_to_hex2d(coord: vec3i) -> vec2f {
+  let i = f32(coord.x - coord.z);
+  let j = f32(coord.y - coord.z);
+  return vec2f(i - 0.5 * j, j * DGGS_H3_SQRT3_2);
+}
+
+fn dggs_h3_geo_az_distance_rads(center: vec2f, azimuth: f32, distance: f32) -> vec2f {
+  if (distance < 1.0e-7) {
+    return center;
+  }
+
+  let positiveAzimuth = dggs_h3_positive_angle_rads(azimuth);
+  let latitude = asin(clamp(
+    sin(center.x) * cos(distance) + cos(center.x) * sin(distance) * cos(positiveAzimuth),
+    -1.0,
+    1.0
+  ));
+  var longitude = 0.0;
+  if (abs(latitude - DGGS_PI_OVER_2) < 1.0e-7) {
+    return vec2f(DGGS_PI_OVER_2, 0.0);
+  }
+  if (abs(latitude + DGGS_PI_OVER_2) < 1.0e-7) {
+    return vec2f(-DGGS_PI_OVER_2, 0.0);
+  }
+
+  let inverseCosLatitude = 1.0 / max(cos(latitude), 1.0e-8);
+  let sinLongitude = clamp(
+    sin(positiveAzimuth) * sin(distance) * inverseCosLatitude,
+    -1.0,
+    1.0
+  );
+  let cosLongitude = clamp(
+    (cos(distance) - sin(center.x) * sin(latitude)) / max(cos(center.x), 1.0e-8) *
+      inverseCosLatitude,
+    -1.0,
+    1.0
+  );
+  longitude = dggs_h3_constrain_longitude(center.y + atan2(sinLongitude, cosLongitude));
+  return vec2f(latitude, longitude);
+}
+
+fn dggs_h3_hex2d_to_lnglat(point: vec2f, face: u32, resolution: u32, substrate: bool) -> vec2f {
+  var radius = length(point);
+  let center = dggs_h3_get_face_center_geo(face);
+  if (radius < 1.0e-7) {
+    return vec2f(center.y * DGGS_RADIANS_TO_DEGREES, center.x * DGGS_RADIANS_TO_DEGREES);
+  }
+
+  var theta = atan2(point.y, point.x);
+  var resolutionIndex = 0u;
+  loop {
+    if (resolutionIndex >= resolution) {
+      break;
+    }
+    radius *= DGGS_H3_RSQRT7;
+    resolutionIndex += 1u;
+  }
+
+  if (substrate) {
+    radius *= DGGS_H3_ONETHIRD;
+    if (dggs_h3_is_resolution_class_iii(resolution)) {
+      radius *= DGGS_H3_RSQRT7;
+    }
+  } else if (dggs_h3_is_resolution_class_iii(resolution)) {
+    theta = dggs_h3_positive_angle_rads(theta + DGGS_H3_AP7_ROT_RADS);
+  }
+
+  radius = atan(radius * DGGS_H3_RES0_U_GNOMONIC);
+  theta = dggs_h3_positive_angle_rads(dggs_h3_get_face_axis_azimuths(face).x - theta);
+  let latitudeLongitude = dggs_h3_geo_az_distance_rads(center, theta, radius);
+  return vec2f(
+    latitudeLongitude.y * DGGS_RADIANS_TO_DEGREES,
+    latitudeLongitude.x * DGGS_RADIANS_TO_DEGREES
+  );
+}
+
+fn dggs_h3_get_boundary_point(index: vec2u, vertexIndex: u32) -> vec2f {
+  if (!dggs_h3_is_single_face_boundary(index)) {
+    return vec2f(0.0);
+  }
+
+  let vertex = dggs_h3_get_boundary_vertex(index, vertexIndex % 6u);
+  let hexPoint = dggs_h3_ijk_to_hex2d(vertex.coord);
+  return dggs_h3_hex2d_to_lnglat(hexPoint, vertex.face, vertex.resolution, true);
+}
+
+fn dggs_h3_get_boundary_point_fp64_split(index: vec2u, vertexIndex: u32) -> vec4f {
+  return dggs_boundary_point_to_fp64_split(dggs_h3_get_boundary_point(index, vertexIndex));
+}
+
+fn dggs_s2_get_face(index: vec2u) -> u32 {
+  return dggs_u64_extract_bits(index, 61u, 3u);
+}
+
+fn dggs_s2_get_level(index: vec2u) -> u32 {
+  let trailingZeros = dggs_u64_count_trailing_zeros(index);
+  if (trailingZeros > 60u) {
+    return 0u;
+  }
+  return DGGS_S2_MAX_LEVEL - trailingZeros / 2u;
+}
+
+fn dggs_s2_is_valid_cell_id(index: vec2u) -> bool {
+  let trailingZeros = dggs_u64_count_trailing_zeros(index);
+  return !dggs_u64_is_zero(index) &&
+    dggs_s2_get_face(index) <= 5u &&
+    trailingZeros <= 60u &&
+    trailingZeros % 2u == 0u;
+}
+
+fn dggs_s2_get_child_position(index: vec2u, level: u32) -> u32 {
+  if (level == 0u || level > DGGS_S2_MAX_LEVEL) {
+    return 0u;
+  }
+  return dggs_u64_extract_bits(index, 2u * (DGGS_S2_MAX_LEVEL - level) + 1u, 2u);
+}
+
+// Packed geohash keys store the geohash length in bits 60..63 and right-align
+// the base32 character codes in the lower 60 bits, first character first.
+fn dggs_geohash_get_length(index: vec2u) -> u32 {
+  return min(
+    dggs_u64_extract_bits(index, DGGS_GEOHASH_LENGTH_BIT_OFFSET, 4u),
+    DGGS_GEOHASH_MAX_LENGTH
+  );
+}
+
+fn dggs_geohash_get_character(index: vec2u, characterIndex: u32) -> u32 {
+  let length = dggs_geohash_get_length(index);
+  if (characterIndex >= length) {
+    return 0u;
+  }
+  return dggs_u64_extract_bits(index, 5u * (length - characterIndex - 1u), 5u);
+}
+
+// Returns vec4(west, south, east, north) in longitude/latitude degrees.
+fn dggs_geohash_get_bounds(index: vec2u) -> vec4f {
+  let length = dggs_geohash_get_length(index);
+  var west = -180.0;
+  var east = 180.0;
+  var south = -90.0;
+  var north = 90.0;
+  var isLongitude = true;
+  var characterIndex = 0u;
+  loop {
+    if (characterIndex >= length) {
+      break;
+    }
+
+    let character = dggs_geohash_get_character(index, characterIndex);
+    var bitIndex = 0u;
+    loop {
+      if (bitIndex >= 5u) {
+        break;
+      }
+
+      let bit = (character >> (4u - bitIndex)) & 1u;
+      if (isLongitude) {
+        let midpoint = (west + east) * 0.5;
+        if (bit == 0u) {
+          east = midpoint;
+        } else {
+          west = midpoint;
+        }
+      } else {
+        let midpoint = (south + north) * 0.5;
+        if (bit == 0u) {
+          north = midpoint;
+        } else {
+          south = midpoint;
+        }
+      }
+      isLongitude = !isLongitude;
+      bitIndex += 1u;
+    }
+    characterIndex += 1u;
+  }
+
+  return vec4f(west, south, east, north);
+}
+
+fn dggs_bounds_get_boundary_point(bounds: vec4f, vertexIndex: u32) -> vec2f {
+  let pointIndex = vertexIndex % 4u;
+  if (pointIndex == 0u) {
+    return vec2f(bounds.x, bounds.w);
+  }
+  if (pointIndex == 1u) {
+    return vec2f(bounds.z, bounds.w);
+  }
+  if (pointIndex == 2u) {
+    return vec2f(bounds.z, bounds.y);
+  }
+  return vec2f(bounds.x, bounds.y);
+}
+
+fn dggs_geohash_get_boundary_point(index: vec2u, vertexIndex: u32) -> vec2f {
+  return dggs_bounds_get_boundary_point(dggs_geohash_get_bounds(index), vertexIndex);
+}
+
+fn dggs_geohash_get_boundary_point_fp64_split(index: vec2u, vertexIndex: u32) -> vec4f {
+  return dggs_boundary_point_to_fp64_split(dggs_geohash_get_boundary_point(index, vertexIndex));
+}
+
+// Packed quadkey keys store the quadkey length in bits 58..63 and right-align
+// the base4 digits in the lower 58 bits, first digit first.
+fn dggs_quadkey_get_length(index: vec2u) -> u32 {
+  return min(
+    dggs_u64_extract_bits(index, DGGS_QUADKEY_LENGTH_BIT_OFFSET, 6u),
+    DGGS_QUADKEY_MAX_LENGTH
+  );
+}
+
+fn dggs_quadkey_get_digit(index: vec2u, digitIndex: u32) -> u32 {
+  let length = dggs_quadkey_get_length(index);
+  if (digitIndex >= length) {
+    return 0u;
+  }
+  return dggs_u64_extract_bits(index, 2u * (length - digitIndex - 1u), 2u);
+}
+
+fn dggs_quadkey_get_tile(index: vec2u) -> vec3u {
+  let length = dggs_quadkey_get_length(index);
+  var tileX = 0u;
+  var tileY = 0u;
+  var digitIndex = 0u;
+  loop {
+    if (digitIndex >= length) {
+      break;
+    }
+
+    let digit = dggs_quadkey_get_digit(index, digitIndex);
+    let mask = 1u << (length - digitIndex - 1u);
+    if ((digit & 1u) != 0u) {
+      tileX |= mask;
+    }
+    if ((digit & 2u) != 0u) {
+      tileY |= mask;
+    }
+    digitIndex += 1u;
+  }
+  return vec3u(tileX, tileY, length);
+}
+
+fn dggs_web_mercator_tile_y_to_latitude(tileY: f32, tileScale: f32) -> f32 {
+  let mercatorY = DGGS_PI * (1.0 - 2.0 * tileY / tileScale);
+  return (2.0 * atan(exp(mercatorY)) - DGGS_PI * 0.5) * DGGS_RADIANS_TO_DEGREES;
+}
+
+// Returns vec4(west, south, east, north) in longitude/latitude degrees.
+fn dggs_quadkey_get_bounds(index: vec2u) -> vec4f {
+  let tile = dggs_quadkey_get_tile(index);
+  let tileScale = f32(1u << tile.z);
+  let west = f32(tile.x) / tileScale * 360.0 - 180.0;
+  let east = f32(tile.x + 1u) / tileScale * 360.0 - 180.0;
+  let north = dggs_web_mercator_tile_y_to_latitude(f32(tile.y), tileScale);
+  let south = dggs_web_mercator_tile_y_to_latitude(f32(tile.y + 1u), tileScale);
+  return vec4f(west, south, east, north);
+}
+
+fn dggs_quadkey_get_boundary_point(index: vec2u, vertexIndex: u32) -> vec2f {
+  return dggs_bounds_get_boundary_point(dggs_quadkey_get_bounds(index), vertexIndex);
+}
+
+fn dggs_quadkey_get_boundary_point_fp64_split(index: vec2u, vertexIndex: u32) -> vec4f {
+  return dggs_boundary_point_to_fp64_split(dggs_quadkey_get_boundary_point(index, vertexIndex));
+}
+
+fn dggs_s2_digit_to_xy(digit: u32) -> vec2u {
+  if (digit == 1u) {
+    return vec2u(0u, 1u);
+  }
+  if (digit == 2u) {
+    return vec2u(1u, 1u);
+  }
+  if (digit == 3u) {
+    return vec2u(1u, 0u);
+  }
+  return vec2u(0u, 0u);
+}
+
+fn dggs_s2_rotate_and_flip_quadrant(size: u32, point: vec2u, digitXY: vec2u) -> vec2u {
+  var result = point;
+  if (digitXY.y == 0u) {
+    if (digitXY.x == 1u) {
+      result = vec2u(size - 1u - result.x, size - 1u - result.y);
+    }
+    result = result.yx;
+  }
+  return result;
+}
+
+fn dggs_s2_get_ij(index: vec2u) -> vec2u {
+  let level = dggs_s2_get_level(index);
+  var point = vec2u(0u);
+  var hilbertLevel = 1u;
+  loop {
+    if (hilbertLevel > level) {
+      break;
+    }
+    let digitLevel = level - hilbertLevel + 1u;
+    let digitXY = dggs_s2_digit_to_xy(dggs_s2_get_child_position(index, digitLevel));
+    let size = 1u << (hilbertLevel - 1u);
+    point = dggs_s2_rotate_and_flip_quadrant(size, point, digitXY);
+    point += size * digitXY;
+    hilbertLevel += 1u;
+  }
+  if ((dggs_s2_get_face(index) & 1u) != 0u) {
+    point = point.yx;
+  }
+  return point;
+}
+
+fn dggs_s2_single_st_to_uv(st: f32) -> f32 {
+  if (st >= 0.5) {
+    return (4.0 * st * st - 1.0) / 3.0;
+  }
+  return (1.0 - 4.0 * (1.0 - st) * (1.0 - st)) / 3.0;
+}
+
+fn dggs_s2_ij_to_st(ij: vec2u, level: u32, offset: vec2f) -> vec2f {
+  let maxSize = f32(1u << level);
+  return (vec2f(f32(ij.x), f32(ij.y)) + offset) / maxSize;
+}
+
+fn dggs_s2_st_to_uv(st: vec2f) -> vec2f {
+  return vec2f(dggs_s2_single_st_to_uv(st.x), dggs_s2_single_st_to_uv(st.y));
+}
+
+fn dggs_s2_face_uv_to_xyz(face: u32, uv: vec2f) -> vec3f {
+  if (face == 0u) {
+    return vec3f(1.0, uv.x, uv.y);
+  }
+  if (face == 1u) {
+    return vec3f(-uv.x, 1.0, uv.y);
+  }
+  if (face == 2u) {
+    return vec3f(-uv.x, -uv.y, 1.0);
+  }
+  if (face == 3u) {
+    return vec3f(-1.0, -uv.y, -uv.x);
+  }
+  if (face == 4u) {
+    return vec3f(uv.y, -1.0, -uv.x);
+  }
+  return vec3f(uv.y, uv.x, -1.0);
+}
+
+fn dggs_s2_xyz_to_lnglat(xyz: vec3f) -> vec2f {
+  let latitude = atan2(xyz.z, length(xyz.xy)) * DGGS_RADIANS_TO_DEGREES;
+  let longitude = atan2(xyz.y, xyz.x) * DGGS_RADIANS_TO_DEGREES;
+  return vec2f(longitude, latitude);
+}
+
+fn dggs_s2_get_boundary_offset(vertexIndex: u32) -> vec2f {
+  let pointIndex = vertexIndex % 4u;
+  if (pointIndex == 1u) {
+    return vec2f(0.0, 1.0);
+  }
+  if (pointIndex == 2u) {
+    return vec2f(1.0, 1.0);
+  }
+  if (pointIndex == 3u) {
+    return vec2f(1.0, 0.0);
+  }
+  return vec2f(0.0, 0.0);
+}
+
+fn dggs_s2_get_boundary_point(index: vec2u, vertexIndex: u32) -> vec2f {
+  let level = dggs_s2_get_level(index);
+  let ij = dggs_s2_get_ij(index);
+  let st = dggs_s2_ij_to_st(ij, level, dggs_s2_get_boundary_offset(vertexIndex));
+  let uv = dggs_s2_st_to_uv(st);
+  let xyz = dggs_s2_face_uv_to_xyz(dggs_s2_get_face(index), uv);
+  return dggs_s2_xyz_to_lnglat(xyz);
+}
+
+fn dggs_s2_get_boundary_point_fp64_split(index: vec2u, vertexIndex: u32) -> vec4f {
+  return dggs_boundary_point_to_fp64_split(dggs_s2_get_boundary_point(index, vertexIndex));
+}
+`
+);
+
+// dist/modules/geospatial/dggs/dggs.js
+var dggs = {
+  name: "dggs",
+  source: dggsWGSL
+};
+
+// dist/modules/color/float-colors.js
+var STORAGE_COLOR_FORMAT = {
+  RGBA8UNORM: 0,
+  RGBA16FLOAT: 1,
+  RGBA32FLOAT: 2
+};
+var STORAGE_COLOR_FORMAT_BYTE_LENGTHS = {
+  rgba8unorm: 4,
+  rgba16float: 8,
+  rgba32float: 16
+};
+var STORAGE_COLOR_DEFAULT_BYTE_STRIDES = {
+  ...STORAGE_COLOR_FORMAT_BYTE_LENGTHS
+};
+var STORAGE_COLOR_FORMAT_BY_NAME = {
+  rgba8unorm: STORAGE_COLOR_FORMAT.RGBA8UNORM,
+  rgba16float: STORAGE_COLOR_FORMAT.RGBA16FLOAT,
+  rgba32float: STORAGE_COLOR_FORMAT.RGBA32FLOAT
+};
+var STORAGE_COLOR_FORMAT_NAME_BY_VALUE = {
+  [STORAGE_COLOR_FORMAT.RGBA8UNORM]: "rgba8unorm",
+  [STORAGE_COLOR_FORMAT.RGBA16FLOAT]: "rgba16float",
+  [STORAGE_COLOR_FORMAT.RGBA32FLOAT]: "rgba32float"
+};
+var COLORS_UNIFORM_TYPES = {
+  useByteColors: "f32"
+};
+var COLORS_DEFAULT_UNIFORMS = {
+  useByteColors: true
+};
+var STORAGE_COLORS_UNIFORM_TYPES = {
+  format: "u32",
+  wordStride: "u32",
+  wordOffset: "u32",
+  _padding: "u32"
+};
+var STORAGE_COLORS_DEFAULT_UNIFORMS = {
+  format: STORAGE_COLOR_FORMAT.RGBA8UNORM,
+  wordStride: STORAGE_COLOR_DEFAULT_BYTE_STRIDES.rgba8unorm / Uint32Array.BYTES_PER_ELEMENT,
+  wordOffset: 0,
+  _padding: 0
+};
+var COLORS_GLSL = buildGLSLColorModuleSource("colors");
+var FLOAT_COLORS_GLSL = buildGLSLColorModuleSource("floatColors");
+var COLORS_WGSL = buildWGSLColorModuleSource("colors");
+var FLOAT_COLORS_WGSL = buildWGSLColorModuleSource("floatColors");
+var STORAGE_COLORS_WGSL = (
+  /* wgsl */
+  `struct storageColorsUniforms {
+  format: u32,
+  wordStride: u32,
+  wordOffset: u32,
+  _padding: u32
+};
+
+@group(0) @binding(auto) var<uniform> storageColors : storageColorsUniforms;
+@group(0) @binding(auto) var<storage, read> storageColorsBuffer : array<u32>;
+
+const STORAGE_COLOR_FORMAT_RGBA8UNORM : u32 = ${STORAGE_COLOR_FORMAT.RGBA8UNORM}u;
+const STORAGE_COLOR_FORMAT_RGBA16FLOAT : u32 = ${STORAGE_COLOR_FORMAT.RGBA16FLOAT}u;
+
+fn storageColors_getWordIndex(rowIndex: u32) -> u32 {
+  return storageColors.wordOffset + rowIndex * storageColors.wordStride;
+}
+
+fn storageColors_readRgba8UnormColor(wordIndex: u32) -> vec4<f32> {
+  return unpack4x8unorm(storageColorsBuffer[wordIndex]);
+}
+
+fn storageColors_readRgba16FloatColor(wordIndex: u32) -> vec4<f32> {
+  let redGreen = unpack2x16float(storageColorsBuffer[wordIndex]);
+  let blueAlpha = unpack2x16float(storageColorsBuffer[wordIndex + 1u]);
+  return vec4<f32>(redGreen.x, redGreen.y, blueAlpha.x, blueAlpha.y);
+}
+
+fn storageColors_readRgba32FloatColor(wordIndex: u32) -> vec4<f32> {
+  return vec4<f32>(
+    bitcast<f32>(storageColorsBuffer[wordIndex]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 1u]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 2u]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 3u])
+  );
+}
+
+fn storageColors_readColor(rowIndex: u32) -> vec4<f32> {
+  let wordIndex = storageColors_getWordIndex(rowIndex);
+  if (storageColors.format == STORAGE_COLOR_FORMAT_RGBA8UNORM) {
+    return storageColors_readRgba8UnormColor(wordIndex);
+  }
+  if (storageColors.format == STORAGE_COLOR_FORMAT_RGBA16FLOAT) {
+    return storageColors_readRgba16FloatColor(wordIndex);
+  }
+  return storageColors_readRgba32FloatColor(wordIndex);
+}
+`
+);
+function buildGLSLColorModuleSource(primaryPrefix) {
+  return (
+    /* glsl */
+    `layout(std140) uniform ${primaryPrefix}Uniforms {
   float useByteColors;
-} floatColors;
+} ${primaryPrefix};
 
-vec3 floatColors_normalize(vec3 inputColor) {
-  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+vec3 ${primaryPrefix}_normalize(vec3 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
 }
 
-vec4 floatColors_normalize(vec4 inputColor) {
-  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+vec4 ${primaryPrefix}_normalize(vec4 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
 }
 
-vec4 floatColors_premultiplyAlpha(vec4 inputColor) {
+vec4 ${primaryPrefix}_premultiplyAlpha(vec4 inputColor) {
   return vec4(inputColor.rgb * inputColor.a, inputColor.a);
 }
 
-vec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {
+vec4 ${primaryPrefix}_unpremultiplyAlpha(vec4 inputColor) {
   return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
 }
 
-vec4 floatColors_premultiply_alpha(vec4 inputColor) {
-  return floatColors_premultiplyAlpha(inputColor);
+vec4 ${primaryPrefix}_premultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_premultiplyAlpha(inputColor);
 }
 
-vec4 floatColors_unpremultiply_alpha(vec4 inputColor) {
-  return floatColors_unpremultiplyAlpha(inputColor);
+vec4 ${primaryPrefix}_unpremultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_unpremultiplyAlpha(inputColor);
 }
 `
-);
-var WGSL_UNIFORMS = (
-  /* wgsl */
-  `struct floatColorsUniforms {
+  );
+}
+function buildWGSLColorModuleSource(primaryPrefix) {
+  return (
+    /* wgsl */
+    `struct ${primaryPrefix}Uniforms {
   useByteColors: f32
 };
 
-@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;
+@group(0) @binding(auto) var<uniform> ${primaryPrefix} : ${primaryPrefix}Uniforms;
 
-fn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {
-  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+fn ${primaryPrefix}_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
 }
 
-fn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
-  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+fn ${primaryPrefix}_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
 }
 
-fn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+fn ${primaryPrefix}_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
 }
 
-fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+fn ${primaryPrefix}_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   return select(
     vec4<f32>(0.0),
     vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
@@ -3402,27 +6591,86 @@ fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   );
 }
 
-fn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
-  return floatColors_premultiplyAlpha(inputColor);
+fn ${primaryPrefix}_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return ${primaryPrefix}_premultiplyAlpha(inputColor);
 }
 
-fn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
-  return floatColors_unpremultiplyAlpha(inputColor);
+fn ${primaryPrefix}_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return ${primaryPrefix}_unpremultiplyAlpha(inputColor);
 }
 `
-);
+  );
+}
+function getStorageColorsUniforms(props = {}) {
+  const format = resolveStorageColorFormat(props.format);
+  const formatName = STORAGE_COLOR_FORMAT_NAME_BY_VALUE[format];
+  const byteStride = props.byteStride ?? STORAGE_COLOR_DEFAULT_BYTE_STRIDES[formatName];
+  const byteOffset = props.byteOffset ?? 0;
+  const minimumByteStride = STORAGE_COLOR_FORMAT_BYTE_LENGTHS[formatName];
+  validateStorageColorByteAlignment("byteStride", byteStride);
+  validateStorageColorByteAlignment("byteOffset", byteOffset);
+  if (byteStride < minimumByteStride) {
+    throw new Error(`storageColors byteStride must be at least ${minimumByteStride} for ${formatName}`);
+  }
+  return {
+    format,
+    wordStride: byteStride / Uint32Array.BYTES_PER_ELEMENT,
+    wordOffset: byteOffset / Uint32Array.BYTES_PER_ELEMENT,
+    _padding: 0
+  };
+}
+function resolveStorageColorFormat(format = "rgba8unorm") {
+  if (typeof format === "number") {
+    if (format in STORAGE_COLOR_FORMAT_NAME_BY_VALUE) {
+      return format;
+    }
+  } else if (format in STORAGE_COLOR_FORMAT_BY_NAME) {
+    return STORAGE_COLOR_FORMAT_BY_NAME[format];
+  }
+  throw new Error(`storageColors format must be one of ${Object.keys(STORAGE_COLOR_FORMAT_BY_NAME).join(", ")}`);
+}
+function validateStorageColorByteAlignment(name, value) {
+  if (!Number.isInteger(value) || value < 0 || value % Uint32Array.BYTES_PER_ELEMENT !== 0) {
+    throw new Error(`storageColors ${name} must be a non-negative 4-byte aligned integer`);
+  }
+}
+var colors = {
+  name: "colors",
+  props: {},
+  uniforms: {},
+  vs: COLORS_GLSL,
+  fs: COLORS_GLSL,
+  source: COLORS_WGSL,
+  uniformTypes: COLORS_UNIFORM_TYPES,
+  defaultUniforms: COLORS_DEFAULT_UNIFORMS
+};
 var floatColors = {
   name: "floatColors",
   props: {},
   uniforms: {},
-  vs: GLSL_UNIFORMS,
-  fs: GLSL_UNIFORMS,
-  source: WGSL_UNIFORMS,
-  uniformTypes: {
-    useByteColors: "f32"
-  },
-  defaultUniforms: {
-    useByteColors: true
+  vs: FLOAT_COLORS_GLSL,
+  fs: FLOAT_COLORS_GLSL,
+  source: FLOAT_COLORS_WGSL,
+  uniformTypes: COLORS_UNIFORM_TYPES,
+  defaultUniforms: COLORS_DEFAULT_UNIFORMS
+};
+var storageColors = {
+  name: "storageColors",
+  props: {},
+  uniforms: {},
+  bindings: {},
+  source: STORAGE_COLORS_WGSL,
+  uniformTypes: STORAGE_COLORS_UNIFORM_TYPES,
+  defaultUniforms: STORAGE_COLORS_DEFAULT_UNIFORMS,
+  bindingLayout: [
+    { name: "storageColors", group: 0 },
+    { name: "storageColorsBuffer", group: 0 }
+  ],
+  getUniforms(props = {}) {
+    return {
+      ...getStorageColorsUniforms(props),
+      ...props.colorBuffer ? { storageColorsBuffer: props.colorBuffer } : {}
+    };
   }
 };
 
@@ -3611,8 +6859,223 @@ function getUniforms(opts = {}, prevUniforms) {
   return uniforms;
 }
 
+// dist/modules/engine/filter/filter.js
+var filterShaderModule = {
+  name: "filter",
+  props: {},
+  uniforms: {},
+  bindingLayout: [{ name: "filter", group: 2 }],
+  uniformTypes: {
+    enabled: "i32",
+    min: "f32",
+    max: "f32"
+  },
+  defaultUniforms: {
+    enabled: 1,
+    min: 0,
+    max: 1
+  },
+  vs: (
+    /* glsl */
+    `layout(std140) uniform filterUniforms {
+  int enabled;
+  float min;
+  float max;
+} filterState;
+
+bool filter_isVisible(float value) {
+  return filterState.enabled == 0 || (value >= filterState.min && value <= filterState.max);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `struct FilterUniforms {
+  enabled: i32,
+  min: f32,
+  max: f32,
+};
+
+@group(2) @binding(auto) var<uniform> filterUniforms: FilterUniforms;
+
+fn filter_isVisible(value: f32) -> bool {
+  return filterUniforms.enabled == 0 ||
+    (value >= filterUniforms.min && value <= filterUniforms.max);
+}
+`
+  ),
+  getUniforms(props = {}) {
+    const uniforms = {};
+    if (props.enabled !== void 0) {
+      uniforms.enabled = Number(props.enabled);
+    }
+    if (props.min !== void 0) {
+      uniforms.min = props.min;
+    }
+    if (props.max !== void 0) {
+      uniforms.max = props.max;
+    }
+    return uniforms;
+  }
+};
+var filterShaderPlugin = {
+  name: "filter",
+  modules: [filterShaderModule],
+  vertexInputs: {
+    filterValues: "f32"
+  },
+  glsl: {
+    injections: [
+      {
+        target: "vs:FILTER_POSITION",
+        injection: `if (!filter_isVisible(filterValues)) {
+  position = vec4(2.0, 2.0, 2.0, 1.0);
+}`
+      }
+    ]
+  },
+  wgsl: {
+    injections: [
+      {
+        target: "vs:FILTER_POSITION",
+        injection: `if (!filter_isVisible(filterValues)) {
+  *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+}`
+      }
+    ]
+  }
+};
+
+// dist/modules/engine/clip/clip.js
+var CLIP_MODE_GEOMETRY = 0;
+var CLIP_MODE_INSTANCE = 1;
+var clipShaderModule = {
+  name: "clip",
+  props: {},
+  uniforms: {},
+  bindingLayout: [{ name: "clip", group: 2 }],
+  uniformTypes: {
+    enabled: "i32",
+    mode: "i32",
+    bounds: "vec4<f32>"
+  },
+  defaultUniforms: {
+    enabled: 1,
+    mode: CLIP_MODE_GEOMETRY,
+    bounds: [0, 0, 1, 1]
+  },
+  vs: (
+    /* glsl */
+    `layout(std140) uniform clipUniforms {
+  highp int enabled;
+  highp int mode;
+  highp vec4 bounds;
+} clipState;
+
+bool clip_isInBounds(vec2 coordinates) {
+  return coordinates.x >= clipState.bounds.x &&
+    coordinates.y >= clipState.bounds.y &&
+    coordinates.x < clipState.bounds.z &&
+    coordinates.y < clipState.bounds.w;
+}
+`
+  ),
+  fs: (
+    /* glsl */
+    `layout(std140) uniform clipUniforms {
+  highp int enabled;
+  highp int mode;
+  highp vec4 bounds;
+} clipState;
+
+bool clip_isInBounds(vec2 coordinates) {
+  return coordinates.x >= clipState.bounds.x &&
+    coordinates.y >= clipState.bounds.y &&
+    coordinates.x < clipState.bounds.z &&
+    coordinates.y < clipState.bounds.w;
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `struct ClipUniforms {
+  enabled: i32,
+  mode: i32,
+  bounds: vec4<f32>,
+};
+
+@group(2) @binding(auto) var<uniform> clipUniforms: ClipUniforms;
+
+fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
+  return coordinates.x >= clipUniforms.bounds.x &&
+    coordinates.y >= clipUniforms.bounds.y &&
+    coordinates.x < clipUniforms.bounds.z &&
+    coordinates.y < clipUniforms.bounds.w;
+}
+`
+  ),
+  getUniforms(props = {}) {
+    const uniforms = {};
+    if (props.enabled !== void 0) {
+      uniforms.enabled = Number(props.enabled);
+    }
+    if (props.mode !== void 0) {
+      uniforms.mode = props.mode === "instance" ? CLIP_MODE_INSTANCE : CLIP_MODE_GEOMETRY;
+    }
+    if (props.bounds !== void 0) {
+      uniforms.bounds = props.bounds;
+    }
+    return uniforms;
+  }
+};
+var clipShaderPlugin = {
+  name: "clip",
+  modules: [clipShaderModule],
+  varyings: {
+    clipCoordinates: { type: "vec2<f32>", interpolation: "smooth" }
+  },
+  glsl: {
+    injections: [
+      {
+        target: "vs:CLIP_POSITION",
+        injection: `clipCoordinates = geometryCoordinates;
+if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_INSTANCE} &&
+    !clip_isInBounds(instanceCoordinates)) {
+  position = vec4(2.0, 2.0, 2.0, 1.0);
+}`
+      },
+      {
+        target: "fs:CLIP_COLOR",
+        injection: `if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`
+      }
+    ]
+  },
+  wgsl: {
+    injections: [
+      {
+        target: "vs:CLIP_POSITION",
+        injection: `clipCoordinates = geometryCoordinates;
+if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_INSTANCE} &&
+    !clip_isInBounds(instanceCoordinates)) {
+  *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+}`
+      },
+      {
+        target: "fs:CLIP_COLOR",
+        injection: `if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`
+      }
+    ]
+  }
+};
+
 // dist/modules/engine/skin/skin.js
-var import_core2 = require("@math.gl/core");
+var import_core5 = require("@math.gl/core");
 var SKIN_MAX_JOINTS = 20;
 var source2 = (
   /* wgsl */
@@ -3674,7 +7137,7 @@ var skin = {
     const countib = inverseBindMatrices.value.length / 16;
     for (let i = 0; i < countib; i++) {
       const slice = inverseBindMatrices.value.subarray(i * 16, i * 16 + 16);
-      matsib.push(new import_core2.Matrix4(Array.from(slice)));
+      matsib.push(new import_core5.Matrix4(Array.from(slice)));
     }
     const top = scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(skeleton);
     const matrices = {};
@@ -3688,7 +7151,7 @@ var skin = {
         break;
       const worldMat = matrices[scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(nodeIndex).id];
       const invBindMat = matsib[i];
-      const Z = new import_core2.Matrix4().copy(worldMat).multiplyRight(invBindMat);
+      const Z = new import_core5.Matrix4().copy(worldMat).multiplyRight(invBindMat);
       const off = i * 16;
       for (let j = 0; j < 16; j++) {
         mats[off + j] = Z[j];
@@ -3704,7 +7167,7 @@ var skin = {
 };
 
 // dist/modules/lighting/lights/lighting.js
-var import_core3 = require("@luma.gl/core");
+var import_core6 = require("@luma.gl/core");
 
 // dist/modules/lighting/lights/lighting-glsl.js
 var lightingUniformsGLSL = (
@@ -3987,7 +7450,7 @@ function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [],
     directionalLightCount++;
   }
   if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
-    import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
+    import_core6.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
   return {
     ambientColor: convertColor(ambientLight, useByteColors),
@@ -4604,6 +8067,631 @@ var phongMaterial = {
   }
 };
 
+// dist/modules/lighting/water-material/water-shaders-glsl.js
+var WATER_VS = (
+  /* glsl */
+  `layout(std140) uniform waterMaterialUniforms {
+  uniform float time;
+  uniform vec3 baseColor;
+  uniform float opacity;
+  uniform vec3 fresnelColor;
+  uniform float fresnelPower;
+  uniform float specularIntensity;
+  uniform float normalStrength;
+  uniform int mappingMode;
+  uniform vec2 coordinateScale;
+  uniform vec2 coordinateOffset;
+  uniform vec2 waveADirection;
+  uniform float waveASpeed;
+  uniform float waveAFrequency;
+  uniform float waveAAmplitude;
+  uniform vec2 waveBDirection;
+  uniform float waveBSpeed;
+  uniform float waveBFrequency;
+  uniform float waveBAmplitude;
+} waterMaterial;
+`
+);
+var WATER_FS = (
+  /* glsl */
+  `layout(std140) uniform waterMaterialUniforms {
+  uniform float time;
+  uniform vec3 baseColor;
+  uniform float opacity;
+  uniform vec3 fresnelColor;
+  uniform float fresnelPower;
+  uniform float specularIntensity;
+  uniform float normalStrength;
+  uniform int mappingMode;
+  uniform vec2 coordinateScale;
+  uniform vec2 coordinateOffset;
+  uniform vec2 waveADirection;
+  uniform float waveASpeed;
+  uniform float waveAFrequency;
+  uniform float waveAAmplitude;
+  uniform vec2 waveBDirection;
+  uniform float waveBSpeed;
+  uniform float waveBFrequency;
+  uniform float waveBAmplitude;
+} waterMaterial;
+
+vec2 water_getDirection(vec2 direction) {
+  float directionLength = length(direction);
+  return directionLength > 0.0 ? direction / directionLength : vec2(1.0, 0.0);
+}
+
+vec2 water_getCoordinates(vec3 position_worldspace, vec3 position_objectspace, vec2 uv) {
+  vec2 baseCoordinates = uv;
+  if (waterMaterial.mappingMode == 1) {
+    baseCoordinates = position_worldspace.xz;
+  } else if (waterMaterial.mappingMode == 2) {
+    vec3 globeDirection = normalize(position_objectspace);
+    float longitude = atan(globeDirection.x, globeDirection.z);
+    float latitude = asin(clamp(globeDirection.y, -1.0, 1.0));
+    baseCoordinates = vec2(longitude, latitude);
+  }
+  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;
+}
+
+vec2 water_getWaveGradient(
+  vec2 coordinates,
+  vec2 direction,
+  float speed,
+  float frequency,
+  float amplitude
+) {
+  vec2 normalizedDirection = water_getDirection(direction);
+  float phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;
+  return cos(phase) * normalizedDirection * frequency * amplitude;
+}
+
+vec3 water_getTangent(vec3 normal_worldspace) {
+  vec3 referenceAxis = abs(normal_worldspace.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+  return normalize(cross(referenceAxis, normal_worldspace));
+}
+
+vec3 water_getNormal(
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec2 coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);
+  vec2 gradient =
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveADirection,
+      waterMaterial.waveASpeed,
+      waterMaterial.waveAFrequency,
+      waterMaterial.waveAAmplitude
+    ) +
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveBDirection,
+      waterMaterial.waveBSpeed,
+      waterMaterial.waveBFrequency,
+      waterMaterial.waveBAmplitude
+    );
+
+  vec3 tangent = water_getTangent(normal_worldspace);
+  vec3 bitangent = normalize(cross(normal_worldspace, tangent));
+  vec3 perturbation =
+    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);
+
+  return normalize(normal_worldspace + perturbation);
+}
+
+vec3 water_getSpecularContribution(
+  vec3 light_direction,
+  vec3 view_direction,
+  vec3 normal_worldspace,
+  vec3 light_color,
+  float fresnel
+) {
+  vec3 halfway_direction = normalize(light_direction + view_direction);
+  float specular =
+    pow(max(dot(normal_worldspace, halfway_direction), 0.0), 72.0) *
+    waterMaterial.specularIntensity *
+    (0.25 + 0.75 * fresnel);
+
+  return waterMaterial.fresnelColor * light_color * specular;
+}
+
+vec4 water_getColorMapped(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec3 waterNormal = water_getNormal(
+    position_worldspace,
+    position_objectspace,
+    normalize(normal_worldspace),
+    uv
+  );
+  vec3 viewDirection = normalize(cameraPosition - position_worldspace);
+  float fresnel =
+    pow(
+      1.0 - max(dot(viewDirection, waterNormal), 0.0),
+      max(waterMaterial.fresnelPower, 0.0001)
+    );
+  vec3 surfaceColor = mix(
+    waterMaterial.baseColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel * 0.6, 0.0, 1.0)
+  );
+
+  if (lighting.enabled == 0) {
+    return vec4(surfaceColor, waterMaterial.opacity);
+  }
+
+  vec3 lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 lightPosition = pointLight.position;
+    vec3 lightDirection = normalize(lightPosition - position_worldspace);
+    float attenuation =
+      getPointLightAttenuation(pointLight, distance(lightPosition, position_worldspace));
+    vec3 incidentLight = pointLight.color / attenuation;
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 lightPosition = spotLight.position;
+    vec3 lightDirection = normalize(lightPosition - position_worldspace);
+    float attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    vec3 incidentLight = spotLight.color / attenuation;
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    vec3 lightDirection = normalize(-directionalLight.direction);
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * directionalLight.color * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      directionalLight.color,
+      fresnel
+    );
+  }
+
+  lightColor = mix(lightColor, waterMaterial.fresnelColor, clamp(fresnel, 0.0, 1.0) * 0.35);
+  return vec4(lightColor, waterMaterial.opacity);
+}
+
+vec4 water_getColor(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  return water_getColorMapped(
+    cameraPosition,
+    position_worldspace,
+    position_worldspace,
+    normal_worldspace,
+    uv
+  );
+}
+`
+);
+
+// dist/modules/lighting/water-material/water-shaders-wgsl.js
+var WATER_WGSL = (
+  /* wgsl */
+  `struct waterMaterialUniforms {
+  time: f32,
+  baseColor: vec3<f32>,
+  opacity: f32,
+  fresnelColor: vec3<f32>,
+  fresnelPower: f32,
+  specularIntensity: f32,
+  normalStrength: f32,
+  mappingMode: i32,
+  coordinateScale: vec2<f32>,
+  coordinateOffset: vec2<f32>,
+  waveADirection: vec2<f32>,
+  waveASpeed: f32,
+  waveAFrequency: f32,
+  waveAAmplitude: f32,
+  waveBDirection: vec2<f32>,
+  waveBSpeed: f32,
+  waveBFrequency: f32,
+  waveBAmplitude: f32,
+};
+
+@group(3) @binding(auto) var<uniform> waterMaterial : waterMaterialUniforms;
+
+fn water_getDirection(direction: vec2<f32>) -> vec2<f32> {
+  let directionLength = length(direction);
+  if (directionLength > 0.0) {
+    return direction / directionLength;
+  }
+
+  return vec2<f32>(1.0, 0.0);
+}
+
+fn water_getCoordinates(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec2<f32> {
+  var baseCoordinates = uv;
+  if (waterMaterial.mappingMode == 1) {
+    baseCoordinates = position_worldspace.xz;
+  } else if (waterMaterial.mappingMode == 2) {
+    let globeDirection = normalize(position_objectspace);
+    let longitude = atan2(globeDirection.x, globeDirection.z);
+    let latitude = asin(clamp(globeDirection.y, -1.0, 1.0));
+    baseCoordinates = vec2<f32>(longitude, latitude);
+  }
+
+  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;
+}
+
+fn water_getWaveGradient(
+  coordinates: vec2<f32>,
+  direction: vec2<f32>,
+  speed: f32,
+  frequency: f32,
+  amplitude: f32
+) -> vec2<f32> {
+  let normalizedDirection = water_getDirection(direction);
+  let phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;
+  return cos(phase) * normalizedDirection * frequency * amplitude;
+}
+
+fn water_getTangent(normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var referenceAxis = vec3<f32>(0.0, 0.0, 1.0);
+  if (abs(normal_worldspace.z) >= 0.999) {
+    referenceAxis = vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(cross(referenceAxis, normal_worldspace));
+}
+
+fn water_getNormal(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec3<f32> {
+  let coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);
+  let gradient =
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveADirection,
+      waterMaterial.waveASpeed,
+      waterMaterial.waveAFrequency,
+      waterMaterial.waveAAmplitude
+    ) +
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveBDirection,
+      waterMaterial.waveBSpeed,
+      waterMaterial.waveBFrequency,
+      waterMaterial.waveBAmplitude
+    );
+  let tangent = water_getTangent(normal_worldspace);
+  let bitangent = normalize(cross(normal_worldspace, tangent));
+  let perturbation =
+    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);
+
+  return normalize(normal_worldspace + perturbation);
+}
+
+fn water_getSpecularContribution(
+  light_direction: vec3<f32>,
+  view_direction: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  light_color: vec3<f32>,
+  fresnel: f32
+) -> vec3<f32> {
+  let halfwayDirection = normalize(light_direction + view_direction);
+  let specular =
+    pow(max(dot(normal_worldspace, halfwayDirection), 0.0), 72.0) *
+    waterMaterial.specularIntensity *
+    (0.25 + 0.75 * fresnel);
+
+  return waterMaterial.fresnelColor * light_color * specular;
+}
+
+fn water_getColorMapped(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  let waterNormal = water_getNormal(
+    position_worldspace,
+    position_objectspace,
+    normalize(normal_worldspace),
+    uv
+  );
+  let viewDirection = normalize(cameraPosition - position_worldspace);
+  let fresnel =
+    pow(
+      1.0 - max(dot(viewDirection, waterNormal), 0.0),
+      max(waterMaterial.fresnelPower, 0.0001)
+    );
+  let surfaceColor = mix(
+    waterMaterial.baseColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel * 0.6, 0.0, 1.0)
+  );
+
+  if (lighting.enabled == 0) {
+    return vec4<f32>(surfaceColor, waterMaterial.opacity);
+  }
+
+  var lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight = lighting_getPointLight(i);
+    let lightPosition = pointLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(lightPosition, position_worldspace)
+    );
+    let incidentLight = pointLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight = lighting_getSpotLight(i);
+    let lightPosition = spotLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    let incidentLight = spotLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight = lighting_getDirectionalLight(i);
+    let lightDirection = normalize(-directionalLight.direction);
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * directionalLight.color * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      directionalLight.color,
+      fresnel
+    );
+  }
+
+  lightColor = mix(
+    lightColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel, 0.0, 1.0) * 0.35
+  );
+  return vec4<f32>(lightColor, waterMaterial.opacity);
+}
+
+fn water_getColor(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  return water_getColorMapped(
+    cameraPosition,
+    position_worldspace,
+    position_worldspace,
+    normal_worldspace,
+    uv
+  );
+}
+`
+);
+
+// dist/modules/lighting/water-material/water-material.js
+var DEFAULT_WATER_MATERIAL_UNIFORMS = {
+  time: 0,
+  baseColor: [0.04, 0.18, 0.31],
+  opacity: 0.82,
+  fresnelColor: [0.86, 0.95, 1],
+  fresnelPower: 5,
+  specularIntensity: 1.4,
+  normalStrength: 0.35,
+  mappingMode: 0,
+  coordinateScale: [1, 1],
+  coordinateOffset: [0, 0],
+  waveADirection: [0.9805806756909201, 0.19611613513818402],
+  waveASpeed: 0.6,
+  waveAFrequency: 4,
+  waveAAmplitude: 0.08,
+  waveBDirection: [0.09950371902099893, 0.9950371902099893],
+  waveBSpeed: -0.45,
+  waveBFrequency: 7,
+  waveBAmplitude: 0.04
+};
+var waterMaterial = {
+  name: "waterMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "waterMaterial", group: 3 }],
+  dependencies: [lighting],
+  source: WATER_WGSL,
+  vs: WATER_VS,
+  fs: WATER_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    time: "f32",
+    baseColor: "vec3<f32>",
+    opacity: "f32",
+    fresnelColor: "vec3<f32>",
+    fresnelPower: "f32",
+    specularIntensity: "f32",
+    normalStrength: "f32",
+    mappingMode: "i32",
+    coordinateScale: "vec2<f32>",
+    coordinateOffset: "vec2<f32>",
+    waveADirection: "vec2<f32>",
+    waveASpeed: "f32",
+    waveAFrequency: "f32",
+    waveAAmplitude: "f32",
+    waveBDirection: "vec2<f32>",
+    waveBSpeed: "f32",
+    waveBFrequency: "f32",
+    waveBAmplitude: "f32"
+  },
+  defaultUniforms: DEFAULT_WATER_MATERIAL_UNIFORMS,
+  getUniforms(props, previousUniforms = DEFAULT_WATER_MATERIAL_UNIFORMS) {
+    const { mapping, ...uniformProps } = props || {};
+    const uniforms = mergeWaterMaterialUniforms(previousUniforms);
+    if (uniformProps.time !== void 0) {
+      uniforms.time = uniformProps.time;
+    }
+    if (uniformProps.opacity !== void 0) {
+      uniforms.opacity = uniformProps.opacity;
+    }
+    if (uniformProps.fresnelPower !== void 0) {
+      uniforms.fresnelPower = uniformProps.fresnelPower;
+    }
+    if (uniformProps.specularIntensity !== void 0) {
+      uniforms.specularIntensity = uniformProps.specularIntensity;
+    }
+    if (uniformProps.normalStrength !== void 0) {
+      uniforms.normalStrength = uniformProps.normalStrength;
+    }
+    if (uniformProps.coordinateScale !== void 0) {
+      uniforms.coordinateScale = [
+        Number(uniformProps.coordinateScale[0]),
+        Number(uniformProps.coordinateScale[1])
+      ];
+    }
+    if (uniformProps.coordinateOffset !== void 0) {
+      uniforms.coordinateOffset = [
+        Number(uniformProps.coordinateOffset[0]),
+        Number(uniformProps.coordinateOffset[1])
+      ];
+    }
+    if (uniformProps.waveASpeed !== void 0) {
+      uniforms.waveASpeed = uniformProps.waveASpeed;
+    }
+    if (uniformProps.waveAFrequency !== void 0) {
+      uniforms.waveAFrequency = uniformProps.waveAFrequency;
+    }
+    if (uniformProps.waveAAmplitude !== void 0) {
+      uniforms.waveAAmplitude = uniformProps.waveAAmplitude;
+    }
+    if (uniformProps.waveBSpeed !== void 0) {
+      uniforms.waveBSpeed = uniformProps.waveBSpeed;
+    }
+    if (uniformProps.waveBFrequency !== void 0) {
+      uniforms.waveBFrequency = uniformProps.waveBFrequency;
+    }
+    if (uniformProps.waveBAmplitude !== void 0) {
+      uniforms.waveBAmplitude = uniformProps.waveBAmplitude;
+    }
+    if (uniformProps.baseColor) {
+      uniforms.baseColor = normalizeColor3(uniformProps.baseColor);
+    }
+    if (uniformProps.fresnelColor) {
+      uniforms.fresnelColor = normalizeColor3(uniformProps.fresnelColor);
+    }
+    if (uniformProps.waveADirection) {
+      uniforms.waveADirection = normalizeDirection2(uniformProps.waveADirection);
+    }
+    if (uniformProps.waveBDirection) {
+      uniforms.waveBDirection = normalizeDirection2(uniformProps.waveBDirection);
+    }
+    if (mapping !== void 0) {
+      uniforms.mappingMode = mapping === "world" ? 1 : mapping === "object" ? 2 : 0;
+    }
+    return uniforms;
+  }
+};
+function mergeWaterMaterialUniforms(previousUniforms) {
+  return {
+    time: previousUniforms.time ?? DEFAULT_WATER_MATERIAL_UNIFORMS.time,
+    baseColor: previousUniforms.baseColor ? normalizeColor3(previousUniforms.baseColor) : DEFAULT_WATER_MATERIAL_UNIFORMS.baseColor,
+    opacity: previousUniforms.opacity ?? DEFAULT_WATER_MATERIAL_UNIFORMS.opacity,
+    fresnelColor: previousUniforms.fresnelColor ? normalizeColor3(previousUniforms.fresnelColor) : DEFAULT_WATER_MATERIAL_UNIFORMS.fresnelColor,
+    fresnelPower: previousUniforms.fresnelPower ?? DEFAULT_WATER_MATERIAL_UNIFORMS.fresnelPower,
+    specularIntensity: previousUniforms.specularIntensity ?? DEFAULT_WATER_MATERIAL_UNIFORMS.specularIntensity,
+    normalStrength: previousUniforms.normalStrength ?? DEFAULT_WATER_MATERIAL_UNIFORMS.normalStrength,
+    mappingMode: previousUniforms.mappingMode ?? DEFAULT_WATER_MATERIAL_UNIFORMS.mappingMode,
+    coordinateScale: previousUniforms.coordinateScale ? [Number(previousUniforms.coordinateScale[0]), Number(previousUniforms.coordinateScale[1])] : DEFAULT_WATER_MATERIAL_UNIFORMS.coordinateScale,
+    coordinateOffset: previousUniforms.coordinateOffset ? [Number(previousUniforms.coordinateOffset[0]), Number(previousUniforms.coordinateOffset[1])] : DEFAULT_WATER_MATERIAL_UNIFORMS.coordinateOffset,
+    waveADirection: previousUniforms.waveADirection ? normalizeDirection2(previousUniforms.waveADirection) : DEFAULT_WATER_MATERIAL_UNIFORMS.waveADirection,
+    waveASpeed: previousUniforms.waveASpeed ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveASpeed,
+    waveAFrequency: previousUniforms.waveAFrequency ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveAFrequency,
+    waveAAmplitude: previousUniforms.waveAAmplitude ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveAAmplitude,
+    waveBDirection: previousUniforms.waveBDirection ? normalizeDirection2(previousUniforms.waveBDirection) : DEFAULT_WATER_MATERIAL_UNIFORMS.waveBDirection,
+    waveBSpeed: previousUniforms.waveBSpeed ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBSpeed,
+    waveBFrequency: previousUniforms.waveBFrequency ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBFrequency,
+    waveBAmplitude: previousUniforms.waveBAmplitude ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBAmplitude
+  };
+}
+function normalizeColor3(color) {
+  const normalizedColor = [Number(color[0]), Number(color[1]), Number(color[2])];
+  const maxChannel = Math.max(...normalizedColor.map((channel) => Math.abs(channel)));
+  if (maxChannel > 1) {
+    normalizedColor[0] /= 255;
+    normalizedColor[1] /= 255;
+    normalizedColor[2] /= 255;
+  }
+  return normalizedColor;
+}
+function normalizeDirection2(direction) {
+  const x = Number(direction[0]);
+  const y = Number(direction[1]);
+  const length = Math.hypot(x, y);
+  if (length === 0) {
+    return [1, 0];
+  }
+  return [x / length, y / length];
+}
+
 // dist/modules/lighting/pbr-material/pbr-material-glsl.js
 var vs3 = (
   /* glsl */