@luma.gl/shaders 10.0.0-alpha.6 → 10.0.0-alpha.8

package/src/lib/shader-plugin.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
+import type {ShaderHook} from './shader-assembly/shader-hooks';
 import type {ShaderInjection} from './shader-assembly/shader-injections';
 import type {ShaderModule} from './shader-module/shader-module';
 import {shaderTypeDecoder, type AttributeShaderType} from '../types';
@@ -17,135 +18,158 @@ export type ShaderPluginInjectionTarget =
   | `vs:${string}`
   | `fs:${string}`;
 
+/** Explicit stage and unqualified target for plugin object declarations. */
+export type ShaderPluginTarget = {
+  /** Shader stage containing this extension point. */
+  stage: 'vertex' | 'fragment';
+  /** Unqualified hook name or structural anchor such as #main-start. */
+  target: string;
+};
+
+/** Hook function declared by a plugin, with parameter signatures per language. */
+export type ShaderPluginHook = ShaderPluginTarget & {
+  /** GLSL parameter list, including parentheses. */
+  glsl?: string;
+  /** WGSL parameter list, including parentheses. */
+  wgsl?: string;
+};
+
 /** Named shader source injection contributed by a ShaderPlugin. */
-export type ShaderPluginInjection = {
-  /** Named shader anchor or hook that receives this source. */
-  target: ShaderPluginInjectionTarget;
-  /** Shader source to inject at the target. */
-  injection: string;
+export type ShaderPluginInjection = ShaderPluginTarget & {
+  /** GLSL source for this target. Omit to skip this injection when assembling GLSL. */
+  glsl?: string;
+  /** WGSL source for this target. Omit to skip this injection when assembling WGSL. */
+  wgsl?: string;
   /** Relative injection order within the target. */
   order?: number;
 };
 
-/** Portable interpolation modes for ShaderPlugin varyings. */
-export type ShaderPluginVaryingInterpolation = 'smooth' | 'flat';
+/** Portable interpolation modes for ShaderPlugin inter-stage variables. */
+export type ShaderPluginInterStageVariableInterpolation = 'smooth' | 'flat';
 
 /** Cross-stage value contributed by a ShaderPlugin. */
-export type ShaderPluginVarying = {
+export type ShaderPluginInterStageVariable = {
   /** Portable scalar or vector shader type. */
   type: AttributeShaderType;
   /** Defaults to smooth for floating-point types and flat for integer types. */
-  interpolation?: ShaderPluginVaryingInterpolation;
+  interpolation?: ShaderPluginInterStageVariableInterpolation;
 };
 
-/** Fully normalized ShaderPlugin varying declaration. */
-export type ResolvedShaderPluginVarying = {
+/** Fully normalized ShaderPlugin inter-stage variable declaration. */
+export type ResolvedShaderPluginInterStageVariable = {
   type: AttributeShaderType;
-  interpolation: ShaderPluginVaryingInterpolation;
+  interpolation: ShaderPluginInterStageVariableInterpolation;
 };
 
-/** Shared or backend-specific shader assembly contributions. */
-export type ShaderPluginVariant = {
-  /** Shader modules added to shader assembly. */
-  modules?: ShaderModule[];
-  /** Boolean preprocessor defines added to shader assembly. */
-  defines?: Record<string, boolean>;
-  /** Named code injections added to shader assembly. */
-  injections?: ShaderPluginInjection[];
+/** Reusable shader assembly descriptor with one portable interface and language-specific source. */
+export type ShaderPlugin = {
+  /** Stable plugin identifier. */
+  name: string;
+  /** Primary shader module. Supporting modules belong in its dependencies; omit for injection-only plugins. */
+  module?: ShaderModule<any, any, any>;
+  /** Boolean or numeric preprocessor defines added to shader assembly. */
+  defines?: Record<string, boolean | number>;
+  /** Named injections as explicit-stage objects or optionally language-qualified string keys. */
+  injections?: ShaderPluginInjection[] | Record<string, string>;
+  /** Callable extension points as explicit-stage objects or optionally language-qualified signatures. */
+  hooks?: (ShaderPluginHook | string)[];
   /** Shader-facing vertex inputs added by this plugin. Buffer ownership remains with the caller. */
   vertexInputs?: Record<string, AttributeShaderType>;
   /** Values transported from the selected vertex entry point to the fragment entry point. */
-  varyings?: Record<string, ShaderPluginVarying>;
-};
-
-/** Reusable cross-backend shader assembly descriptor. */
-export type ShaderPlugin = ShaderPluginVariant & {
-  /** Stable plugin identifier. */
-  name: string;
-  /** GLSL-only shader assembly contributions. */
-  glsl?: ShaderPluginVariant;
-  /** WGSL-only shader assembly contributions. */
-  wgsl?: ShaderPluginVariant;
+  interStageVariables?: Record<string, ShaderPluginInterStageVariable>;
 };
 
 /** ShaderPlugin contributions resolved for one shader language. */
 export type ResolvedShaderPlugins = {
   /** Resolved shader modules in plugin declaration order. */
   modules: ShaderModule[];
-  /** Resolved boolean preprocessor defines. */
-  defines: Record<string, boolean>;
+  /** Language-selected hook declarations. */
+  hooks: ShaderHook[];
+  /** Resolved boolean or numeric preprocessor defines. */
+  defines: Record<string, boolean | number>;
   /** Resolved named code injections grouped by target. */
   injections: Record<string, ShaderInjection[]>;
   /** Resolved shader-facing vertex inputs in plugin declaration order. */
   vertexInputs: Record<string, AttributeShaderType>;
-  /** Resolved cross-stage varyings in plugin declaration order. */
-  varyings: Record<string, ResolvedShaderPluginVarying>;
+  /** Resolved inter-stage variables in plugin declaration order. */
+  interStageVariables: Record<string, ResolvedShaderPluginInterStageVariable>;
 };
 
 const SHADER_PLUGIN_INJECTION_TARGET_REGEX =
   /^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][\w-]*)$/;
 
-/** Resolve shared and backend-specific contributions from shader plugins. */
+/** Resolve plugin interfaces and select injection source for one shader language. */
 export function resolveShaderPlugins(
   plugins: readonly ShaderPlugin[] = [],
   shaderLanguage: 'glsl' | 'wgsl'
 ): ResolvedShaderPlugins {
-  const modules: ShaderModule[] = [];
-  const defines: Record<string, boolean> = {};
-  const injections: Record<string, ShaderInjection[]> = {};
-  const vertexInputs: Record<string, AttributeShaderType> = {};
-  const varyings: Record<string, ResolvedShaderPluginVarying> = {};
+  const resolved: ResolvedShaderPlugins = {
+    modules: [],
+    hooks: [],
+    defines: {},
+    injections: {},
+    vertexInputs: {},
+    interStageVariables: {}
+  };
 
   for (const plugin of plugins) {
-    appendShaderPluginVariant({modules, defines, injections, vertexInputs, varyings}, plugin);
-    appendShaderPluginVariant(
-      {modules, defines, injections, vertexInputs, varyings},
-      plugin[shaderLanguage]
-    );
+    appendShaderPlugin(resolved, plugin, shaderLanguage);
   }
+  const {vertexInputs, interStageVariables} = resolved;
 
-  for (const name of Object.keys(varyings)) {
+  for (const name of Object.keys(interStageVariables)) {
     if (vertexInputs[name]) {
       throw new Error(`ShaderPlugin name "${name}" cannot be both a vertex input and a varying`);
     }
   }
 
-  return {modules, defines, injections, vertexInputs, varyings};
+  return resolved;
 }
 
-/** Preserve explicit module inputs while appending plugin modules by first-seen name. */
+/**
+ * Preserve explicit module inputs while appending plugin modules by first-seen name.
+ * Optional diagnostics report distinct descriptors sharing a name, without changing selection.
+ * Descriptor identity is checked; equivalent independently-created descriptors also report a conflict.
+ */
 export function mergeShaderPluginModules(
   modules: readonly ShaderModule[] = [],
-  pluginModules: readonly ShaderModule[] = []
+  pluginModules: readonly ShaderModule[] = [],
+  options: {onConflict?: (name: string, selected: ShaderModule, ignored: ShaderModule) => void} = {}
 ): ShaderModule[] {
   const mergedModules: ShaderModule[] = [...modules];
-  const seenModuleNames = new Set(mergedModules.map(module => module.name));
+  const selectedModules = new Map<string, ShaderModule>();
+  for (const module of mergedModules) {
+    const selected = selectedModules.get(module.name);
+    if (selected && selected !== module) options.onConflict?.(module.name, selected, module);
+    if (!selected) selectedModules.set(module.name, module);
+  }
 
   for (const pluginModule of pluginModules) {
-    if (!seenModuleNames.has(pluginModule.name)) {
+    const selected = selectedModules.get(pluginModule.name);
+    if (selected && selected !== pluginModule) {
+      options.onConflict?.(pluginModule.name, selected, pluginModule);
+    }
+    if (!selected) {
       mergedModules.push(pluginModule);
-      seenModuleNames.add(pluginModule.name);
+      selectedModules.set(pluginModule.name, pluginModule);
     }
   }
 
   return mergedModules;
 }
 
-function appendShaderPluginVariant(
+function appendShaderPlugin(
   resolved: ResolvedShaderPlugins,
-  variant: ShaderPluginVariant | undefined
+  plugin: ShaderPlugin,
+  shaderLanguage: 'glsl' | 'wgsl'
 ): void {
-  if (!variant) {
-    return;
-  }
-
-  if (variant.modules?.length) {
-    resolved.modules.push(...variant.modules);
+  if (plugin.module) {
+    resolved.modules.push(plugin.module);
   }
-  if (variant.defines) {
-    Object.assign(resolved.defines, variant.defines);
+  if (plugin.defines) {
+    Object.assign(resolved.defines, plugin.defines);
   }
-  for (const [name, type] of Object.entries(variant.vertexInputs || {})) {
+  for (const [name, type] of Object.entries(plugin.vertexInputs || {})) {
     assertShaderPluginInterfaceName(name, 'vertex input');
     const existingType = resolved.vertexInputs[name];
     if (existingType && existingType !== type) {
@@ -155,10 +179,10 @@ function appendShaderPluginVariant(
     }
     resolved.vertexInputs[name] = type;
   }
-  for (const [name, varying] of Object.entries(variant.varyings || {})) {
+  for (const [name, varying] of Object.entries(plugin.interStageVariables || {})) {
     assertShaderPluginInterfaceName(name, 'varying');
-    const normalizedVarying = normalizeShaderPluginVarying(name, varying);
-    const existingVarying = resolved.varyings[name];
+    const normalizedVarying = normalizeShaderPluginInterStageVariable(name, varying);
+    const existingVarying = resolved.interStageVariables[name];
     if (
       existingVarying &&
       (existingVarying.type !== normalizedVarying.type ||
@@ -170,17 +194,58 @@ function appendShaderPluginVariant(
           `"${normalizedVarying.type}/${normalizedVarying.interpolation}"`
       );
     }
-    resolved.varyings[name] = normalizedVarying;
+    resolved.interStageVariables[name] = normalizedVarying;
   }
 
-  for (const injection of variant.injections || []) {
-    assertNamedShaderPluginInjectionTarget(injection.target);
-    if (!resolved.injections[injection.target]) {
-      resolved.injections[injection.target] = [];
+  for (const hook of plugin.hooks || []) {
+    const declarationSource =
+      typeof hook === 'string' ? selectShaderLanguage(hook, shaderLanguage) : undefined;
+    if (typeof hook === 'string' && declarationSource === undefined) continue;
+    const signature =
+      typeof hook === 'string'
+        ? declarationSource!.slice(declarationSource!.indexOf('('))
+        : hook[shaderLanguage];
+    if (signature === undefined) continue;
+    const target =
+      typeof hook === 'string' ? declarationSource!.split('(')[0] : getShaderPluginTarget(hook);
+    if (!/^(vs|fs):[A-Za-z_][A-Za-z0-9_]*$/.test(target) || !/^\([^]*\)$/.test(signature.trim())) {
+      throw new Error(`Invalid ShaderPlugin hook ${target}`);
+    }
+    const declaration = {hook: `${target}${signature.trim()}`};
+    const existing = resolved.hooks.find(value => value.hook.split('(')[0] === target);
+    if (existing && existing.hook !== declaration.hook) {
+      throw new Error(`Conflicting ShaderPlugin hook ${target}`);
+    }
+    if (!existing) resolved.hooks.push(declaration);
+  }
+  const pluginInjections = Array.isArray(plugin.injections)
+    ? plugin.injections
+    : Object.entries(plugin.injections || {}).flatMap(([key, source]): ShaderPluginInjection[] => {
+        const target = selectShaderLanguage(key, shaderLanguage);
+        if (target === undefined) return [];
+        const [stage, ...name] = target.split(':');
+        if (stage !== 'vs' && stage !== 'fs')
+          throw new Error(`Invalid ShaderPlugin injection ${key}`);
+        return [
+          {
+            stage: stage === 'vs' ? ('vertex' as const) : ('fragment' as const),
+            target: name.join(':'),
+            [shaderLanguage]: source
+          }
+        ];
+      });
+  for (const injection of pluginInjections) {
+    const source = injection[shaderLanguage];
+    if (source === undefined) continue;
+    const target = getShaderPluginTarget(injection);
+    assertNamedShaderPluginInjectionTarget(target);
+    if (!resolved.injections[target]) {
+      resolved.injections[target] = [];
     }
-    const injections = resolved.injections[injection.target];
+    const injections = resolved.injections[target];
     injections.push({
-      injection: injection.injection,
+      pluginName: plugin.name,
+      injection: source,
       order: injection.order ?? 0
     });
   }
@@ -192,10 +257,10 @@ function assertShaderPluginInterfaceName(name: string, kind: 'vertex input' | 'v
   }
 }
 
-function normalizeShaderPluginVarying(
+function normalizeShaderPluginInterStageVariable(
   name: string,
-  varying: ShaderPluginVarying
-): ResolvedShaderPluginVarying {
+  varying: ShaderPluginInterStageVariable
+): ResolvedShaderPluginInterStageVariable {
   const {primitiveType} = shaderTypeDecoder.getAttributeShaderTypeInfo(varying.type);
   const integerType = primitiveType === 'i32' || primitiveType === 'u32';
   const interpolation = varying.interpolation || (integerType ? 'flat' : 'smooth');
@@ -212,3 +277,15 @@ function assertNamedShaderPluginInjectionTarget(target: ShaderPluginInjectionTar
     );
   }
 }
+
+function getShaderPluginTarget(value: ShaderPluginTarget): ShaderPluginInjectionTarget {
+  if ((value.stage !== 'vertex' && value.stage !== 'fragment') || value.target.includes(':')) {
+    throw new Error('ShaderPlugin object targets require an explicit stage and unqualified target');
+  }
+  return `${value.stage === 'vertex' ? 'vs' : 'fs'}:${value.target}` as ShaderPluginInjectionTarget;
+}
+
+function selectShaderLanguage(value: string, language: 'glsl' | 'wgsl'): string | undefined {
+  const match = /^(glsl|wgsl):([\s\S]+)$/.exec(value);
+  return match ? (match[1] === language ? match[2] : undefined) : value;
+}

package/src/lib/wgsl-shader-assembler.ts

@@ -36,7 +36,7 @@ export class WGSLShaderAssembler extends ShaderAssembler {
     entryPoints: ShaderTranspilerEntryPoints;
   } {
     const modules = this._getModuleList(props.modules); // Combine with default modules
-    const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions
+    const hookFunctions = [...this._hookFunctions, ...(props.hookFunctions || [])];
     const translated = this._transpileShader(
       props,
       modules,

package/src/modules/engine/clip/clip.ts

@@ -100,50 +100,40 @@ fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
 /** Coordinate-system-neutral instance and geometry clipping. */
 export const clipShaderPlugin: ShaderPlugin = {
   name: 'clip',
-  modules: [clipShaderModule],
-  varyings: {
+  module: clipShaderModule,
+  interStageVariables: {
     clipCoordinates: {type: 'vec2<f32>', interpolation: 'smooth'}
   },
-  glsl: {
-    injections: [
-      {
-        target: 'vs:CLIP_POSITION',
-        injection: `\
+  injections: [
+    {
+      stage: 'vertex',
+      target: 'CLIP_POSITION',
+      glsl: `\
 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: `\
+}`,
+      wgsl: `\
 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: `\
+    },
+    {
+      stage: 'fragment',
+      target: 'CLIP_COLOR',
+      glsl: `\
+if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`,
+      wgsl: `\
 if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_GEOMETRY} &&
     !clip_isInBounds(clipCoordinates)) {
   discard;
 }`
-      }
-    ]
-  }
+    }
+  ]
 };

package/src/modules/engine/filter/filter.ts

@@ -78,30 +78,22 @@ fn filter_isVisible(value: f32) -> bool {
 /** Scalar inclusive-range filtering for shaders that expose the `FILTER_POSITION` vertex hook. */
 export const filterShaderPlugin: ShaderPlugin = {
   name: 'filter',
-  modules: [filterShaderModule],
+  module: filterShaderModule,
   vertexInputs: {
     filterValues: 'f32'
   },
-  glsl: {
-    injections: [
-      {
-        target: 'vs:FILTER_POSITION',
-        injection: `\
+  injections: [
+    {
+      stage: 'vertex',
+      target: 'FILTER_POSITION',
+      glsl: `\
 if (!filter_isVisible(filterValues)) {
   position = vec4(2.0, 2.0, 2.0, 1.0);
-}`
-      }
-    ]
-  },
-  wgsl: {
-    injections: [
-      {
-        target: 'vs:FILTER_POSITION',
-        injection: `\
+}`,
+      wgsl: `\
 if (!filter_isVisible(filterValues)) {
   *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
 }`
-      }
-    ]
-  }
+    }
+  ]
 };

package/src/modules/lighting/lights/lighting.ts

@@ -49,7 +49,7 @@ export type PointLight = {
 export type DirectionalLight = {
   /** Discriminator used to identify directional lights in `lights: Light[]`. */
   type: 'directional';
-  /** World-space light direction. */
+  /** World-space direction in which light travels. */
   direction: Readonly<NumberArray3>;
   /** RGB light color in the existing `0..255` convention used by luma.gl materials. */
   color?: Readonly<NumberArray3>;

package/src/modules/lighting/pbr-material/pbr-material-glsl.ts

@@ -1249,7 +1249,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
       for(int i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
-          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
           color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
         }
       }
@@ -1537,7 +1537,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     // Apply directional light
     for(int i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
           lighting_getDirectionalLight(i).color,

package/src/modules/lighting/pbr-material/pbr-material-wgsl.ts

@@ -1468,7 +1468,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       for (var i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
-          PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+          PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
           color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
         }
       }
@@ -1828,7 +1828,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     // Apply directional light
     for (var i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
-        PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+        PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
           lighting_getDirectionalLight(i).color,

package/src/modules/math/fp64/fp64.ts

@@ -4,7 +4,7 @@
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
-import {fp64ify, fp64LowPart, fp64ifyMatrix4} from '../../../modules/math/fp64/fp64-utils';
+import {fp64ify, fp64LowPart, fp64ifyMatrix4} from './fp64-utils';
 import {fp64arithmeticShader} from './fp64-arithmetic-glsl';
 import {fp64arithmeticWGSL} from './fp64-arithmetic-wgsl';
 import {fp64functionShader} from './fp64-functions-glsl';

package/src/types/texture-formats.ts

@@ -85,6 +85,8 @@ export type TextureFormatCompressed =
   | 'pvrtc-rgba4unorm-webgl'
   | 'pvrtc-rgb2unorm-webgl'
   | 'pvrtc-rgba2unorm-webgl'
+  | 'etc1-rgb-unorm-webgl'
+  // Legacy misspelling retained for compatibility.
   | 'etc1-rbg-unorm-webgl'
   | 'atc-rgb-unorm-webgl'
   | 'atc-rgba-unorm-webgl'

package/src/types.ts

@@ -35,13 +35,81 @@ export type UniformFormat =
   | 'mat4x3<f32>'
   | 'mat4x4<f32>';
 
-export * from './types/primitive-data-types';
-export * from './types/shader-types';
-export * from './types/shader-type-decoder';
-export * from './types/shader-block-layout';
-export * from './types/shader-layout';
-export * from './types/texture-formats';
-export * from './types/sampler-props';
+export {type PrimitiveDataType} from './types/primitive-data-types';
+export {
+  type AttributeShaderType,
+  type VariableShaderType,
+  type CompositeShaderType,
+  type StructShaderType,
+  type ArrayShaderType,
+  type AttributeShaderTypeAlias,
+  type VariableShaderTypeAlias,
+  type AttributeShaderTypeT,
+  type VariableShaderTypeT,
+  type AttributeShaderTypeAliasT,
+  type VariableShaderTypeAliasT
+} from './types/shader-types';
+export {
+  getVariableShaderTypeInfo,
+  getAttributeShaderTypeInfo,
+  makeShaderAttributeType,
+  resolveAttributeShaderTypeAlias,
+  resolveVariableShaderTypeAlias,
+  type VariableShaderTypeInfo,
+  type AttributeShaderTypeInfo,
+  ShaderTypeDecoder,
+  shaderTypeDecoder,
+  WGSL_ATTRIBUTE_TYPE_ALIAS_MAP,
+  WGSL_VARIABLE_TYPE_ALIAS_MAP
+} from './types/shader-type-decoder';
+export {
+  makeShaderBlockLayout,
+  getLeafLayoutInfo,
+  isCompositeShaderTypeStruct,
+  type ShaderBlockLayoutEntry,
+  type ShaderBlockLayoutOptions,
+  type ShaderBlockLayout
+} from './types/shader-block-layout';
+export {
+  type ShaderLayout,
+  type ComputeShaderLayout,
+  type AttributeDeclaration,
+  type BindingDeclaration,
+  type UniformBufferBindingLayout,
+  type UniformBlockLayout,
+  type UniformInfo,
+  type StorageBufferBindingLayout,
+  type TextureBindingLayout,
+  type ExternalTextureBindingLayout,
+  type SamplerBindingLayout,
+  type StorageTextureBindingLayout,
+  type VaryingBinding,
+  type UniformBlockBinding,
+  type UniformBinding
+} from './types/shader-layout';
+export {
+  type TextureFormat,
+  type TextureFormatDepthStencil,
+  type TextureFormatColor,
+  type TextureFormatColorUncompressed,
+  type TextureFormatUnorm8,
+  type TextureFormatSnorm8,
+  type TextureFormatUint8,
+  type TextureFormatSint8,
+  type TextureFormatUnorm16,
+  type TextureFormatSnorm16,
+  type TextureFormatUint16,
+  type TextureFormatSint16,
+  type TextureFormatFloat16,
+  type TextureFormatUint32,
+  type TextureFormatSint32,
+  type TextureFormatFloat32,
+  type TextureFormatPacked16,
+  type TextureFormatPacked32,
+  type TextureFormatCompressed,
+  type CompressedTextureFormat
+} from './types/texture-formats';
+export {type CompareFunction, type SamplerProps} from './types/sampler-props';
 export {alignTo} from './types/align-to';
 
 /** Resource values remain opaque until an execution adapter binds them. */

package/src/wgsl.ts

@@ -20,4 +20,15 @@ export {
   type ShaderBindingDebugRow
 } from './lib/shader-assembly/wgsl-binding-debug';
 
-export * from './lib/shader-assembly/wgsl-binding-scan';
+export {
+  maskWGSLComments,
+  getWGSLBindingDeclarationMatches,
+  replaceWGSLBindingDeclarationMatches,
+  hasWGSLAutoBinding,
+  getFirstWGSLAutoBindingDeclarationMatch,
+  WGSL_BINDABLE_VARIABLE_PATTERN,
+  MODULE_WGSL_BINDING_DECLARATION_REGEXES,
+  WGSL_BINDING_DECLARATION_REGEXES,
+  WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES,
+  type WGSLBindingDeclarationMatch
+} from './lib/shader-assembly/wgsl-binding-scan';