@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.11

package/dist/lib/shader-assembly/assemble-wgsl-shaders.cjs

@@ -0,0 +1,498 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assemble_wgsl_shaders_exports = {};
+__export(assemble_wgsl_shaders_exports, {
+  RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT: () => RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT,
+  allocateApplicationAutoBindingLocation: () => allocateApplicationAutoBindingLocation,
+  allocateAutoBindingLocation: () => allocateAutoBindingLocation,
+  appendGeneratedVaryingInjections: () => appendGeneratedVaryingInjections,
+  appendGeneratedVertexInputInjections: () => appendGeneratedVertexInputInjections,
+  assembleShaderWGSL: () => assembleShaderWGSL,
+  assembleWGSLShader: () => assembleWGSLShader,
+  assembleWGSLSource: () => assembleWGSLSource,
+  assertNoUnresolvedAutoBindings: () => assertNoUnresolvedAutoBindings,
+  claimReservedBindingLocation: () => claimReservedBindingLocation,
+  formatWGSLBindingAssignmentComments: () => formatWGSLBindingAssignmentComments,
+  formatWGSLSourceSnippet: () => formatWGSLSourceSnippet,
+  getBindingRegistryKey: () => getBindingRegistryKey,
+  getUsedBindingsByGroupFromApplicationWGSL: () => getUsedBindingsByGroupFromApplicationWGSL,
+  getWGSLDeclarationInjections: () => getWGSLDeclarationInjections,
+  getWGSLModuleNameAtIndex: () => getWGSLModuleNameAtIndex,
+  getWGSLShaderInjectionTargets: () => getWGSLShaderInjectionTargets,
+  isInApplicationWGSLSection: () => isInApplicationWGSLSection,
+  registerUsedBindingLocation: () => registerUsedBindingLocation,
+  relocateWGSLApplicationBindingMatch: () => relocateWGSLApplicationBindingMatch,
+  relocateWGSLApplicationBindings: () => relocateWGSLApplicationBindings,
+  relocateWGSLModuleBindingMatch: () => relocateWGSLModuleBindingMatch,
+  relocateWGSLModuleBindings: () => relocateWGSLModuleBindings,
+  reserveModuleBindings: () => reserveModuleBindings,
+  validateApplicationWGSLBinding: () => validateApplicationWGSLBinding,
+  validateModuleWGSLBinding: () => validateModuleWGSLBinding
+});
+module.exports = __toCommonJS(assemble_wgsl_shaders_exports);
+var import_wgsl_binding_debug = require("./wgsl-binding-debug.cjs");
+var import_wgsl_interface_scan = require("./wgsl-interface-scan.cjs");
+var import_wgsl_injection_target_names = require("./wgsl-injection-target-names.cjs");
+var import_shader_module_dependencies = require("../shader-module/shader-module-dependencies.cjs");
+var import_shader_assembly_shared = require("./shader-assembly-shared.cjs");
+var import_assert = require("../utils/assert.cjs");
+var import_preprocessor = require("../preprocessor/preprocessor.cjs");
+var import_shader_plugin_vertex_inputs = require("./shader-plugin-vertex-inputs.cjs");
+var import_shader_plugin_varyings = require("./shader-plugin-varyings.cjs");
+var import_shader_injection_targets = require("./shader-injection-targets.cjs");
+var import_shader_injections = require("./shader-injections.cjs");
+var import_shader_module = require("../shader-module/shader-module.cjs");
+var import_wgsl_binding_scan = require("./wgsl-binding-scan.cjs");
+const RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
+function assembleWGSLShader(options) {
+  const assembledShader = assembleWGSLSource(options);
+  return {
+    ...assembledShader,
+    bindingTable: (0, import_wgsl_binding_debug.getShaderBindingDebugRowsFromWGSL)(assembledShader.source, assembledShader.bindingAssignments),
+    shaderLayout: (0, import_wgsl_interface_scan.scanWGSLInterface)(assembledShader.source, {
+      vertexEntryPoint: options.vertexEntryPoint,
+      scanVertexAttributes: options.scanVertexAttributes
+    })
+  };
+}
+function assembleWGSLSource(options) {
+  const modules = (0, import_shader_module_dependencies.getShaderModuleDependencies)(options.modules || []);
+  const { source, bindingAssignments } = assembleShaderWGSL(options.platformInfo, {
+    ...options,
+    source: options.source,
+    stage: "vertex",
+    modules
+  });
+  return {
+    source,
+    getUniforms: (0, import_shader_assembly_shared.assembleGetUniforms)(modules),
+    bindingAssignments
+  };
+}
+function assembleShaderWGSL(platformInfo, options) {
+  const {
+    // id,
+    source,
+    stage,
+    modules,
+    // defines = {},
+    defines = {},
+    injectionTargets = [],
+    inject = {},
+    pluginInjections = {},
+    pluginVertexInputs = {},
+    pluginInterStageVariables = {},
+    vertexEntryPoint = "vertexMain",
+    fragmentEntryPoint = "fragmentMain",
+    log
+  } = options;
+  (0, import_assert.assert)(typeof source === "string", "shader source must be a string");
+  const preprocessedSource = (0, import_preprocessor.preprocess)(source, { defines });
+  const pluginVertexInputAssembly = (0, import_shader_plugin_vertex_inputs.assembleShaderPluginVertexInputsWGSL)(preprocessedSource, vertexEntryPoint, pluginVertexInputs);
+  const pluginVaryingAssembly = (0, import_shader_plugin_varyings.assembleShaderPluginInterStageVariablesWGSL)(pluginVertexInputAssembly.source, vertexEntryPoint, fragmentEntryPoint, pluginInterStageVariables);
+  const coreSource = pluginVaryingAssembly.source;
+  let assembledSource = "";
+  const injectionTargetMap = (0, import_shader_injection_targets.normalizeShaderInjectionTargets)(injectionTargets, options.pluginInjectionTargets, "wgsl");
+  const targetInjections = {};
+  const declInjections = {};
+  const mainInjections = {};
+  (0, import_shader_assembly_shared.appendInjections)(pluginInjections, targetInjections, declInjections, mainInjections);
+  const applicationInjections = Array.isArray(inject) ? (0, import_shader_injections.resolveShaderInjections)(inject, "wgsl") : {};
+  (0, import_shader_assembly_shared.appendInjections)(applicationInjections, targetInjections, declInjections, mainInjections);
+  const injectionMap = Array.isArray(inject) ? {} : inject;
+  for (const key in injectionMap) {
+    const injection = typeof injectionMap[key] === "string" ? { injection: injectionMap[key], order: 0 } : injectionMap[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] = [...declInjections[key] || [], injection];
+        } else {
+          mainInjections[key] = [...mainInjections[key] || [], injection];
+        }
+      } else {
+        targetInjections[key] = [...targetInjections[key] || [], injection];
+      }
+    } else {
+      mainInjections[key] = [...mainInjections[key] || [], injection];
+    }
+  }
+  appendGeneratedVertexInputInjections(pluginVertexInputAssembly.declarations, pluginVertexInputAssembly.initialization, declInjections, mainInjections);
+  appendGeneratedVaryingInjections(pluginVaryingAssembly, declInjections, mainInjections);
+  (0, import_shader_injection_targets.validateShaderInjectionTargetInjections)(injectionTargetMap, targetInjections);
+  const modulesToInject = modules.map((module2) => ({
+    module: module2,
+    source: (0, import_preprocessor.preprocess)((0, import_shader_assembly_shared.getShaderModuleSource)(module2, "wgsl", log), { defines })
+  }));
+  const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(applicationRelocation.source);
+  const reservedBindingKeysByGroup = reserveModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
+  const bindingAssignments = [];
+  const relocatedModules = modulesToInject.map(({ module: module2, source: moduleSource }) => {
+    const relocation = relocateWGSLModuleBindings(moduleSource, module2, {
+      usedBindingsByGroup,
+      bindingRegistry: options._bindingRegistry,
+      reservedBindingKeysByGroup
+    });
+    bindingAssignments.push(...relocation.bindingAssignments);
+    return { module: module2, source: relocation.source };
+  });
+  for (const { module: module2, source: moduleSource } of relocatedModules) {
+    if (log) {
+      (0, import_shader_module.checkShaderModuleDeprecations)(module2, coreSource, log);
+    }
+    assembledSource += moduleSource;
+  }
+  assembledSource += import_shader_assembly_shared.INJECT_SHADER_DECLARATIONS;
+  assembledSource = (0, import_shader_injections.injectShader)(assembledSource, stage, getWGSLDeclarationInjections(declInjections), false, "wgsl", { vertex: vertexEntryPoint, fragment: fragmentEntryPoint });
+  const targetNames = (0, import_wgsl_injection_target_names.getWGSLInjectionTargetNames)(injectionTargetMap, [
+    assembledSource,
+    applicationRelocation.source,
+    ...Object.values(targetInjections).flat().map((injection) => injection.injection),
+    ...Object.values(mainInjections).flat().map((injection) => injection.injection)
+  ].join("\n"));
+  assembledSource += getWGSLShaderInjectionTargets(injectionTargetMap, targetInjections, targetNames);
+  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
+  assembledSource += applicationRelocation.source;
+  assembledSource = (0, import_shader_injections.injectShader)(assembledSource, stage, mainInjections, false, "wgsl", {
+    vertex: vertexEntryPoint,
+    fragment: fragmentEntryPoint
+  });
+  assembledSource = (0, import_wgsl_injection_target_names.resolveWGSLInjectionTargetNames)(assembledSource, injectionTargetMap, targetNames);
+  assertNoUnresolvedAutoBindings(assembledSource);
+  return { source: assembledSource, bindingAssignments };
+}
+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 getWGSLDeclarationInjections(declarationInjections) {
+  const unifiedDeclarations = [
+    ...declarationInjections["vs:#decl"] || [],
+    ...declarationInjections["fs:#decl"] || []
+  ];
+  return unifiedDeclarations.length ? { "vs:#decl": unifiedDeclarations } : {};
+}
+function getWGSLShaderInjectionTargets(injectionTargetMap, targetInjections, names = (0, import_wgsl_injection_target_names.getWGSLInjectionTargetNames)(injectionTargetMap)) {
+  return ["vertex", "fragment"].map((stage) => {
+    const targets = Object.fromEntries(Object.entries(injectionTargetMap[stage]).map(([key, target]) => {
+      var _a;
+      const name = key.slice(3);
+      const emittedName = ((_a = names.get(name)) == null ? void 0 : _a[stage]) || name;
+      return [key, { ...target, signature: emittedName + target.signature.slice(name.length) }];
+    }));
+    return (0, import_shader_injection_targets.getShaderInjectionTargets)(targets, targetInjections, "wgsl");
+  }).join("");
+}
+function getUsedBindingsByGroupFromApplicationWGSL(source) {
+  const usedBindingsByGroup = /* @__PURE__ */ new Map();
+  for (const match of (0, import_wgsl_binding_scan.getWGSLBindingDeclarationMatches)(source, import_wgsl_binding_scan.WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES)) {
+    const location = Number(match.bindingToken);
+    const group = Number(match.groupToken);
+    validateApplicationWGSLBinding(group, location, match.name);
+    registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${match.name}"`);
+  }
+  return usedBindingsByGroup;
+}
+function relocateWGSLApplicationBindings(source) {
+  const declarationMatches = (0, import_wgsl_binding_scan.getWGSLBindingDeclarationMatches)(source, import_wgsl_binding_scan.WGSL_BINDING_DECLARATION_REGEXES);
+  const usedBindingsByGroup = /* @__PURE__ */ new Map();
+  for (const declarationMatch of declarationMatches) {
+    if (declarationMatch.bindingToken === "auto") {
+      continue;
+    }
+    const location = Number(declarationMatch.bindingToken);
+    const group = Number(declarationMatch.groupToken);
+    validateApplicationWGSLBinding(group, location, declarationMatch.name);
+    registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${declarationMatch.name}"`);
+  }
+  const relocationState = {
+    sawSupportedBindingDeclaration: declarationMatches.length > 0
+  };
+  const relocatedSource = (0, import_wgsl_binding_scan.replaceWGSLBindingDeclarationMatches)(source, import_wgsl_binding_scan.WGSL_BINDING_DECLARATION_REGEXES, (declarationMatch) => relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState));
+  if ((0, import_wgsl_binding_scan.hasWGSLAutoBinding)(source) && !relocationState.sawSupportedBindingDeclaration) {
+    throw new Error('Unsupported @binding(auto) declaration form in application WGSL. Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.');
+  }
+  return { source: relocatedSource };
+}
+function relocateWGSLModuleBindings(moduleSource, module2, context) {
+  const bindingAssignments = [];
+  const declarationMatches = (0, import_wgsl_binding_scan.getWGSLBindingDeclarationMatches)(moduleSource, import_wgsl_binding_scan.MODULE_WGSL_BINDING_DECLARATION_REGEXES);
+  const relocationState = {
+    sawSupportedBindingDeclaration: declarationMatches.length > 0,
+    nextHintedBindingLocation: typeof module2.firstBindingSlot === "number" ? module2.firstBindingSlot : null
+  };
+  const relocatedSource = (0, import_wgsl_binding_scan.replaceWGSLBindingDeclarationMatches)(moduleSource, import_wgsl_binding_scan.MODULE_WGSL_BINDING_DECLARATION_REGEXES, (declarationMatch) => relocateWGSLModuleBindingMatch(declarationMatch, {
+    module: module2,
+    context,
+    bindingAssignments,
+    relocationState
+  }));
+  if ((0, import_wgsl_binding_scan.hasWGSLAutoBinding)(moduleSource) && !relocationState.sawSupportedBindingDeclaration) {
+    throw new Error(`Unsupported @binding(auto) declaration form in module "${module2.name}". Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.`);
+  }
+  return { source: relocatedSource, bindingAssignments };
+}
+function relocateWGSLModuleBindingMatch(declarationMatch, params) {
+  var _a, _b;
+  const { module: module2, context, bindingAssignments, relocationState } = params;
+  const { match, bindingToken, groupToken, name } = declarationMatch;
+  const group = Number(groupToken);
+  if (bindingToken === "auto") {
+    const registryKey2 = getBindingRegistryKey(group, module2.name, name);
+    const registryLocation = (_a = context.bindingRegistry) == null ? void 0 : _a.get(registryKey2);
+    const location2 = registryLocation !== void 0 ? registryLocation : allocateAutoBindingLocation(group, context.usedBindingsByGroup, module2.name, relocationState.nextHintedBindingLocation ?? void 0, context.bindingRegistry);
+    validateModuleWGSLBinding(module2.name, group, location2, name);
+    if (registryLocation !== void 0 && claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location2, registryKey2)) {
+      bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+    }
+    registerUsedBindingLocation(context.usedBindingsByGroup, group, location2, `module "${module2.name}" binding "${name}"`);
+    (_b = context.bindingRegistry) == null ? void 0 : _b.set(registryKey2, location2);
+    bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+    if (relocationState.nextHintedBindingLocation !== null && registryLocation === void 0) {
+      relocationState.nextHintedBindingLocation = location2 + 1;
+    }
+    return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+  }
+  const location = Number(bindingToken);
+  validateModuleWGSLBinding(module2.name, group, location, name);
+  const registryKey = getBindingRegistryKey(group, module2.name, name);
+  if (!claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location, registryKey)) {
+    registerUsedBindingLocation(context.usedBindingsByGroup, group, location, `module "${module2.name}" binding "${name}"`);
+  }
+  bindingAssignments.push({ moduleName: module2.name, name, group, location });
+  return match;
+}
+function relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState) {
+  const { match, bindingToken, groupToken, name } = declarationMatch;
+  const group = Number(groupToken);
+  if (bindingToken === "auto") {
+    const location = allocateApplicationAutoBindingLocation(group, usedBindingsByGroup);
+    validateApplicationWGSLBinding(group, location, name);
+    registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${name}"`);
+    return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location})`);
+  }
+  relocationState.sawSupportedBindingDeclaration = true;
+  return match;
+}
+function reserveModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
+  const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
+  const autoBindings = [];
+  function reserveBinding(group, location, registryKey, label) {
+    registerUsedBindingLocation(usedBindingsByGroup, group, location, label);
+    const reservedBindingKeys = reservedBindingKeysByGroup.get(group) || /* @__PURE__ */ new Map();
+    reservedBindingKeys.set(location, registryKey);
+    reservedBindingKeysByGroup.set(group, reservedBindingKeys);
+  }
+  for (const { module: module2, source } of modules) {
+    for (const binding of (0, import_wgsl_binding_scan.getWGSLBindingDeclarationMatches)(source, import_wgsl_binding_scan.MODULE_WGSL_BINDING_DECLARATION_REGEXES)) {
+      const group = Number(binding.groupToken);
+      if (binding.bindingToken === "auto") {
+        autoBindings.push({ module: module2, name: binding.name, group });
+        continue;
+      }
+      const location = Number(binding.bindingToken);
+      validateModuleWGSLBinding(module2.name, group, location, binding.name);
+      reserveBinding(group, location, getBindingRegistryKey(group, module2.name, binding.name), `module "${module2.name}" binding "${binding.name}"`);
+    }
+  }
+  for (const { module: module2, name, group } of autoBindings) {
+    const registryKey = getBindingRegistryKey(group, module2.name, name);
+    const location = bindingRegistry == null ? void 0 : bindingRegistry.get(registryKey);
+    if (location !== void 0) {
+      reserveBinding(group, location, registryKey, `registered module binding "${registryKey}"`);
+    }
+  }
+  return reservedBindingKeysByGroup;
+}
+function claimReservedBindingLocation(reservedBindingKeysByGroup, group, location, registryKey) {
+  const reservedBindingKeys = reservedBindingKeysByGroup.get(group);
+  if (!reservedBindingKeys) {
+    return false;
+  }
+  const reservedKey = reservedBindingKeys.get(location);
+  if (!reservedKey) {
+    return false;
+  }
+  if (reservedKey !== registryKey) {
+    throw new Error(`Registered module binding "${registryKey}" collided with "${reservedKey}": group ${group}, binding ${location}.`);
+  }
+  reservedBindingKeys.delete(location);
+  return true;
+}
+function validateApplicationWGSLBinding(group, location, name) {
+  if (group === 0 && location >= RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Application binding "${name}" in group 0 uses reserved binding ${location}. Application-owned explicit group-0 bindings must stay below ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT}.`);
+  }
+}
+function validateModuleWGSLBinding(moduleName, group, location, name) {
+  if (group === 0 && location < RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Module "${moduleName}" binding "${name}" in group 0 uses reserved application binding ${location}. Module-owned explicit group-0 bindings must be ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT} or higher.`);
+  }
+}
+function registerUsedBindingLocation(usedBindingsByGroup, group, location, label) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  if (usedBindings.has(location)) {
+    throw new Error(`Duplicate WGSL binding assignment for ${label}: group ${group}, binding ${location}.`);
+  }
+  usedBindings.add(location);
+  usedBindingsByGroup.set(group, usedBindings);
+}
+function allocateAutoBindingLocation(group, usedBindingsByGroup, moduleName, preferredBindingLocation, bindingRegistry) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  const registeredBindingLocations = /* @__PURE__ */ new Set();
+  const registryGroupPrefix = `${group}:`;
+  const registryModulePrefix = `${registryGroupPrefix}${moduleName}:`;
+  for (const [registryKey, location] of bindingRegistry || []) {
+    if (registryKey.startsWith(registryModulePrefix)) {
+      registeredBindingLocations.add(location);
+    }
+  }
+  let nextBinding = preferredBindingLocation ?? (group === 0 ? RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT : usedBindings.size > 0 ? Math.max(...usedBindings) + 1 : 0);
+  while (usedBindings.has(nextBinding) || registeredBindingLocations.has(nextBinding)) {
+    nextBinding++;
+  }
+  for (const [registryKey, location] of bindingRegistry || []) {
+    if (location === nextBinding && registryKey.startsWith(registryGroupPrefix)) {
+      bindingRegistry == null ? void 0 : bindingRegistry.delete(registryKey);
+    }
+  }
+  return nextBinding;
+}
+function allocateApplicationAutoBindingLocation(group, usedBindingsByGroup) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  let nextBinding = 0;
+  while (usedBindings.has(nextBinding)) {
+    nextBinding++;
+  }
+  return nextBinding;
+}
+function assertNoUnresolvedAutoBindings(source) {
+  const unresolvedBinding = (0, import_wgsl_binding_scan.getFirstWGSLAutoBindingDeclarationMatch)(source, import_wgsl_binding_scan.MODULE_WGSL_BINDING_DECLARATION_REGEXES);
+  if (!unresolvedBinding) {
+    return;
+  }
+  const moduleName = getWGSLModuleNameAtIndex(source, unresolvedBinding.index);
+  if (moduleName) {
+    throw new Error(`Unresolved @binding(auto) for module "${moduleName}" binding "${unresolvedBinding.name}" remained in assembled WGSL source.`);
+  }
+  if (isInApplicationWGSLSection(source, unresolvedBinding.index)) {
+    throw new Error(`Unresolved @binding(auto) for application binding "${unresolvedBinding.name}" remained in assembled WGSL source.`);
+  }
+  throw new Error(`Unresolved @binding(auto) remained in assembled WGSL source near "${formatWGSLSourceSnippet(unresolvedBinding.match)}".`);
+}
+function formatWGSLBindingAssignmentComments(bindingAssignments) {
+  if (bindingAssignments.length === 0) {
+    return "";
+  }
+  let source = "// ----- MODULE WGSL BINDING ASSIGNMENTS ---------------\n";
+  for (const bindingAssignment of bindingAssignments) {
+    source += `// ${bindingAssignment.moduleName}.${bindingAssignment.name} -> @group(${bindingAssignment.group}) @binding(${bindingAssignment.location})
+`;
+  }
+  source += "\n";
+  return source;
+}
+function getBindingRegistryKey(group, moduleName, bindingName) {
+  return `${group}:${moduleName}:${bindingName}`;
+}
+function getWGSLModuleNameAtIndex(source, index) {
+  const moduleHeaderRegex = /^\/\/ ----- MODULE ([^\n]+) ---------------$/gm;
+  let moduleName;
+  let match;
+  match = moduleHeaderRegex.exec(source);
+  while (match && match.index <= index) {
+    moduleName = match[1];
+    match = moduleHeaderRegex.exec(source);
+  }
+  return moduleName;
+}
+function isInApplicationWGSLSection(source, index) {
+  const injectionMarkerIndex = source.indexOf(import_shader_assembly_shared.INJECT_SHADER_DECLARATIONS);
+  return injectionMarkerIndex >= 0 ? index > injectionMarkerIndex : true;
+}
+function formatWGSLSourceSnippet(source) {
+  return source.replace(/\s+/g, " ").trim();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT,
+  allocateApplicationAutoBindingLocation,
+  allocateAutoBindingLocation,
+  appendGeneratedVaryingInjections,
+  appendGeneratedVertexInputInjections,
+  assembleShaderWGSL,
+  assembleWGSLShader,
+  assembleWGSLSource,
+  assertNoUnresolvedAutoBindings,
+  claimReservedBindingLocation,
+  formatWGSLBindingAssignmentComments,
+  formatWGSLSourceSnippet,
+  getBindingRegistryKey,
+  getUsedBindingsByGroupFromApplicationWGSL,
+  getWGSLDeclarationInjections,
+  getWGSLModuleNameAtIndex,
+  getWGSLShaderInjectionTargets,
+  isInApplicationWGSLSection,
+  registerUsedBindingLocation,
+  relocateWGSLApplicationBindingMatch,
+  relocateWGSLApplicationBindings,
+  relocateWGSLModuleBindingMatch,
+  relocateWGSLModuleBindings,
+  reserveModuleBindings,
+  validateApplicationWGSLBinding,
+  validateModuleWGSLBinding
+});

package/dist/lib/shader-assembly/assemble-wgsl-shaders.d.ts

@@ -0,0 +1,70 @@
+import { type ShaderBindingDebugRow } from "./wgsl-binding-debug.js";
+import { type ShaderLayout } from "../../types.js";
+import { type AssembleWGSLShaderOptions, type GetUniformsFunc, type WGSLBindingAssignment, type AssembleStageOptions, type WGSLApplicationRelocationState, type BindingRelocationContext, type WGSLRelocationParams } from "./shader-assembly-types.js";
+import { PlatformInfo } from "./platform-info.js";
+import { normalizeShaderInjectionTargets } from "./shader-injection-targets.js";
+import { type ResolvedShaderInjection } from "./shader-injections.js";
+import { type ShaderModule } from "../shader-module/shader-module.js";
+import { type WGSLBindingDeclarationMatch } from "./wgsl-binding-scan.js";
+export declare const RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
+/** Inject shader modules and compute metadata for the resulting WGSL source. */
+export declare function assembleWGSLShader(options: AssembleWGSLShaderOptions): {
+    source: string;
+    getUniforms: GetUniformsFunc;
+    bindingAssignments: WGSLBindingAssignment[];
+    bindingTable: ShaderBindingDebugRow[];
+    shaderLayout: ShaderLayout | null;
+};
+/** @internal Assemble source without scanning metadata that subsequent preprocessing invalidates. */
+export declare function assembleWGSLSource(options: AssembleWGSLShaderOptions): {
+    source: string;
+    getUniforms: GetUniformsFunc;
+    bindingAssignments: WGSLBindingAssignment[];
+};
+/**
+ * Pulls together complete source code for either a vertex or a fragment shader
+ * adding prologues, requested module chunks, and any final injections.
+ * @param gl
+ * @param options
+ * @returns
+ */
+export declare function assembleShaderWGSL(platformInfo: PlatformInfo, options: AssembleStageOptions): {
+    source: string;
+    bindingAssignments: WGSLBindingAssignment[];
+};
+export declare function appendGeneratedVertexInputInjections(declarations: string, initialization: string, declarationInjections: Record<string, ResolvedShaderInjection[]>, mainInjections: Record<string, ResolvedShaderInjection[]>): void;
+export declare function appendGeneratedVaryingInjections(assembly: {
+    declarations: string;
+    vertexInitialization: string;
+    fragmentInitialization: string;
+}, declarationInjections: Record<string, ResolvedShaderInjection[]>, mainInjections: Record<string, ResolvedShaderInjection[]>): void;
+export declare function getWGSLDeclarationInjections(declarationInjections: Record<string, ResolvedShaderInjection[]>): Record<string, ResolvedShaderInjection[]>;
+export declare function getWGSLShaderInjectionTargets(injectionTargetMap: ReturnType<typeof normalizeShaderInjectionTargets>, targetInjections: Record<string, ResolvedShaderInjection[]>, names?: Map<string, Record<"vertex" | "fragment", string>>): string;
+export declare function getUsedBindingsByGroupFromApplicationWGSL(source: string): Map<number, Set<number>>;
+export declare function relocateWGSLApplicationBindings(source: string): {
+    source: string;
+};
+export declare function relocateWGSLModuleBindings(moduleSource: string, module: ShaderModule, context: BindingRelocationContext): {
+    source: string;
+    bindingAssignments: WGSLBindingAssignment[];
+};
+export declare function relocateWGSLModuleBindingMatch(declarationMatch: WGSLBindingDeclarationMatch, params: WGSLRelocationParams): string;
+export declare function relocateWGSLApplicationBindingMatch(declarationMatch: WGSLBindingDeclarationMatch, usedBindingsByGroup: Map<number, Set<number>>, relocationState: WGSLApplicationRelocationState): string;
+/** Reserve declared locations before reusing registry assignments or allocating new bindings. */
+export declare function reserveModuleBindings(modules: {
+    module: ShaderModule;
+    source: string;
+}[], bindingRegistry: Map<string, number> | undefined, usedBindingsByGroup: Map<number, Set<number>>): Map<number, Map<number, string>>;
+export declare function claimReservedBindingLocation(reservedBindingKeysByGroup: Map<number, Map<number, string>>, group: number, location: number, registryKey: string): boolean;
+export declare function validateApplicationWGSLBinding(group: number, location: number, name: string): void;
+export declare function validateModuleWGSLBinding(moduleName: string, group: number, location: number, name: string): void;
+export declare function registerUsedBindingLocation(usedBindingsByGroup: Map<number, Set<number>>, group: number, location: number, label: string): void;
+export declare function allocateAutoBindingLocation(group: number, usedBindingsByGroup: Map<number, Set<number>>, moduleName: string, preferredBindingLocation?: number, bindingRegistry?: Map<string, number>): number;
+export declare function allocateApplicationAutoBindingLocation(group: number, usedBindingsByGroup: Map<number, Set<number>>): number;
+export declare function assertNoUnresolvedAutoBindings(source: string): void;
+export declare function formatWGSLBindingAssignmentComments(bindingAssignments: WGSLBindingAssignment[]): string;
+export declare function getBindingRegistryKey(group: number, moduleName: string, bindingName: string): string;
+export declare function getWGSLModuleNameAtIndex(source: string, index: number): string | undefined;
+export declare function isInApplicationWGSLSection(source: string, index: number): boolean;
+export declare function formatWGSLSourceSnippet(source: string): string;
+//# sourceMappingURL=assemble-wgsl-shaders.d.ts.map

package/dist/lib/shader-assembly/assemble-wgsl-shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble-wgsl-shaders.d.ts","sourceRoot":"","sources":["../../../src/lib/shader-assembly/assemble-wgsl-shaders.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,KAAK,qBAAqB,EAAoC,gCAA6B;AACnG,OAAO,EAAC,KAAK,YAAY,EAAC,uBAAoB;AAM9C,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,EAE7B,KAAK,oBAAoB,EAC1B,mCAAgC;AAQjC,OAAO,EAAC,YAAY,EAAC,2BAAwB;AAK7C,OAAO,EACL,+BAA+B,EAGhC,sCAAmC;AACpC,OAAO,EACL,KAAK,uBAAuB,EAG7B,+BAA4B;AAC7B,OAAO,EAAgC,KAAK,YAAY,EAAC,0CAAuC;AAChG,OAAO,EAOL,KAAK,2BAA2B,EAEjC,+BAA4B;AAE7B,eAAO,MAAM,0CAA0C,MAAM,CAAC;AAE9D,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,eAAe,CAAC;IAC7B,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;IAC5C,YAAY,EAAE,qBAAqB,EAAE,CAAC;IACtC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC,CAaA;AAED,qGAAqG;AACrG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,eAAe,CAAC;IAC7B,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;CAC7C,CAcA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,oBAAoB,GAC5B;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAoM/D;AAED,wBAAgB,oCAAoC,CAClD,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,EACtB,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,EAChE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,GACxD,IAAI,CAeN;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE;IACR,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sBAAsB,EAAE,MAAM,CAAC;CAChC,EACD,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,EAChE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,GACxD,IAAI,CAsBN;AAED,wBAAgB,4BAA4B,CAC1C,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,GAC/D,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAO3C;AAED,wBAAgB,6BAA6B,CAC3C,kBAAkB,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,EACtE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,EAC3D,KAAK,qDAAkD,GACtD,MAAM,CAaR;AAED,wBAAgB,yCAAyC,CACvD,MAAM,EAAE,MAAM,GACb,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAoB1B;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CA2ChF;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,wBAAwB,GAChC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAgC/D;AAED,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,2BAA2B,EAC7C,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAwDR;AAED,wBAAgB,mCAAmC,CACjD,gBAAgB,EAAE,2BAA2B,EAC7C,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAC7C,eAAe,EAAE,8BAA8B,GAC9C,MAAM,CAkBR;AAED,iGAAiG;AACjG,wBAAgB,qBAAqB,CACnC,OAAO,EAAE;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EAAE,EACjD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAChD,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAC5C,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgDlC;AAED,wBAAgB,4BAA4B,CAC1C,0BAA0B,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC5D,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,OAAO,CAiBT;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,IAAI,CAON;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,IAAI,CAON;AAED,wBAAgB,2BAA2B,CACzC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAC7C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,IAAI,CASN;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAC7C,UAAU,EAAE,MAAM,EAClB,wBAAwB,CAAC,EAAE,MAAM,EACjC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,MAAM,CA8BR;AAED,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,MAAM,EACb,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAC5C,MAAM,CASR;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAyBnE;AAED,wBAAgB,mCAAmC,CACjD,kBAAkB,EAAE,qBAAqB,EAAE,GAC1C,MAAM,CAWR;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY1F;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAGjF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9D"}