@carbonenginejs/runtime 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/resource/formats/webgl/core/glsl/DxbcGlslEmitter.js

@@ -2,27 +2,26 @@ import { CjsDxbcFormat } from '../../../dxbc/CjsDxbcFormat.js';
 import { WebglReadError } from '../errors.js';
 import { DxbcGlslOperandFormatter } from './DxbcGlslOperandFormatter.js';
 import { DxbcGlslHelperRegistry } from './DxbcGlslHelpers.js';
-import { DETAIL_MAP_ARRAY_NAME } from '../../../hlsl/core/detailMapFamily.js';
 
 const COMPONENTS = ["x", "y", "z", "w"];
 
-/**
- * Map-style compute lowering caps simultaneous UAV writes to this many
- * fragment color outputs. WebGL2 only guarantees `MAX_DRAW_BUFFERS >= 4`
- * (real implementations commonly expose up to 8); a compute kernel that
- * writes more UAVs than fit in one draw call's attachment set (e.g. a
- * hierarchical mip-chain "Pack" pass writing 16 mip levels per dispatch)
- * cannot become a single map-style fragment pass at all.
+/**
+ * Map-style compute lowering caps simultaneous UAV writes to this many
+ * fragment color outputs. WebGL2 only guarantees `MAX_DRAW_BUFFERS >= 4`
+ * (real implementations commonly expose up to 8); a compute kernel that
+ * writes more UAVs than fit in one draw call's attachment set (e.g. a
+ * hierarchical mip-chain "Pack" pass writing 16 mip levels per dispatch)
+ * cannot become a single map-style fragment pass at all.
  */
 const MAX_MAP_STYLE_UAV_OUTPUTS = 8;
 
-/**
- * GLSL sampler type per DXBC resource-dimension id (float return types; the
- * stripped-RDEF corpus reflects everything as float).
+/**
+ * GLSL sampler type per DXBC resource-dimension id (float return types; the
+ * stripped-RDEF corpus reflects everything as float).
  */
-/**
- * DXBC resource dimension for a cube map. Emulated addressing refuses it: a
- * cube coordinate is a direction, so a [0,1] range test is meaningless there.
+/**
+ * DXBC resource dimension for a cube map. Emulated addressing refuses it: a
+ * cube coordinate is a direction, so a [0,1] range test is meaningless there.
  */
 const CUBE_DIMENSION = 6;
 const SAMPLER_TYPE_BY_DIMENSION = {
@@ -33,11 +32,11 @@ const SAMPLER_TYPE_BY_DIMENSION = {
   8: "sampler2DArray"
 };
 
-/**
- * Shadow-sampler type per WebGL2-supported DXBC resource dimension.
- * Comparison sampling changes both the call signature and the uniform type;
- * keeping this separate from the ordinary sampler table guarantees shaders
- * without comparison opcodes retain their existing declarations verbatim.
+/**
+ * Shadow-sampler type per WebGL2-supported DXBC resource dimension.
+ * Comparison sampling changes both the call signature and the uniform type;
+ * keeping this separate from the ordinary sampler table guarantees shaders
+ * without comparison opcodes retain their existing declarations verbatim.
  */
 const SHADOW_SAMPLER_TYPE_BY_DIMENSION = {
   3: "sampler2DShadow",
@@ -47,19 +46,19 @@ const SHADOW_SAMPLER_TYPE_BY_DIMENSION = {
 const COMPARISON_SAMPLE_OPCODES = new Set(["sample_c", "sample_c_lz"]);
 const NON_COMPARISON_TEXTURE_OPCODES = new Set(["sample", "sample_l", "sample_b", "sample_d", "gather4", "gather4_po", "ld", "ld_ms", "lod"]);
 
-/**
- * Filtered-sample coordinate mask per resource dimension
- * (HLSLcc `TranslateTexCoord`, toGLSLInstruction.cpp:985-1031).
+/**
+ * Filtered-sample coordinate mask per resource dimension
+ * (HLSLcc `TranslateTexCoord`, toGLSLInstruction.cpp:985-1031).
  */
-/**
- * GLSL symbol for the merged detail-map array.
- *
- * Derived, not spelled out. The family owns the name and it has been renamed
- * once already (`DetailMapArray` -> `DetailArrayMap`); a second literal is a
- * second place for the next rename to miss, which is exactly what the writer's
- * `outputName` comment warns about. Only the GLSL sampler prefix is local.
+/**
+ * GLSL symbol for the merged detail-map array.
+ *
+ * Derived, not spelled out. The family owns the name and it has been renamed
+ * once already (`DetailMapArray` -> `DetailArrayMap`); a second literal is a
+ * second place for the next rename to miss, which is exactly what the writer's
+ * `outputName` comment warns about. Only the GLSL sampler prefix is local.
  */
-const DETAIL_MAP_ARRAY_SYMBOL = `s${DETAIL_MAP_ARRAY_NAME}`;
+
 const COORD_MASK_BY_DIMENSION = {
   2: "x",
   3: "xy",
@@ -70,32 +69,32 @@ const COORD_MASK_BY_DIMENSION = {
   10: "xyzw"
 };
 
-/**
- * DXBC -> GLSL ES 3.00 emitter for vertex and pixel stages.
- *
- * Implements the lowering rules in `docs/dxbc-lowering/*.md`, which pin every
- * template to HLSLcc's `toGLSLInstruction.cpp`/`toGLSLDeclaration.cpp`.
- * Registers are stored as float vec4s with bitcasts at use sites, comparison
- * results are 0xFFFFFFFF/0 masks (never bools), and register-stable symbols
- * (`cb#.data[]`, `t#`, `in_SEMANTIC#`, `vs_SEMANTIC#`) form the ABI surface.
- *
- * Emitter-wide policy: Adreno-3xx driver hygiene from HLSLcc (per-component
- * bitwise splits, `op_not`, `uint(0)` literals, `uvecN()` ctor wraps) is NOT
- * ported; the target is ANGLE-backed WebGL2 and the plain spec-legal forms
- * are emitted instead.
+/**
+ * DXBC -> GLSL ES 3.00 emitter for vertex and pixel stages.
+ *
+ * Implements the lowering rules in `docs/dxbc-lowering/*.md`, which pin every
+ * template to HLSLcc's `toGLSLInstruction.cpp`/`toGLSLDeclaration.cpp`.
+ * Registers are stored as float vec4s with bitcasts at use sites, comparison
+ * results are 0xFFFFFFFF/0 masks (never bools), and register-stable symbols
+ * (`cb#.data[]`, `t#`, `in_SEMANTIC#`, `vs_SEMANTIC#`) form the ABI surface.
+ *
+ * Emitter-wide policy: Adreno-3xx driver hygiene from HLSLcc (per-component
+ * bitwise splits, `op_not`, `uint(0)` literals, `uvecN()` ctor wraps) is NOT
+ * ported; the target is ANGLE-backed WebGL2 and the plain spec-legal forms
+ * are emitted instead.
  */
 class DxbcGlslEmitter {
-  /**
-  * @param {object} [options] Emitter options.
-  * @param {object} [options.profile] Target-runtime profile overrides.
-  * @param {"array"|"std140"} [options.profile.constantBufferStyle] `uniform vec4 cbN[]`
-  *   arrays for ccpwgl's uniform4fv path, or std140 blocks.
-  * @param {Object.<number,number>} [options.profile.pixelConstantBufferRemap] Pixel-stage
-  *   cb slot renames (ccpwgl keeps PS effect constants at cb7).
-  * @param {function(number,string):string} [options.profile.samplerName] Texture uniform
-  *   naming per register and stage.
-  * @param {number} [options.profile.vertexStructuredCapacity] Element capacity for
-  *   vertex-stage structured-buffer UBOs (bones; Carbon max is 69 joints).
+  /**
+  * @param {object} [options] Emitter options.
+  * @param {object} [options.profile] Target-runtime profile overrides.
+  * @param {"array"|"std140"} [options.profile.constantBufferStyle] `uniform vec4 cbN[]`
+  *   arrays for ccpwgl's uniform4fv path, or std140 blocks.
+  * @param {Object.<number,number>} [options.profile.pixelConstantBufferRemap] Pixel-stage
+  *   cb slot renames (ccpwgl keeps PS effect constants at cb7).
+  * @param {function(number,string):string} [options.profile.samplerName] Texture uniform
+  *   naming per register and stage.
+  * @param {number} [options.profile.vertexStructuredCapacity] Element capacity for
+  *   vertex-stage structured-buffer UBOs (bones; Carbon max is 69 joints).
   */
   constructor(options = {}) {
     this.helpers = new DxbcGlslHelperRegistry();
@@ -134,6 +133,11 @@ class DxbcGlslEmitter {
       // into one array binding frees two texture units on shaders that
       // sit exactly on WebGL2's 16-unit limit.
       detailMapArrayRegisters: [],
+      // Every family to merge, as { family, outputName, registers } in
+      // layer order. The key above is the detail family's older spelling
+      // and is still honoured; this one carries the rest - Frontier's
+      // roughness, atlas and dirt families among them.
+      textureArrayFamilies: [],
       // Which end of the source clip range is NEAR, and therefore which
       // form the depth-range fixup takes.
       //
@@ -197,11 +201,11 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Registers the GLSL helper functions this emitter's lowerings can require.
-  * GLSL ES 3.00 has no `bitfieldExtract`/`bitfieldInsert`/`bitCount`/
-  * `textureGather` (all ES 3.10+), so `ibfe`/`ubfe`/`bfi`/`countbits`/
-  * `gather4` lower to these hand-written equivalents instead.
+  /**
+  * Registers the GLSL helper functions this emitter's lowerings can require.
+  * GLSL ES 3.00 has no `bitfieldExtract`/`bitfieldInsert`/`bitCount`/
+  * `textureGather` (all ES 3.10+), so `ibfe`/`ubfe`/`bfi`/`countbits`/
+  * `gather4` lower to these hand-written equivalents instead.
   */
   _defineHelpers() {
     // Texture address modes WebGL2 cannot express, emulated in the shader.
@@ -287,16 +291,16 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-  * Translates one DXBC stage into GLSL ES 3.00 source.
-  *
-  * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes DXBC container bytes.
-  * @param {object} [options] Emit options.
-  * @param {string} [options.source] Source name used in error details.
-  * @returns {{source:string,stageName:string,inputs:object[],outputs:object[],bindings:object[],warnings:string[],computeFragment:(object|undefined)}}
-  *   GLSL text plus the IO contract the packaging layer records; compute
-  *   stages add a `computeFragment` host contract (thread group,
-  *   dispatch-origin uniform, per-output UAV slice routing).
+  /**
+  * Translates one DXBC stage into GLSL ES 3.00 source.
+  *
+  * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes DXBC container bytes.
+  * @param {object} [options] Emit options.
+  * @param {string} [options.source] Source name used in error details.
+  * @returns {{source:string,stageName:string,inputs:object[],outputs:object[],bindings:object[],warnings:string[],computeFragment:(object|undefined)}}
+  *   GLSL text plus the IO contract the packaging layer records; compute
+  *   stages add a `computeFragment` host contract (thread group,
+  *   dispatch-origin uniform, per-output UAV slice routing).
   */
   Emit(bytes, options = {}) {
     const sourceName = options.source || "memory";
@@ -354,8 +358,10 @@ class DxbcGlslEmitter {
       neutralResources: new Set(this.profile.neutralResourceRegisters || []),
       // Resource register -> array layer for the merged detail maps, and
       // whether the one shared array declaration has been emitted yet.
-      detailMapArrayLayers: new Map((this.profile.detailMapArrayRegisters || []).map((register, layer) => [register, layer])),
-      detailMapArrayDeclared: false,
+      // Resource register -> the array it was merged into and its layer
+      // within it, and which array declarations have been emitted.
+      textureArrayLayers: this._textureArrayLayerMap(),
+      declaredTextureArrays: new Set(),
       inputMasks: new Map(),
       outputMasks: new Map(),
       bindings: [],
@@ -403,7 +409,13 @@ class DxbcGlslEmitter {
     // them in float storage: a vertex-id corner index `r0.x = uintBitsToFloat(id & 3u)`
     // reads back 0 for ids 1..3, collapsing every quad (plane sets, the sprite
     // pool). Packed-light shaders need the same companions for their words.
-    state.integerTemps = !!state.lightPackedTexture || state.decoder.instructions.some(instruction => (instruction.opcodeName === "dcl_input_sgv" || instruction.opcodeName === "dcl_input_ps_sgv") && (instruction.declaration?.systemValueName === "vertex_id" || instruction.declaration?.systemValueName === "instance_id"));
+    //
+    // Integer vertex inputs arrive as float VALUES (see _declareVertexInput);
+    // a move into a temporary must value-convert into the companion, or a later
+    // `floatBitsToInt(r#)` reads the bits of 3.0 instead of 3 (the haze-set box
+    // corner index, TEXCOORD7).
+    const integerVertexInputRegisters = new Set(program.programTypeName !== "vertex" ? [] : (raw.inputSignature?.elements || []).filter(element => element.componentTypeName === "uint32" || element.componentTypeName === "int32").map(element => element.registerIndex));
+    state.integerTemps = !!state.lightPackedTexture || state.decoder.instructions.some(instruction => (instruction.opcodeName === "dcl_input_sgv" || instruction.opcodeName === "dcl_input_ps_sgv") && (instruction.declaration?.systemValueName === "vertex_id" || instruction.declaration?.systemValueName === "instance_id") || (instruction.opcodeName === "mov" || instruction.opcodeName === "movc") && instruction.operands[0]?.type === 0 && instruction.operands.slice(1).some(operand => operand.type === 1 && integerVertexInputRegisters.has(operand.registerIndex)));
     state.formatter = new DxbcGlslOperandFormatter({
       // Populated during vertex-input declaration (the declaration loop
       // runs before any body emission, so the map is complete before the
@@ -494,10 +506,10 @@ class DxbcGlslEmitter {
     return result;
   }
 
-  /**
-  * Normalizes the optional local-light constant-buffer lowering profile.
-  *
-  * @returns {object|null} Normalized profile, or null when disabled.
+  /**
+  * Normalizes the optional local-light constant-buffer lowering profile.
+  *
+  * @returns {object|null} Normalized profile, or null when disabled.
   */
   _normalizeLightConstantBufferProfile() {
     const profile = this.profile.lightConstantBuffer;
@@ -516,27 +528,27 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Finds resources used by comparison-sample instructions before resource
-  * declarations are emitted, so those declarations can use shadow sampler
-  * types. A single GLSL uniform cannot be both a shadow and ordinary sampler;
-  * reject that shape explicitly instead of producing invalid GLSL.
-  *
-  * The same walk records the t#/s# pairing for EVERY sampled resource, not
-  * only the comparison ones. D3D carries sampler state on a shared sampler
-  * object and pairs it with a texture at the sample site; GLSL merges the two
-  * into one uniform, so that pairing is the only place the pairing exists once
-  * the shader is translated. Dropping it forces a consumer to guess, and the
-  * available guess - "the sampler whose register equals the texture's" - is
-  * numeric coincidence: with two pattern samplers declared, `NormalMap` at t3
-  * collides with the clamp sampler at s3 and every hull's normal map is read
-  * clamped instead of wrapped.
-  *
-  * @param {object} decoder Decoded DXBC instruction stream.
-  * @param {string} sourceName Source name used in error details.
-  * @returns {{comparison:Map<number,Set<number>>,paired:Map<number,Set<number>>}}
-  *   Resource register -> sampler registers, for comparison sampling and for
-  *   all sampling respectively.
+  /**
+  * Finds resources used by comparison-sample instructions before resource
+  * declarations are emitted, so those declarations can use shadow sampler
+  * types. A single GLSL uniform cannot be both a shadow and ordinary sampler;
+  * reject that shape explicitly instead of producing invalid GLSL.
+  *
+  * The same walk records the t#/s# pairing for EVERY sampled resource, not
+  * only the comparison ones. D3D carries sampler state on a shared sampler
+  * object and pairs it with a texture at the sample site; GLSL merges the two
+  * into one uniform, so that pairing is the only place the pairing exists once
+  * the shader is translated. Dropping it forces a consumer to guess, and the
+  * available guess - "the sampler whose register equals the texture's" - is
+  * numeric coincidence: with two pattern samplers declared, `NormalMap` at t3
+  * collides with the clamp sampler at s3 and every hull's normal map is read
+  * clamped instead of wrapped.
+  *
+  * @param {object} decoder Decoded DXBC instruction stream.
+  * @param {string} sourceName Source name used in error details.
+  * @returns {{comparison:Map<number,Set<number>>,paired:Map<number,Set<number>>}}
+  *   Resource register -> sampler registers, for comparison sampling and for
+  *   all sampling respectively.
   */
   _analyzeComparisonResources(decoder, sourceName) {
     const comparisonResources = new Map();
@@ -578,27 +590,27 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Normalizes the emulated-addressing profile.
-  *
-  * Keyed by RESOURCE register, not sampler register, because that is what
-  * every layer we touch keys on: GL stores wrap state on the texture object,
-  * ccpwgl keys overrides by texture name, and the emitted GLSL declares one
-  * sampler uniform per resource. Only D3D treats the mode as a property of a
-  * shared sampler - in `decalv5` five textures share one bordered sampler and
-  * each can resolve to a different mode, which a sampler-keyed scheme cannot
-  * represent.
-  *
-  * It arrives as a profile option because it CANNOT be discovered here: DXBC
-  * carries no sampler state, which lives in the Carbon container wrapping it.
-  * The caller also chooses the SUPERSET - listing a texture whose container
-  * mode needs no emulation is deliberate and cheap, because the runtime mode
-  * decides, and it is what lets an override correct a container that is wrong.
-  *
-  * Shape: `{ bufferRegister, textures: [{ registerIndex, borderColor }] }`.
-  *
-  * @returns {{bufferRegister:number, textures:Map<number,{color:number[]}>}|null}
-  *   Null when disabled.
+  /**
+  * Normalizes the emulated-addressing profile.
+  *
+  * Keyed by RESOURCE register, not sampler register, because that is what
+  * every layer we touch keys on: GL stores wrap state on the texture object,
+  * ccpwgl keys overrides by texture name, and the emitted GLSL declares one
+  * sampler uniform per resource. Only D3D treats the mode as a property of a
+  * shared sampler - in `decalv5` five textures share one bordered sampler and
+  * each can resolve to a different mode, which a sampler-keyed scheme cannot
+  * represent.
+  *
+  * It arrives as a profile option because it CANNOT be discovered here: DXBC
+  * carries no sampler state, which lives in the Carbon container wrapping it.
+  * The caller also chooses the SUPERSET - listing a texture whose container
+  * mode needs no emulation is deliberate and cheap, because the runtime mode
+  * decides, and it is what lets an override correct a container that is wrong.
+  *
+  * Shape: `{ bufferRegister, textures: [{ registerIndex, borderColor }] }`.
+  *
+  * @returns {{bufferRegister:number, textures:Map<number,{color:number[]}>}|null}
+  *   Null when disabled.
   */
   _normalizeEmulatedAddressingProfile() {
     const value = this.profile.emulatedAddressing;
@@ -673,19 +685,19 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Applies emulated address modes to one sample.
-  *
-  * Emits nothing for a texture the caller did not list, so a shader with no
-  * emulated addressing is byte-identical to one emitted without the profile.
-  *
-  * @param {object} state Emit state.
-  * @param {object} instruction Decoded texture instruction.
-  * @param {string} call The GLSL sample expression built so far.
-  * @param {string} coord The coordinate expression passed to that sample.
-  * @param {string} coordMask Component mask of the coordinate.
-  * @returns {string} The sample expression, addressed when the caller listed it.
-  * @private
+  /**
+  * Applies emulated address modes to one sample.
+  *
+  * Emits nothing for a texture the caller did not list, so a shader with no
+  * emulated addressing is byte-identical to one emitted without the profile.
+  *
+  * @param {object} state Emit state.
+  * @param {object} instruction Decoded texture instruction.
+  * @param {string} call The GLSL sample expression built so far.
+  * @param {string} coord The coordinate expression passed to that sample.
+  * @param {string} coordMask Component mask of the coordinate.
+  * @returns {string} The sample expression, addressed when the caller listed it.
+  * @private
   */
   _applyEmulatedAddressing(state, instruction, call, coord, coordMask) {
     const profile = state.emulatedAddressing;
@@ -748,18 +760,18 @@ class DxbcGlslEmitter {
     return `${borderHelper}(${rewritten}, ${addressedCoord}, ${modes}, vec4(${color}))`;
   }
 
-  /**
-  * Declares the emulated-addressing constant buffer, once per shader.
-  *
-  * Sized to the highest listed resource register so the array stays compact,
-  * the way Carbon emitters declare compact `cb` arrays. The register is
-  * caller-chosen and defaults to 8: shipped effects declare only cb0-4, 6 and
-  * 7, and ccpwgl already resolves `cb0`..`cb15` by name, so 8 needs no new
-  * binding table.
-  *
-  * @param {object} state Emit state.
-  * @returns {string} The buffer's GLSL name.
-  * @private
+  /**
+  * Declares the emulated-addressing constant buffer, once per shader.
+  *
+  * Sized to the highest listed resource register so the array stays compact,
+  * the way Carbon emitters declare compact `cb` arrays. The register is
+  * caller-chosen and defaults to 8: shipped effects declare only cb0-4, 6 and
+  * 7, and ccpwgl already resolves `cb0`..`cb15` by name, so 8 needs no new
+  * binding table.
+  *
+  * @param {object} state Emit state.
+  * @returns {string} The buffer's GLSL name.
+  * @private
   */
   _ensureAddressBuffer(state) {
     const {
@@ -820,10 +832,10 @@ class DxbcGlslEmitter {
     return name;
   }
 
-  /**
-  * Normalizes the optional packed local-light texture lowering profile.
-  *
-  * @returns {object|null} Normalized profile, or null when disabled.
+  /**
+  * Normalizes the optional packed local-light texture lowering profile.
+  *
+  * @returns {object|null} Normalized profile, or null when disabled.
   */
   _normalizeLightPackedTextureProfile() {
     const profile = this.profile.lightPackedTexture;
@@ -841,12 +853,12 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Declares the packed local-light texture ABI used to replace the
-  * LightIndexBuffer/LightBuffer/LightProfileArray trio with one RGBA32UI
-  * data texture.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Declares the packed local-light texture ABI used to replace the
+  * LightIndexBuffer/LightBuffer/LightProfileArray trio with one RGBA32UI
+  * data texture.
+  *
+  * @param {object} state Emit state.
   */
   _ensureLightPackedTexture(state) {
     const profile = state.lightPackedTexture;
@@ -868,9 +880,9 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits our packed profile helpers only when a sample uses them.
-   * @param {object} state Emit state.
+  /**
+   * Emits our packed profile helpers only when a sample uses them.
+   * @param {object} state Emit state.
    */
   _ensureLightProfileHelpers(state) {
     if (state.lightProfileHelpersDeclared) return;
@@ -885,11 +897,11 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Declares the local-light constant-buffer ABI used to replace the two
-  * tiled-light structured buffers without consuming sampler units.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Declares the local-light constant-buffer ABI used to replace the two
+  * tiled-light structured buffers without consuming sampler units.
+  *
+  * @param {object} state Emit state.
   */
   _ensureLightConstantBuffer(state) {
     const profile = state.lightConstantBuffer;
@@ -912,15 +924,15 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-  * Rejects compute shaders that need real compute-pipeline features (shared
-  * memory, barriers, atomics, raw/structured/typed UAV reads) instead of the
-  * "map-style" thread-per-fragment shape this emitter lowers. The message
-  * intentionally contains "not supported" so packaging's kill-list
-  * classifier regex (`/not supported|No GLSL lowering|unimplementable/i`)
-  * routes these to the exclusion list rather than the failure list.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Rejects compute shaders that need real compute-pipeline features (shared
+  * memory, barriers, atomics, raw/structured/typed UAV reads) instead of the
+  * "map-style" thread-per-fragment shape this emitter lowers. The message
+  * intentionally contains "not supported" so packaging's kill-list
+  * classifier regex (`/not supported|No GLSL lowering|unimplementable/i`)
+  * routes these to the exclusion list rather than the failure list.
+  *
+  * @param {object} state Emit state.
   */
   _assertMapStyleCompute(state) {
     for (const instruction of state.decoder.instructions) {
@@ -936,26 +948,26 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Pre-scans a map-style compute shader's `store_uav_typed` instructions and
-  * builds a per-UAV slice plan before any declaration is emitted.
-  *
-  * Straight-line constant propagation only: the address registers ASSAO-style
-  * Prepare passes build are `mov rX.<c>, l(k)` immediates, so the tracker
-  * records the last constant written to each temp component and treats every
-  * other write as dynamic. Each stored-to UAV register resolves to either
-  * `{ kind: "single" }` (at most one store; the array-slice coordinate, when
-  * present, is dropped — the host attaches the target layer via
-  * `framebufferTextureLayer`) or `{ kind: "multiSlice", slices, sliceByOffset }`
-  * (several stores at statically distinct texture2darray slices, each routed
-  * to its own fragment output — the host attaches those layers as sequential
-  * color attachments).
-  *
-  * Anything outside those two shapes cannot become one fragment pass, so the
-  * throw messages deliberately contain "not supported" for packaging's
-  * kill-list classifier (see `_assertMapStyleCompute`).
-  *
-  * @param {object} state Emit state.
+  /**
+  * Pre-scans a map-style compute shader's `store_uav_typed` instructions and
+  * builds a per-UAV slice plan before any declaration is emitted.
+  *
+  * Straight-line constant propagation only: the address registers ASSAO-style
+  * Prepare passes build are `mov rX.<c>, l(k)` immediates, so the tracker
+  * records the last constant written to each temp component and treats every
+  * other write as dynamic. Each stored-to UAV register resolves to either
+  * `{ kind: "single" }` (at most one store; the array-slice coordinate, when
+  * present, is dropped — the host attaches the target layer via
+  * `framebufferTextureLayer`) or `{ kind: "multiSlice", slices, sliceByOffset }`
+  * (several stores at statically distinct texture2darray slices, each routed
+  * to its own fragment output — the host attaches those layers as sequential
+  * color attachments).
+  *
+  * Anything outside those two shapes cannot become one fragment pass, so the
+  * throw messages deliberately contain "not supported" for packaging's
+  * kill-list classifier (see `_assertMapStyleCompute`).
+  *
+  * @param {object} state Emit state.
   */
   _analyzeUavStores(state) {
     for (const instruction of state.decoder.instructions) {
@@ -1028,16 +1040,16 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Updates the per-temp-component constant tracker for one instruction:
-  * `mov rX.<mask>, l(...)` records each written component's immediate dword,
-  * and any other write to a temp component invalidates it. Destination
-  * operands are exactly the mask-selection temp operands (DXBC sources
-  * always read through swizzle/select1), so this also handles multi-
-  * destination opcodes like `sincos` and `udiv` conservatively.
-  *
-  * @param {object} instruction Decoded non-declaration instruction.
-  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
+  /**
+  * Updates the per-temp-component constant tracker for one instruction:
+  * `mov rX.<mask>, l(...)` records each written component's immediate dword,
+  * and any other write to a temp component invalidates it. Destination
+  * operands are exactly the mask-selection temp operands (DXBC sources
+  * always read through swizzle/select1), so this also handles multi-
+  * destination opcodes like `sincos` and `udiv` conservatively.
+  *
+  * @param {object} instruction Decoded non-declaration instruction.
+  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
   */
   _trackTempConstants(instruction, constantTemps) {
     const source = instruction.operands[1];
@@ -1056,13 +1068,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Resolves the array-slice (z) component of a `store_uav_typed` address
-  * operand to a compile-time constant, or null when it is dynamic.
-  *
-  * @param {object} addressOperand Decoded address operand.
-  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
-  * @returns {number|null} Constant slice index, or null.
+  /**
+  * Resolves the array-slice (z) component of a `store_uav_typed` address
+  * operand to a compile-time constant, or null when it is dynamic.
+  *
+  * @param {object} addressOperand Decoded address operand.
+  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
+  * @returns {number|null} Constant slice index, or null.
   */
   _resolveSliceConstant(addressOperand, constantTemps) {
     if (addressOperand.type === 4) {
@@ -1077,14 +1089,14 @@ class DxbcGlslEmitter {
     return constantTemps.has(key) ? constantTemps.get(key) : null;
   }
 
-  /**
-  * Allocates the next map-style UAV fragment-output location, enforcing the
-  * `MAX_MAP_STYLE_UAV_OUTPUTS` attachment budget across single-output UAVs
-  * and per-slice multi-output UAVs alike.
-  *
-  * @param {object} state Emit state.
-  * @param {number} register UAV register index (error detail only).
-  * @returns {number} Allocated output location.
+  /**
+  * Allocates the next map-style UAV fragment-output location, enforcing the
+  * `MAX_MAP_STYLE_UAV_OUTPUTS` attachment budget across single-output UAVs
+  * and per-slice multi-output UAVs alike.
+  *
+  * @param {object} state Emit state.
+  * @param {number} register UAV register index (error detail only).
+  * @returns {number} Allocated output location.
   */
   _allocateUavOutputLocation(state, register) {
     const location = state.uavOutputCount;
@@ -1103,12 +1115,12 @@ class DxbcGlslEmitter {
   // Declarations
   // ------------------------------------------------------------------
 
-  /**
-   * Emits one decoded DXBC declaration into the GLSL interface and manifest.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC declaration instruction.
-   * @private
+  /**
+   * Emits one decoded DXBC declaration into the GLSL interface and manifest.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC declaration instruction.
+   * @private
    */
   _emitDeclaration(state, instruction) {
     const declaration = instruction.declaration;
@@ -1205,8 +1217,8 @@ class DxbcGlslEmitter {
               dimensionName: declaration.resourceDimensionName
             });
           }
-          if (state.detailMapArrayLayers.has(register)) {
-            this._declareDetailArrayMap(state, register, declaration, comparisonSamplers);
+          if (state.textureArrayLayers.has(register)) {
+            this._declareTextureArrayMap(state, register, declaration, comparisonSamplers);
             break;
           }
           const name = this.profile.samplerName(register, state.stageName);
@@ -1405,24 +1417,24 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Finds the signature element assigned to a register.
-   *
-   * @param {object|null} signature Decoded DXBC signature.
-   * @param {number} registerIndex Register index.
-   * @returns {object|null} Matching signature element.
-   * @private
+  /**
+   * Finds the signature element assigned to a register.
+   *
+   * @param {object|null} signature Decoded DXBC signature.
+   * @param {number} registerIndex Register index.
+   * @returns {object|null} Matching signature element.
+   * @private
    */
   _signatureElement(signature, registerIndex) {
     return signature?.elements.find(element => element.registerIndex === registerIndex) || null;
   }
 
-  /**
-   * Declares one vertex input using its Carbon semantic identity.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded input declaration.
-   * @private
+  /**
+   * Declares one vertex input using its Carbon semantic identity.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded input declaration.
+   * @private
    */
   _declareVertexInput(state, instruction) {
     const register = instruction.declaration.registerIndex;
@@ -1464,12 +1476,12 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Declares one pixel-stage varying or system input.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded input declaration.
-   * @private
+  /**
+   * Declares one pixel-stage varying or system input.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded input declaration.
+   * @private
    */
   _declarePixelInput(state, instruction) {
     const register = instruction.declaration.registerIndex;
@@ -1509,12 +1521,12 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Maps a supported system-generated input to its GLSL expression.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded system-input declaration.
-   * @private
+  /**
+   * Maps a supported system-generated input to its GLSL expression.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded system-input declaration.
+   * @private
    */
   _declareSystemInput(state, instruction) {
     const declaration = instruction.declaration;
@@ -1539,16 +1551,16 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Records which compute pseudo-input(s) a `dcl_input` declaration exposes.
-  * The actual GLSL (uniform + derived locals) is emitted once, after every
-  * declaration has been seen, by `_emitComputeInputPrelude` — `dcl_input`
-  * for a thread-id kind can appear before or after `dcl_thread_group` in the
-  * bytecode stream, and the flattened/group-id forms need the workgroup
-  * size regardless of declaration order.
-  *
-  * @param {object} state Emit state.
-  * @param {object} instruction `dcl_input` instruction with a thread-id-kind operand.
+  /**
+  * Records which compute pseudo-input(s) a `dcl_input` declaration exposes.
+  * The actual GLSL (uniform + derived locals) is emitted once, after every
+  * declaration has been seen, by `_emitComputeInputPrelude` — `dcl_input`
+  * for a thread-id kind can appear before or after `dcl_thread_group` in the
+  * bytecode stream, and the flattened/group-id forms need the workgroup
+  * size regardless of declaration order.
+  *
+  * @param {object} state Emit state.
+  * @param {object} instruction `dcl_input` instruction with a thread-id-kind operand.
   */
   _declareComputeInput(state, instruction) {
     const kind = instruction.declaration.operandTypeName;
@@ -1573,13 +1585,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Emits the shared `gl_FragCoord`-derived thread-id prelude for map-style
-  * compute shaders: a `cjsDispatchOrigin` uniform (so a dispatch can be
-  * tiled across more than one draw/viewport), then only the intermediate
-  * and final locals this shader actually declared inputs for.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Emits the shared `gl_FragCoord`-derived thread-id prelude for map-style
+  * compute shaders: a `cjsDispatchOrigin` uniform (so a dispatch can be
+  * tiled across more than one draw/viewport), then only the intermediate
+  * and final locals this shader actually declared inputs for.
+  *
+  * @param {object} state Emit state.
   */
   _emitComputeInputPrelude(state) {
     const used = state.computeInputsUsed;
@@ -1614,12 +1626,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Reads the workgroup size recorded by `dcl_thread_group`, required to
-  * split the flat thread id back into group id / id-in-group components.
-  *
-  * @param {object} state Emit state.
-  * @returns {[number,number,number]} Workgroup size.
+  /**
+  * Reads the workgroup size recorded by `dcl_thread_group`, required to
+  * split the flat thread id back into group id / id-in-group components.
+  *
+  * @param {object} state Emit state.
+  * @returns {[number,number,number]} Workgroup size.
   */
   _threadGroupSizeOrThrow(state) {
     if (!Array.isArray(state.threadGroup)) {
@@ -1630,12 +1642,12 @@ class DxbcGlslEmitter {
     return state.threadGroup;
   }
 
-  /**
-   * Declares one stage output and records its backend identity.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded output declaration.
-   * @private
+  /**
+   * Declares one stage output and records its backend identity.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded output declaration.
+   * @private
    */
   _declareOutput(state, instruction) {
     const declaration = instruction.declaration;
@@ -1693,12 +1705,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Materializes an immediate constant-buffer declaration.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded custom-data declaration.
-   * @private
+  /**
+   * Materializes an immediate constant-buffer declaration.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded custom-data declaration.
+   * @private
    */
   _declareImmediateConstantBuffer(state, instruction) {
     const rows = instruction.customData?.immediateConstantBuffer;
@@ -1709,11 +1721,11 @@ class DxbcGlslEmitter {
     state.declarationLines.push(`const vec4 ${state.icbName}[${rows.length}] = vec4[${rows.length}](`, ...literals.map((literal, index) => `    ${literal}${index < literals.length - 1 ? "," : ""}`), ");");
   }
 
-  /**
-   * Initializes paired vertex outputs that the source shader does not write.
-   *
-   * @param {object} state Mutable emission state.
-   * @private
+  /**
+   * Initializes paired vertex outputs that the source shader does not write.
+   *
+   * @param {object} state Mutable emission state.
+   * @private
    */
   _zeroFillUnwrittenOutputs(state) {
     const written = new Set();
@@ -1738,12 +1750,12 @@ class DxbcGlslEmitter {
   // Instructions
   // ------------------------------------------------------------------
 
-  /**
-   * Dispatches one decoded instruction to its GLSL lowering rule.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Dispatches one decoded instruction to its GLSL lowering rule.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _emitInstruction(state, instruction) {
     const lower = DxbcGlslEmitter.LOWERINGS[instruction.opcodeName];
@@ -1757,12 +1769,12 @@ class DxbcGlslEmitter {
     lower.call(this, state, instruction);
   }
 
-  /**
-   * Appends one correctly indented line to the emitted function body.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {string} text GLSL source line.
-   * @private
+  /**
+   * Appends one correctly indented line to the emitted function body.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {string} text GLSL source line.
+   * @private
    */
   _line(state, text) {
     // Packed uint words (and small integer results) must survive float
@@ -1809,12 +1821,12 @@ class DxbcGlslEmitter {
     state.bodyLines.push(`${"    ".repeat(state.indent)}${text}`);
   }
 
-  /**
-   * Counts the active components in a DXBC mask.
-   *
-   * @param {number} mask DXBC component bit mask.
-   * @returns {number} Active component count.
-   * @private
+  /**
+   * Counts the active components in a DXBC mask.
+   *
+   * @param {number} mask DXBC component bit mask.
+   * @returns {number} Active component count.
+   * @private
    */
   _maskWidth(mask) {
     let width = 0;
@@ -1824,51 +1836,51 @@ class DxbcGlslEmitter {
     return width || 4;
   }
 
-  /**
-   * Converts a DXBC component bit mask to GLSL swizzle characters.
-   *
-   * @param {number} mask DXBC component bit mask.
-   * @returns {string} GLSL component string.
-   * @private
+  /**
+   * Converts a DXBC component bit mask to GLSL swizzle characters.
+   *
+   * @param {number} mask DXBC component bit mask.
+   * @returns {string} GLSL component string.
+   * @private
    */
   _maskChars(mask) {
     return COMPONENTS.filter((_, bit) => mask & 1 << bit).join("") || "xyzw";
   }
 
-  /**
-  * Builds the lvalue text for one register-space destination component,
-  * remapped into the target variable's declared component space.
+  /**
+  * Builds the lvalue text for one register-space destination component,
+  * remapped into the target variable's declared component space.
   */
   _destComponentRef(state, destOperand, target, component) {
     const remapped = state.formatter.remapComponents(destOperand, component);
     return `${target.ref}${remapped ? `.${remapped}` : ""}`;
   }
 
-  /**
-   * Formats a resolved destination reference and optional mask.
-   *
-   * @param {object} target Resolved destination.
-   * @returns {string} GLSL lvalue text.
-   * @private
+  /**
+   * Formats a resolved destination reference and optional mask.
+   *
+   * @param {object} target Resolved destination.
+   * @returns {string} GLSL lvalue text.
+   * @private
    */
   _destText(target) {
     return `${target.ref}${target.mask ? `.${target.mask}` : ""}`;
   }
 
-  /**
-   * Selects the GLSL floating scalar or vector type for a width.
-   *
-   * @param {number} width Component width.
-   * @returns {string} GLSL type name.
-   * @private
+  /**
+   * Selects the GLSL floating scalar or vector type for a width.
+   *
+   * @param {number} width Component width.
+   * @returns {string} GLSL type name.
+   * @private
    */
   _vecType(width) {
     return width === 1 ? "float" : `vec${width}`;
   }
 
-  /**
-  * Reads a source at the destination mask's width, wrapping in a matching
-  * constructor so intrinsic arguments always type-check exactly.
+  /**
+  * Reads a source at the destination mask's width, wrapping in a matching
+  * constructor so intrinsic arguments always type-check exactly.
   */
   _vecArg(state, operand, destMask, as = "float") {
     const expression = state.formatter.sourceExpression(operand, {
@@ -1886,14 +1898,14 @@ class DxbcGlslEmitter {
     return `${ctor}(${expression})`;
   }
 
-  /**
-   * Resolves a destination operand and its register-space component mask.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {number} [operandIndex=0] Destination operand index.
-   * @returns {{target: object|null, mask: string}} Destination and mask.
-   * @private
+  /**
+   * Resolves a destination operand and its register-space component mask.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {number} [operandIndex=0] Destination operand index.
+   * @returns {{target: object|null, mask: string}} Destination and mask.
+   * @private
    */
   _destMask(state, instruction, operandIndex = 0) {
     const target = state.formatter.destination(instruction.operands[operandIndex]);
@@ -1906,25 +1918,25 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-   * Tests whether an operand produces one scalar component.
-   *
-   * @param {object} operand Decoded DXBC operand.
-   * @returns {boolean} True when the source is scalar.
-   * @private
+  /**
+   * Tests whether an operand produces one scalar component.
+   *
+   * @param {object} operand Decoded DXBC operand.
+   * @returns {boolean} True when the source is scalar.
+   * @private
    */
   _isScalarSource(operand) {
     return operand.selectionModeName === "select1" || operand.type === 4 && operand.componentCount === 1 || operand.componentCount === 1;
   }
 
-  /**
-   * Emits an assignment and applies instruction saturation when required.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} valueExpression GLSL right-hand expression.
-   * @param {object} [options={}] Assignment formatting options.
-   * @private
+  /**
+   * Emits an assignment and applies instruction saturation when required.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} valueExpression GLSL right-hand expression.
+   * @param {object} [options={}] Assignment formatting options.
+   * @private
    */
   _assign(state, instruction, valueExpression, options = {}) {
     const statement = state.formatter.assignment(instruction.operands[0], valueExpression, options);
@@ -1940,13 +1952,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Emits a width-correct floating binary infix operation.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL infix operator.
-   * @private
+  /**
+   * Emits a width-correct floating binary infix operation.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL infix operator.
+   * @private
    */
   _infixBinary(state, instruction, operator) {
     const {
@@ -1962,15 +1974,15 @@ class DxbcGlslEmitter {
     this._assignWidened(state, instruction, mask, `${a} ${operator} ${b}`, width === 1);
   }
 
-  /**
-   * Widens a scalar result when assigning it to a vector destination.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} mask Destination component mask.
-   * @param {string} expression GLSL expression.
-   * @param {boolean} rhsIsScalar Whether the expression is scalar.
-   * @private
+  /**
+   * Widens a scalar result when assigning it to a vector destination.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} mask Destination component mask.
+   * @param {string} expression GLSL expression.
+   * @param {boolean} rhsIsScalar Whether the expression is scalar.
+   * @private
    */
   _assignWidened(state, instruction, mask, expression, rhsIsScalar) {
     const value = rhsIsScalar && mask.length > 1 ? `vec${mask.length}(${expression})` : expression;
@@ -1979,13 +1991,13 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits a unary GLSL intrinsic with destination-width handling.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} glslName GLSL intrinsic name.
-   * @private
+  /**
+   * Emits a unary GLSL intrinsic with destination-width handling.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} glslName GLSL intrinsic name.
+   * @private
    */
   _helperUnary(state, instruction, glslName) {
     const {
@@ -1997,13 +2009,13 @@ class DxbcGlslEmitter {
     this._assignWidened(state, instruction, mask, `${glslName}(${src})`, state.formatter.expressionWidth(instruction.operands[1], mask) === 1);
   }
 
-  /**
-   * Emits a binary GLSL intrinsic with width-matched arguments.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} glslName GLSL intrinsic name.
-   * @private
+  /**
+   * Emits a binary GLSL intrinsic with width-matched arguments.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} glslName GLSL intrinsic name.
+   * @private
    */
   _helperBinary(state, instruction, glslName) {
     const {
@@ -2016,13 +2028,13 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits a dot product and replicates its scalar result when necessary.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} sourceMask Source component mask.
-   * @private
+  /**
+   * Emits a dot product and replicates its scalar result when necessary.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} sourceMask Source component mask.
+   * @private
    */
   _dotProduct(state, instruction, sourceMask) {
     const {
@@ -2036,16 +2048,16 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits scalar or vector comparison bits in the float register model.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {object} options Comparison options.
-   * @param {string} options.intrinsic GLSL vector comparison intrinsic.
-   * @param {string} options.operator GLSL scalar comparison operator.
-   * @param {"float"|"int"|"uint"} options.as Operand interpretation.
-   * @private
+  /**
+   * Emits scalar or vector comparison bits in the float register model.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} options Comparison options.
+   * @param {string} options.intrinsic GLSL vector comparison intrinsic.
+   * @param {string} options.operator GLSL scalar comparison operator.
+   * @param {"float"|"int"|"uint"} options.as Operand interpretation.
+   * @private
    */
   _comparison(state, instruction, {
     intrinsic,
@@ -2072,13 +2084,13 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `uintBitsToFloat(uvec${mask.length}(${intrinsic}(${a}, ${b})) * 0xFFFFFFFFu)`);
   }
 
-  /**
-   * Emits an unsigned bitwise operation through register bitcasts.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL bitwise operator.
-   * @private
+  /**
+   * Emits an unsigned bitwise operation through register bitcasts.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL bitwise operator.
+   * @private
    */
   _bitwiseBinary(state, instruction, operator) {
     const {
@@ -2089,14 +2101,14 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `uintBitsToFloat(${a} ${operator} ${b})`);
   }
 
-  /**
-   * Emits a signed or unsigned integer binary operation through bitcasts.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL integer operator.
-   * @param {"int"|"uint"} [as="int"] Integer interpretation.
-   * @private
+  /**
+   * Emits a signed or unsigned integer binary operation through bitcasts.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL integer operator.
+   * @param {"int"|"uint"} [as="int"] Integer interpretation.
+   * @private
    */
   _intBinary(state, instruction, operator, as = "int") {
     const {
@@ -2108,13 +2120,13 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `${wrap}(${a} ${operator} ${b})`);
   }
 
-  /**
-   * Formats the DXBC zero or nonzero control-flow condition.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @returns {string} GLSL boolean expression.
-   * @private
+  /**
+   * Formats the DXBC zero or nonzero control-flow condition.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @returns {string} GLSL boolean expression.
+   * @private
    */
   _condition(state, instruction) {
     const scalar = state.formatter.sourceExpression(instruction.operands[0], {
@@ -2125,12 +2137,12 @@ class DxbcGlslEmitter {
     return `${scalar} ${test} 0u`;
   }
 
-  /**
-   * Emits component-wise conditional moves without aliasing destinations.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Emits component-wise conditional moves without aliasing destinations.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _movc(state, instruction) {
     const destOperand = instruction.operands[0];
@@ -2175,12 +2187,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Emits the paired sine and cosine destinations in alias-safe order.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Emits the paired sine and cosine destinations in alias-safe order.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _sincos(state, instruction) {
     const [sinDest, cosDest, angle] = instruction.operands;
@@ -2208,23 +2220,23 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Declares the merged detail-map array, once, on the first member seen.
-   *
-   * Each member keeps its own entry in `resourceNames` pointing at the shared
-   * array, so every existing reference site resolves to it without knowing a
-   * merge happened. The declared dimension deliberately stays 2D: the layer is
-   * appended to the coordinate at each sample site rather than read out of the
-   * shader's own operand, which has no third component to give.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {number} register Resource register being declared.
-   * @param {object} declaration Decoded resource declaration.
-   * @param {Set<number>|null} comparisonSamplers Comparison samplers, when any.
-   * @private
+  /**
+   * Declares one merged array, once per family, on its first member seen.
+   *
+   * Each member keeps its own entry in `resourceNames` pointing at the shared
+   * array, so every existing reference site resolves to it without knowing a
+   * merge happened. The declared dimension deliberately stays 2D: the layer is
+   * appended to the coordinate at each sample site rather than read out of the
+   * shader's own operand, which has no third component to give.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {number} register Resource register being declared.
+   * @param {object} declaration Decoded resource declaration.
+   * @param {Set<number>|null} comparisonSamplers Comparison samplers, when any.
+   * @private
    */
-  _declareDetailArrayMap(state, register, declaration, comparisonSamplers) {
-    // A comparison-sampled or non-2D detail map is not the family the
+  _declareTextureArrayMap(state, register, declaration, comparisonSamplers) {
+    // A comparison-sampled or non-2D member is not the family the
     // recogniser promised, so refuse rather than emit a wrong declaration.
     if (comparisonSamplers || declaration.resourceDimension !== 3) {
       throw new WebglReadError("Detail-map array merging requires plain 2D textures without comparison sampling", {
@@ -2233,77 +2245,149 @@ class DxbcGlslEmitter {
         dimensionName: declaration.resourceDimensionName
       });
     }
+    const merged = state.textureArrayLayers.get(register);
+    const symbol = merged.symbol;
+    const members = [...state.textureArrayLayers].filter(([, entry]) => entry.symbol === symbol).map(([memberRegister]) => memberRegister);
     state.resourceDimensions.set(register, declaration.resourceDimension);
-    state.resourceNames.set(register, DETAIL_MAP_ARRAY_SYMBOL);
-    if (state.detailMapArrayDeclared) return;
-    state.detailMapArrayDeclared = true;
+    state.resourceNames.set(register, symbol);
+    if (state.declaredTextureArrays.has(symbol)) return;
+    state.declaredTextureArrays.add(symbol);
 
     // One GL uniform now stands for every merged layer, so it can carry only
     // one sampler state. Union the layers' pairings: if they disagree the
     // merge itself was invalid, and the packaging layer is where that is
     // detectable, because only it holds the sampler values to compare.
-    const merged = new Set();
-    for (const layerRegister of state.detailMapArrayLayers.keys()) {
-      for (const sampler of state.pairedSamplers.get(layerRegister) ?? []) merged.add(sampler);
+    const pairings = new Set();
+    for (const layerRegister of members) {
+      for (const sampler of state.pairedSamplers.get(layerRegister) ?? []) pairings.add(sampler);
     }
-    state.declarationLines.push(`uniform mediump sampler2DArray ${DETAIL_MAP_ARRAY_SYMBOL};`);
+
+    // A packing family stays a plain 2D texture - its members are channels
+    // of one texel, not layers of one stack - so the declaration, the
+    // sampler type and the coordinate all stay 2D.
+    const packing = merged.kind === "pack";
+    const samplerTypeName = packing ? "sampler2D" : "sampler2DArray";
+    state.declarationLines.push(`uniform mediump ${samplerTypeName} ${symbol};`);
     state.bindings.push({
       kind: "resource",
       registerIndex: register,
-      name: DETAIL_MAP_ARRAY_SYMBOL,
-      samplerType: "sampler2DArray",
-      dimensionName: "texture2darray",
-      arrayLayerCount: state.detailMapArrayLayers.size,
-      mergedFrom: [...state.detailMapArrayLayers.keys()],
-      ...(merged.size ? {
-        pairedSamplerRegisters: [...merged].sort((a, b) => a - b)
+      name: symbol,
+      samplerType: samplerTypeName,
+      dimensionName: packing ? "texture2d" : "texture2darray",
+      ...(packing ? {
+        packedChannelCount: members.length
+      } : {
+        arrayLayerCount: members.length
+      }),
+      mergedFrom: members,
+      mergedFamily: merged.family,
+      ...(pairings.size ? {
+        pairedSamplerRegisters: [...pairings].sort((a, b) => a - b)
       } : {})
     });
   }
 
-  /**
-   * Returns the array layer a texture operand maps to, when it was merged.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} texOperand Texture resource operand.
-   * @returns {number|null} Layer index, or null when the register was not merged.
-   * @private
+  /**
+   * Builds the register -> merged array map from the profile.
+   *
+   * Two spellings, one meaning: `detailMapArrayRegisters` is the detail
+   * family's original key, and `textureArrayFamilies` carries any family
+   * including that one. A caller may pass either.
+   *
+   * @returns {Map<number, object>} register -> { symbol, layer, family }
+   * @private
+   */
+  _textureArrayLayerMap() {
+    const map = new Map();
+    const families = [...(this.profile.detailMapArrayRegisters?.length ? [{
+      family: "detail-map-array",
+      outputName: "DetailArrayMap",
+      registers: this.profile.detailMapArrayRegisters
+    }] : []), ...(this.profile.textureArrayFamilies || [])];
+    for (const entry of families) {
+      const symbol = `s${entry.outputName}`;
+      const kind = entry.kind ?? "array";
+      for (const [layer, register] of (entry.registers || []).entries()) {
+        map.set(register, {
+          symbol,
+          layer,
+          kind,
+          // For a packing family the member's position IS its channel.
+          // Nothing else decides it, which is why the family table's
+          // parameter order is the one authority for both ends.
+          channel: kind === "pack" ? "xyzw"[layer] : null,
+          family: entry.family,
+          outputName: entry.outputName
+        });
+      }
+    }
+    return map;
+  }
+
+  /**
+   * Returns the array layer a texture operand maps to, when it was merged.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} texOperand Texture resource operand.
+   * @returns {number|null} Layer index, or null when the register was not merged.
+   * @private
+   */
+  _textureArrayLayer(state, texOperand) {
+    const merged = state.textureArrayLayers.get(texOperand.registerIndex);
+
+    // A packed member has no layer: its coordinate is unchanged and the
+    // redirect happens on the RESULT, in `_mergedChannel`.
+    return merged === undefined || merged.kind === "pack" ? null : merged.layer;
+  }
+
+  /**
+   * Returns the packed channel a texture operand reads, when it was packed.
+   *
+   * The member's whole sampled value becomes that one channel broadcast, which
+   * is faithful precisely because the premise of a packing family is that the
+   * map is consumed for a single scalar. A member read for more than that is
+   * not a packing candidate and the family table is where that is decided.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} texOperand Texture resource operand.
+   * @returns {string|null} Channel letter, or null when not packed.
+   * @private
    */
-  _detailMapArrayLayer(state, texOperand) {
-    const layer = state.detailMapArrayLayers.get(texOperand.registerIndex);
-    return layer === undefined ? null : layer;
-  }
-
-  /**
-   * Refuses an operation that cannot be redirected at an array layer.
-   *
-   * Recognising the detail family proves the resources are mergeable; it does
-   * not prove every *use* is. A texel fetch or a size query against a merged
-   * register would silently mean something different once the register became
-   * one layer of an array, so those fail the build instead.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {object} texOperand Texture resource operand.
-   * @private
+  _mergedChannel(state, texOperand) {
+    const merged = state.textureArrayLayers.get(texOperand.registerIndex);
+    return merged === undefined || merged.kind !== "pack" ? null : merged.channel;
+  }
+
+  /**
+   * Refuses an operation that cannot be redirected at an array layer.
+   *
+   * Recognising the detail family proves the resources are mergeable; it does
+   * not prove every *use* is. A texel fetch or a size query against a merged
+   * register would silently mean something different once the register became
+   * one layer of an array, so those fail the build instead.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} texOperand Texture resource operand.
+   * @private
    */
   _rejectDetailArrayMapUse(state, instruction, texOperand) {
-    if (!state.detailMapArrayLayers.has(texOperand.registerIndex)) return;
-    throw new WebglReadError(`Detail map merged into an array is used by ${instruction.opcodeName}, ` + "which this emitter cannot redirect at an array layer", {
+    if (!state.textureArrayLayers.has(texOperand.registerIndex)) return;
+    throw new WebglReadError(`${state.textureArrayLayers.get(texOperand.registerIndex).outputName} layer is used by ` + `${instruction.opcodeName}, which this emitter cannot redirect at an array layer`, {
       source: state.sourceName,
       register: texOperand.registerIndex,
       opcodeName: instruction.opcodeName
     });
   }
 
-  /**
-   * Resolves and validates the declared dimension of a texture operand.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {object} texOperand Texture resource operand.
-   * @returns {number} DXBC resource-dimension code.
-   * @private
+  /**
+   * Resolves and validates the declared dimension of a texture operand.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} texOperand Texture resource operand.
+   * @returns {number} DXBC resource-dimension code.
+   * @private
    */
   _resourceDimension(state, instruction, texOperand) {
     const dimension = state.resourceDimensions.get(texOperand.registerIndex);
@@ -2317,18 +2401,18 @@ class DxbcGlslEmitter {
     return dimension;
   }
 
-  /**
-   * Emits a regular, LOD, bias, gradient, or comparison texture sample.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC texture instruction.
-   * @param {object} [options={}] Sampling-mode operand indexes.
-   * @param {number|null} [options.lodOperandIndex=null] Explicit LOD operand.
-   * @param {number|null} [options.biasOperandIndex=null] LOD bias operand.
-   * @param {number[]|null} [options.gradOperandIndexes=null] Gradient operands.
-   * @param {number|null} [options.comparisonRefOperandIndex=null] Comparison reference operand.
-   * @param {boolean} [options.forceLodZero=false] Whether to force the LOD-zero adaptation.
-   * @private
+  /**
+   * Emits a regular, LOD, bias, gradient, or comparison texture sample.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC texture instruction.
+   * @param {object} [options={}] Sampling-mode operand indexes.
+   * @param {number|null} [options.lodOperandIndex=null] Explicit LOD operand.
+   * @param {number|null} [options.biasOperandIndex=null] LOD bias operand.
+   * @param {number[]|null} [options.gradOperandIndexes=null] Gradient operands.
+   * @param {number|null} [options.comparisonRefOperandIndex=null] Comparison reference operand.
+   * @param {boolean} [options.forceLodZero=false] Whether to force the LOD-zero adaptation.
+   * @private
    */
   _textureSample(state, instruction, {
     lodOperandIndex = null,
@@ -2405,11 +2489,11 @@ class DxbcGlslEmitter {
     }
     const dimension = this._resourceDimension(state, instruction, texOperand);
     const coordMask = COORD_MASK_BY_DIMENSION[dimension];
-    const detailLayer = this._detailMapArrayLayer(state, texOperand);
+    const arrayLayer = this._textureArrayLayer(state, texOperand);
     const baseCoord = this._vecArg(state, coordOperand, coordMask);
     // A merged detail map keeps its 2D coordinate and gains the layer as a
     // literal third component; the register it came from is the layer.
-    const coord = detailLayer === null ? baseCoord : `vec3(${baseCoord}, ${detailLayer}.0)`;
+    const coord = arrayLayer === null ? baseCoord : `vec3(${baseCoord}, ${arrayLayer}.0)`;
     const texName = state.formatter.registerReference(texOperand);
     const returnSwizzle = [...mask].map(component => texOperand.swizzle ? texOperand.swizzle["xyzw".indexOf(component)] : component).join("");
     if (comparisonRefOperandIndex !== null) {
@@ -2459,17 +2543,24 @@ class DxbcGlslEmitter {
       call = `texture(${texName}, ${coord})`;
     }
     call = this._applyEmulatedAddressing(state, instruction, call, coord, coordMask);
+
+    // A packed member's texel carries three other maps' scalars in its other
+    // channels, so the value has to be reduced to its own before the
+    // instruction's swizzle runs - otherwise a read of .y would silently
+    // return a neighbouring map.
+    const packedChannel = this._mergedChannel(state, texOperand);
+    if (packedChannel !== null) call = `vec4((${call}).${packedChannel})`;
     this._assign(state, instruction, `${call}.${returnSwizzle}`, {
       saturate: instruction.saturate
     });
   }
 
-  /**
-   * Emits an integer-coordinate texel fetch for a declared resource.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC load instruction.
-   * @private
+  /**
+   * Emits an integer-coordinate texel fetch for a declared resource.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC load instruction.
+   * @private
    */
   _texelFetch(state, instruction) {
     const {
@@ -2505,9 +2596,9 @@ class DxbcGlslEmitter {
   }
 }
 
-/**
- * Per-opcode lowering table. Every rule cites its family spec in
- * `docs/dxbc-lowering/`; templates are HLSLcc-derived, see each doc.
+/**
+ * Per-opcode lowering table. Every rule cites its family spec in
+ * `docs/dxbc-lowering/`; templates are HLSLcc-derived, see each doc.
  */
 DxbcGlslEmitter.LOWERINGS = {
   // --- float-alu ---
@@ -3088,11 +3179,11 @@ DxbcGlslEmitter.LOWERINGS = {
   }
 };
 
-/**
- * `ld_structured` lowering. Vertex UBO path reads `name.data[row]` vec4 rows;
- * pixel data-texture path reads RGBA32UI texels (4 dwords per texel, fixed
- * 2048-texel row width). 16-byte-aligned reads use one static channel per
- * component; unaligned reads fall back to per-dword dynamic addressing.
+/**
+ * `ld_structured` lowering. Vertex UBO path reads `name.data[row]` vec4 rows;
+ * pixel data-texture path reads RGBA32UI texels (4 dwords per texel, fixed
+ * 2048-texel row width). 16-byte-aligned reads use one static channel per
+ * component; unaligned reads fall back to per-dword dynamic addressing.
  */
 DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruction) {
   const target = state.formatter.destination(instruction.operands[0]);
@@ -3201,10 +3292,10 @@ DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruct
   }
 };
 
-/**
- * `resinfo` lowering: width/height/depth via textureSize per live destination
- * component; the 4th (mip-count) channel has no WebGL2 equivalent and throws
- * only when a shader actually reads it.
+/**
+ * `resinfo` lowering: width/height/depth via textureSize per live destination
+ * component; the 4th (mip-count) channel has no WebGL2 equivalent and throws
+ * only when a shader actually reads it.
  */
 DxbcGlslEmitter.prototype._resinfo = function _resinfo(state, instruction) {
   const {
@@ -3248,8 +3339,8 @@ DxbcGlslEmitter.prototype._resinfo = function _resinfo(state, instruction) {
   }
 };
 
-/**
- * Shared int/uint min-max lowering used by imax/imin/umax/umin.
+/**
+ * Shared int/uint min-max lowering used by imax/imin/umax/umin.
  */
 DxbcGlslEmitter.prototype._intMinMax = function _intMinMax(state, instruction, fn, as) {
   const {
@@ -3261,16 +3352,16 @@ DxbcGlslEmitter.prototype._intMinMax = function _intMinMax(state, instruction, f
   this._assign(state, instruction, `${wrap}(${fn}(${a}, ${b}))`);
 };
 
-/**
- * `gather4` lowering: fetches one channel from each of the four texels a
- * bilinear sample would blend, via the `hlslcc_textureGather4Emulated` /
- * `hlslcc_textureGather4ArrayEmulated` helpers (GLSL ES 3.00 has no
- * `textureGather`). Only 2D and 2D-array resources are supported — the
- * dimensions the AO/blur/FSR/CAS map-style corpus this lowering targets is
- * known to use (ASSAO gathers from its deinterleaved texture2darray slices).
- *
- * @param {object} state Emit state.
- * @param {object} instruction `gather4` instruction.
+/**
+ * `gather4` lowering: fetches one channel from each of the four texels a
+ * bilinear sample would blend, via the `hlslcc_textureGather4Emulated` /
+ * `hlslcc_textureGather4ArrayEmulated` helpers (GLSL ES 3.00 has no
+ * `textureGather`). Only 2D and 2D-array resources are supported — the
+ * dimensions the AO/blur/FSR/CAS map-style corpus this lowering targets is
+ * known to use (ASSAO gathers from its deinterleaved texture2darray slices).
+ *
+ * @param {object} state Emit state.
+ * @param {object} instruction `gather4` instruction.
  */
 DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
   const {
@@ -3290,11 +3381,21 @@ DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
   // A merged detail map is declared 2D but sampled through an array, so the
   // array helper and the layered coordinate are selected by the merge rather
   // than by the declared dimension.
-  const detailLayer = this._detailMapArrayLayer(state, texOperand);
-  const asArray = dimension === 8 || detailLayer !== null;
+  // Gather returns four neighbouring texels of ONE channel; for a packed
+  // member that channel is the pack's, not the map's, and no swizzle after
+  // the fact recovers it. Refuse rather than emit something plausible.
+  if (this._mergedChannel(state, texOperand) !== null) {
+    throw new WebglReadError(`${state.textureArrayLayers.get(texOperand.registerIndex).outputName} channel is used by ` + `${instruction.opcodeName}, which this emitter cannot redirect at a packed channel`, {
+      source: state.sourceName,
+      register: texOperand.registerIndex,
+      opcodeName: instruction.opcodeName
+    });
+  }
+  const arrayLayer = this._textureArrayLayer(state, texOperand);
+  const asArray = dimension === 8 || arrayLayer !== null;
   const helper = this.helpers.require(asArray ? "hlslcc_textureGather4ArrayEmulated" : "hlslcc_textureGather4Emulated");
   const baseCoord = this._vecArg(state, coordOperand, dimension === 8 ? "xyz" : "xy");
-  const coord = detailLayer === null ? baseCoord : `vec3(${baseCoord}, ${detailLayer}.0)`;
+  const coord = arrayLayer === null ? baseCoord : `vec3(${baseCoord}, ${arrayLayer}.0)`;
   const texName = state.formatter.registerReference(texOperand);
   const channelLetter = this._gather4Channel(samplerOperand);
   const channelIndex = "xyzw".indexOf(channelLetter);
@@ -3304,13 +3405,13 @@ DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
   });
 };
 
-/**
- * Reads the gathered-channel selector `gather4`/`gather4_po` carry on their
- * sampler operand (a 1-component swizzle; red/`x` is the default when no
- * selection is encoded).
- *
- * @param {object} operand Decoded sampler operand.
- * @returns {string} Channel letter (`x`/`y`/`z`/`w`).
+/**
+ * Reads the gathered-channel selector `gather4`/`gather4_po` carry on their
+ * sampler operand (a 1-component swizzle; red/`x` is the default when no
+ * selection is encoded).
+ *
+ * @param {object} operand Decoded sampler operand.
+ * @returns {string} Channel letter (`x`/`y`/`z`/`w`).
  */
 DxbcGlslEmitter.prototype._gather4Channel = function _gather4Channel(operand) {
   if (operand.selectionModeName === "select1" && operand.selected) {
@@ -3322,22 +3423,22 @@ DxbcGlslEmitter.prototype._gather4Channel = function _gather4Channel(operand) {
   return "x";
 };
 
-/**
- * Assembles the final GLSL text.
+/**
+ * Assembles the final GLSL text.
  */
-/**
- * The depth-range fixup emitted at the end of a vertex stage, by source range.
- *
- * Both entries map their range onto GL NDC [-1, 1] and both compose to the
- * identity with a projection of the matching form, so an unbiased vertex is
- * unchanged either way. See `profile.depthRange`.
- * @type {Object.<string,string>}
+/**
+ * The depth-range fixup emitted at the end of a vertex stage, by source range.
+ *
+ * Both entries map their range onto GL NDC [-1, 1] and both compose to the
+ * identity with a projection of the matching form, so an unbiased vertex is
+ * unchanged either way. See `profile.depthRange`.
+ * @type {Object.<string,string>}
  */
-/**
- * The clip-space Y flip uniform and tail emitted when `profile.clipYFlip` is set.
- * Name and statements match CCP's shipped gles2 vertex bodies exactly, so a
- * consumer drives translated and legacy stages through the one uniform.
- * @type {string}
+/**
+ * The clip-space Y flip uniform and tail emitted when `profile.clipYFlip` is set.
+ * Name and statements match CCP's shipped gles2 vertex bodies exactly, so a
+ * consumer drives translated and legacy stages through the one uniform.
+ * @type {string}
  */
 const CLIP_Y_FLIP_UNIFORM = "ssyf";