@carbonenginejs/runtime-resource 0.13.0 → 0.15.0

package/dist/resource/shader/reflection/carbonRecordFields.js

@@ -1,159 +1,159 @@
-// Shared field accessors for Carbon v15 description records.
-//
-// The record tree is what the one Carbon effect reader emits
-// (`format/carbonEffect/carbonEffectRecords.js`). Each reflection class maps its
-// own record, but three field encodings recur across all of them and are worth
-// naming once rather than open-coding at every call site:
-//
-//   - a string is an arena reference `{offset, value}`, not a string;
-//   - an annotation value is four raw little-endian bytes, because Carbon writes
-//     it through one union member and reads it through another, so the bytes are
-//     the only faithful carrier;
-//   - a blob is `{size, offset, bytes}` with `offset === 0xffffffff` meaning the
-//     reference was never set, which is not the same as an empty payload.
-//
-// Both directions live here, as `recordX` and `toRecordX` pairs. They are held
-// apart by the round trip rather than by separation: records in, classes, records
-// out, compared byte for byte over the shipped corpus, so a mistake that
-// satisfied both sides would have to be an exact inverse of itself.
-
-const rawValueBuffer = new DataView(new ArrayBuffer(4));
-
-/**
- * Reads the text out of an arena string reference.
- *
- * @param {{offset:number,value:string}|null|undefined} ref String reference.
- * @returns {string} The referenced text, or "" when unset.
- */
-function recordText(ref) {
-  return String(ref?.value ?? "");
-}
-
-/**
- * Decodes an annotation record's four raw bytes as the `u32` bit pattern the
- * reflection classes carry as `rawValue`.
- *
- * Carbon stores the value as a `{float,int32_t}` union and the type byte decides
- * which member is meaningful, so the bits travel untyped and each annotation type
- * reinterprets them itself. Decoding to a number here — rather than to a float —
- * is what keeps a value like `-FLT_MAX` exact.
- *
- * @param {Uint8Array|null|undefined} bytes Four little-endian bytes.
- * @returns {number} The unsigned 32-bit pattern those bytes carry.
- */
-function recordRawValue(bytes) {
-  if (!bytes || bytes.length < 4) return 0;
-  rawValueBuffer.setUint8(0, bytes[0]);
-  rawValueBuffer.setUint8(1, bytes[1]);
-  rawValueBuffer.setUint8(2, bytes[2]);
-  rawValueBuffer.setUint8(3, bytes[3]);
-  return rawValueBuffer.getUint32(0, true);
-}
-
-/**
- * Re-encodes a record's `float` as the `u32` bit pattern the reflection classes
- * carry in their `*Raw` sampler fields.
- *
- * The container stores sampler LOD and border values as real floats, but the
- * class keeps the bits, so a value like `-FLT_MAX` survives serialization without
- * a decimal round trip. Reading the float and re-encoding it here is exact: the
- * record's value came from a `f32` read, so it is already representable.
- *
- * @param {number} value Float value from a sampler record.
- * @returns {number} The unsigned 32-bit pattern encoding that float.
- */
-function recordRawBits(value) {
-  rawValueBuffer.setFloat32(0, Number.isFinite(value) ? value : 0, true);
-  return rawValueBuffer.getUint32(0, true);
-}
-
-/**
- * Wraps text as the arena string reference the writer interns.
- *
- * The offset is always 0: the writer assigns real offsets while building the
- * arena, and any value here would be discarded. Carrying the text is the whole
- * job.
- *
- * @param {string} value Text value.
- * @returns {{offset:number,value:string}} String reference.
- */
-function toRecordText(value) {
-  return {
-    offset: 0,
-    value: String(value ?? "")
-  };
-}
-
-/**
- * Encodes a `u32` bit pattern as an annotation record's four raw bytes.
- *
- * The inverse of {@link recordRawValue}, and raw for the same reason: the value
- * is written through one union member and read through another, so no numeric
- * conversion may happen on the way out either.
- *
- * @param {number} rawValue Unsigned 32-bit pattern.
- * @returns {Uint8Array} Four little-endian bytes.
- */
-function toRecordRawValue(rawValue) {
-  const bytes = new Uint8Array(4);
-  rawValueBuffer.setUint32(0, rawValue >>> 0, true);
-  for (let index = 0; index < 4; index += 1) {
-    bytes[index] = rawValueBuffer.getUint8(index);
-  }
-  return bytes;
-}
-
-/**
- * Decodes a `*Raw` sampler field back to the float the record stores.
- *
- * The inverse of {@link recordRawBits}. Assigning the raw `u32` straight across
- * would write `4286578687.0` where the file says `-3.4028235e38`, and every
- * structural check in the container would accept it.
- *
- * @param {number} bits Raw 32-bit pattern.
- * @returns {number} The float those bits encode.
- */
-function toRecordFloat(bits) {
-  rawValueBuffer.setUint32(0, (bits ?? 0) >>> 0, true);
-  return rawValueBuffer.getFloat32(0, true);
-}
-
-/**
- * Wraps bytes as the record codec's sized blob reference.
- *
- * A zero-length blob keeps the offset word the file carried, because the writer
- * passes it straight through rather than interning anything. That word is
- * usually `0xffffffff`, but not always — measured across the shipped corpus,
- * 150 of 4833 files carry a live-looking offset behind a zero size, and
- * normalizing it changes the bytes and can make two distinct bodies collapse
- * into one. An empty payload and an absent one are not the same thing.
- *
- * @param {Uint8Array} bytes Payload bytes.
- * @param {number} [declaredSize] Size to declare when tracked separately.
- * @param {number} [unsetOffset] Offset word to keep when the size is zero.
- * @returns {{size:number,offset:number,bytes:Uint8Array}} Blob reference.
- */
-function toRecordBlob(bytes, declaredSize, unsetOffset = 0xffffffff) {
-  const owned = bytes instanceof Uint8Array ? bytes : new Uint8Array(0);
-  const size = declaredSize ?? owned.byteLength;
-  return {
-    size,
-    offset: size === 0 ? unsetOffset >>> 0 : 0,
-    bytes: owned
-  };
-}
-
-/**
- * Returns a blob reference's payload bytes, or an empty view when the reference
- * was never set.
- *
- * @param {{size:number,offset:number,bytes:Uint8Array}|null|undefined} ref Blob.
- * @returns {Uint8Array} Owned-by-the-container view over the payload.
- */
-function recordBytes(ref) {
-  const bytes = ref?.bytes;
-  return bytes instanceof Uint8Array ? bytes : new Uint8Array(0);
-}
-
-export { recordBytes, recordRawBits, recordRawValue, recordText, toRecordBlob, toRecordFloat, toRecordRawValue, toRecordText };
-//# sourceMappingURL=carbonRecordFields.js.map
+// Shared field accessors for Carbon v15 description records.
+//
+// The record tree is what the one Carbon effect reader emits
+// (`format/carbonEffect/carbonEffectRecords.js`). Each reflection class maps its
+// own record, but three field encodings recur across all of them and are worth
+// naming once rather than open-coding at every call site:
+//
+//   - a string is an arena reference `{offset, value}`, not a string;
+//   - an annotation value is four raw little-endian bytes, because Carbon writes
+//     it through one union member and reads it through another, so the bytes are
+//     the only faithful carrier;
+//   - a blob is `{size, offset, bytes}` with `offset === 0xffffffff` meaning the
+//     reference was never set, which is not the same as an empty payload.
+//
+// Both directions live here, as `recordX` and `toRecordX` pairs. They are held
+// apart by the round trip rather than by separation: records in, classes, records
+// out, compared byte for byte over the shipped corpus, so a mistake that
+// satisfied both sides would have to be an exact inverse of itself.
+
+const rawValueBuffer = new DataView(new ArrayBuffer(4));
+
+/**
+ * Reads the text out of an arena string reference.
+ *
+ * @param {{offset:number,value:string}|null|undefined} ref String reference.
+ * @returns {string} The referenced text, or "" when unset.
+ */
+function recordText(ref) {
+  return String(ref?.value ?? "");
+}
+
+/**
+ * Decodes an annotation record's four raw bytes as the `u32` bit pattern the
+ * reflection classes carry as `rawValue`.
+ *
+ * Carbon stores the value as a `{float,int32_t}` union and the type byte decides
+ * which member is meaningful, so the bits travel untyped and each annotation type
+ * reinterprets them itself. Decoding to a number here — rather than to a float —
+ * is what keeps a value like `-FLT_MAX` exact.
+ *
+ * @param {Uint8Array|null|undefined} bytes Four little-endian bytes.
+ * @returns {number} The unsigned 32-bit pattern those bytes carry.
+ */
+function recordRawValue(bytes) {
+  if (!bytes || bytes.length < 4) return 0;
+  rawValueBuffer.setUint8(0, bytes[0]);
+  rawValueBuffer.setUint8(1, bytes[1]);
+  rawValueBuffer.setUint8(2, bytes[2]);
+  rawValueBuffer.setUint8(3, bytes[3]);
+  return rawValueBuffer.getUint32(0, true);
+}
+
+/**
+ * Re-encodes a record's `float` as the `u32` bit pattern the reflection classes
+ * carry in their `*Raw` sampler fields.
+ *
+ * The container stores sampler LOD and border values as real floats, but the
+ * class keeps the bits, so a value like `-FLT_MAX` survives serialization without
+ * a decimal round trip. Reading the float and re-encoding it here is exact: the
+ * record's value came from a `f32` read, so it is already representable.
+ *
+ * @param {number} value Float value from a sampler record.
+ * @returns {number} The unsigned 32-bit pattern encoding that float.
+ */
+function recordRawBits(value) {
+  rawValueBuffer.setFloat32(0, Number.isFinite(value) ? value : 0, true);
+  return rawValueBuffer.getUint32(0, true);
+}
+
+/**
+ * Wraps text as the arena string reference the writer interns.
+ *
+ * The offset is always 0: the writer assigns real offsets while building the
+ * arena, and any value here would be discarded. Carrying the text is the whole
+ * job.
+ *
+ * @param {string} value Text value.
+ * @returns {{offset:number,value:string}} String reference.
+ */
+function toRecordText(value) {
+  return {
+    offset: 0,
+    value: String(value ?? "")
+  };
+}
+
+/**
+ * Encodes a `u32` bit pattern as an annotation record's four raw bytes.
+ *
+ * The inverse of {@link recordRawValue}, and raw for the same reason: the value
+ * is written through one union member and read through another, so no numeric
+ * conversion may happen on the way out either.
+ *
+ * @param {number} rawValue Unsigned 32-bit pattern.
+ * @returns {Uint8Array} Four little-endian bytes.
+ */
+function toRecordRawValue(rawValue) {
+  const bytes = new Uint8Array(4);
+  rawValueBuffer.setUint32(0, rawValue >>> 0, true);
+  for (let index = 0; index < 4; index += 1) {
+    bytes[index] = rawValueBuffer.getUint8(index);
+  }
+  return bytes;
+}
+
+/**
+ * Decodes a `*Raw` sampler field back to the float the record stores.
+ *
+ * The inverse of {@link recordRawBits}. Assigning the raw `u32` straight across
+ * would write `4286578687.0` where the file says `-3.4028235e38`, and every
+ * structural check in the container would accept it.
+ *
+ * @param {number} bits Raw 32-bit pattern.
+ * @returns {number} The float those bits encode.
+ */
+function toRecordFloat(bits) {
+  rawValueBuffer.setUint32(0, (bits ?? 0) >>> 0, true);
+  return rawValueBuffer.getFloat32(0, true);
+}
+
+/**
+ * Wraps bytes as the record codec's sized blob reference.
+ *
+ * A zero-length blob keeps the offset word the file carried, because the writer
+ * passes it straight through rather than interning anything. That word is
+ * usually `0xffffffff`, but not always — measured across the shipped corpus,
+ * 150 of 4833 files carry a live-looking offset behind a zero size, and
+ * normalizing it changes the bytes and can make two distinct bodies collapse
+ * into one. An empty payload and an absent one are not the same thing.
+ *
+ * @param {Uint8Array} bytes Payload bytes.
+ * @param {number} [declaredSize] Size to declare when tracked separately.
+ * @param {number} [unsetOffset] Offset word to keep when the size is zero.
+ * @returns {{size:number,offset:number,bytes:Uint8Array}} Blob reference.
+ */
+function toRecordBlob(bytes, declaredSize, unsetOffset = 0xffffffff) {
+  const owned = bytes instanceof Uint8Array ? bytes : new Uint8Array(0);
+  const size = declaredSize ?? owned.byteLength;
+  return {
+    size,
+    offset: size === 0 ? unsetOffset >>> 0 : 0,
+    bytes: owned
+  };
+}
+
+/**
+ * Returns a blob reference's payload bytes, or an empty view when the reference
+ * was never set.
+ *
+ * @param {{size:number,offset:number,bytes:Uint8Array}|null|undefined} ref Blob.
+ * @returns {Uint8Array} Owned-by-the-container view over the payload.
+ */
+function recordBytes(ref) {
+  const bytes = ref?.bytes;
+  return bytes instanceof Uint8Array ? bytes : new Uint8Array(0);
+}
+
+export { recordBytes, recordRawBits, recordRawValue, recordText, toRecordBlob, toRecordFloat, toRecordRawValue, toRecordText };
+//# sourceMappingURL=carbonRecordFields.js.map

package/dist/resource/shader/reflection/shaderStage.js

@@ -1,22 +1,22 @@
-/** Number of shader stages Carbon's fixed-width stage array holds. */
-const SHADER_STAGE_COUNT = 6;
-
-/**
- * Require one of Carbon's six authored shader-stage indices.
- *
- * Carbon addresses stages positionally through a fixed-width array on the pass
- * (`Tr2EffectDescription.h`), so a stage type is an index into that array and
- * nothing outside `[0, 5]` addresses anything.
- *
- * @param {number} value Candidate stage type.
- * @returns {number} The validated stage type.
- */
-function requireShaderStageType(value) {
-  if (!Number.isSafeInteger(value) || value < 0 || value >= SHADER_STAGE_COUNT) {
-    throw new RangeError(`Shader stage type must be in [0, ${SHADER_STAGE_COUNT - 1}]`);
-  }
-  return value;
-}
-
-export { SHADER_STAGE_COUNT, requireShaderStageType };
-//# sourceMappingURL=shaderStage.js.map
+/** Number of shader stages Carbon's fixed-width stage array holds. */
+const SHADER_STAGE_COUNT = 6;
+
+/**
+ * Require one of Carbon's six authored shader-stage indices.
+ *
+ * Carbon addresses stages positionally through a fixed-width array on the pass
+ * (`Tr2EffectDescription.h`), so a stage type is an index into that array and
+ * nothing outside `[0, 5]` addresses anything.
+ *
+ * @param {number} value Candidate stage type.
+ * @returns {number} The validated stage type.
+ */
+function requireShaderStageType(value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value >= SHADER_STAGE_COUNT) {
+    throw new RangeError(`Shader stage type must be in [0, ${SHADER_STAGE_COUNT - 1}]`);
+  }
+  return value;
+}
+
+export { SHADER_STAGE_COUNT, requireShaderStageType };
+//# sourceMappingURL=shaderStage.js.map

package/dist/resource/shader/sampler/Tr2SamplerSetup.js

@@ -1,135 +1,135 @@
-import { CjsSchema, impl, type } from '@carbonenginejs/runtime-utils/schema';
-import { CjsModel } from '@carbonenginejs/runtime-utils/model';
-import { isPlainObject } from '@carbonenginejs/runtime-utils/is';
-import { recordText, recordRawBits, toRecordFloat, toRecordText } from '../reflection/carbonRecordFields.js';
-
-// Source: trinity/trinity/Shader/Tr2EffectDescription.h
-
-/** Reflected sampler name and complete device-free sampler descriptor. */
-class Tr2SamplerSetup extends CjsModel {
-  /** name (const char*) */
-  name = "";
-
-  /** Whether the source sampler carried a name rather than authored null. */
-  hasName = false;
-
-  /** sampler (Tr2SamplerStateAL) */
-  sampler = null;
-
-  /** Whether the sampler occupies a dynamic register rather than static signature state. */
-  isDynamic = false;
-
-  /**
-   * Construct a canonical sampler record from JS/JSON model values.
-   *
-   * @param {object} values Canonical model values.
-   * @param {object} options CjsModel import options.
-   * @returns {Tr2SamplerSetup} Hydrated sampler.
-   */
-  static from(values = {}, options = {}) {
-    let normalized = values;
-    if (values && Object.hasOwn(values, "name") && !Object.hasOwn(values, "hasName")) {
-      normalized = {
-        ...values,
-        hasName: values.name !== null,
-        name: values.name === null ? "" : values.name
-      };
-    }
-    return super.from(normalized, options);
-  }
-
-  /**
-   * Build one dynamic sampler from its Carbon v15 description record.
-   *
-   * The name is kept whatever `isDynamic` says. Carbon nulls a non-dynamic
-   * sampler's name while reading (`Tr2EffectDescription.cpp:430-433`), but that
-   * is a runtime decision made on the way to a device — the file still carries
-   * the string, and this graph has to be able to re-emit the file it came from.
-   * Dropping it loses arena content: measured across the shipped corpus, this
-   * single rule accounted for every non-byte-identical re-emission.
-   *
-   * A consumer that wants Carbon's runtime view asks for it: the name is
-   * meaningful only when `isDynamic`.
-   *
-   * @param {object} record Carbon sampler record.
-   * @returns {Tr2SamplerSetup} Reflected sampler.
-   */
-  static fromCarbonBinary(record) {
-    if (!isPlainObject(record)) {
-      throw new TypeError("Carbon effect sampler record must be an object");
-    }
-    const sampler = new this();
-    sampler.isDynamic = !!record.isDynamic;
-    sampler.name = recordText(record.name);
-    sampler.hasName = sampler.name !== "";
-    sampler.sampler = {
-      comparison: !!record.comparison,
-      minFilter: record.minFilter,
-      magFilter: record.magFilter,
-      mipFilter: record.mipFilter,
-      addressU: record.addressU,
-      addressV: record.addressV,
-      addressW: record.addressW,
-      mipLODBiasRaw: recordRawBits(record.mipLODBias),
-      maxAnisotropy: record.maxAnisotropy,
-      comparisonFunc: record.comparisonFunc,
-      borderColorRaw: (record.borderColor ?? []).map(recordRawBits),
-      minLODRaw: recordRawBits(record.minLOD),
-      maxLODRaw: recordRawBits(record.maxLOD)
-    };
-    return sampler;
-  }
-
-  /**
-   * Emit this sampler as a Carbon v15 record.
-   *
-   * The name is written whether or not it is meaningful: Carbon's writer always
-   * emits the field, and the string it emits is the one the compiler authored,
-   * not the one Carbon's reader keeps.
-   *
-   * @param {number} registerIndex Register this sampler is bound at.
-   * @returns {object} Carbon sampler record.
-   */
-  toCarbonBinary(registerIndex) {
-    const descriptor = this.sampler ?? {};
-    return {
-      registerIndex,
-      name: toRecordText(this.name),
-      comparison: descriptor.comparison ? 1 : 0,
-      minFilter: descriptor.minFilter,
-      magFilter: descriptor.magFilter,
-      mipFilter: descriptor.mipFilter,
-      addressU: descriptor.addressU,
-      addressV: descriptor.addressV,
-      addressW: descriptor.addressW,
-      mipLODBias: toRecordFloat(descriptor.mipLODBiasRaw),
-      maxAnisotropy: descriptor.maxAnisotropy,
-      comparisonFunc: descriptor.comparisonFunc,
-      // On one line deliberately: the raw-field guard requires the
-      // reinterpretation to be visible on the same line as the raw access.
-      borderColor: (descriptor.borderColorRaw ?? [0, 0, 0, 0]).slice(0, 4).map(toRecordFloat),
-      minLOD: toRecordFloat(descriptor.minLODRaw),
-      maxLOD: toRecordFloat(descriptor.maxLODRaw),
-      isDynamic: this.isDynamic ? 1 : 0
-    };
-  }
-}
-
-// Declared imperatively rather than with decorators, so this module stays
-// plain ESM that loads from source without a transform. The decorator
-// expressions are reused verbatim, so the registered metadata is identical.
-// Statics belong in `methods`: decorateMethod targets the prototype and
-// would register a static as an instance field.
-CjsSchema.define(Tr2SamplerSetup, {
-  className: "Tr2SamplerSetup",
-  family: "shader",
-  fields: {
-    name: type.string,
-    hasName: [impl.adapted, impl.reason("The schema string field cannot distinguish an authored null sampler name from an empty name; portable reflection must retain that distinction for static sampler records."), type.boolean],
-    sampler: type.rawStruct("Tr2SamplerStateAL"),
-    isDynamic: [impl.adapted, impl.reason("The portable effect contract distinguishes dynamic and static sampler declarations before an engine creates sampler state."), type.boolean]
-  }
-});
-
-export { Tr2SamplerSetup };
-//# sourceMappingURL=Tr2SamplerSetup.js.map
+import { CjsSchema, impl, type } from '@carbonenginejs/runtime-utils/schema';
+import { CjsModel } from '@carbonenginejs/runtime-utils/model';
+import { isPlainObject } from '@carbonenginejs/runtime-utils/is';
+import { recordText, recordRawBits, toRecordFloat, toRecordText } from '../reflection/carbonRecordFields.js';
+
+// Source: trinity/trinity/Shader/Tr2EffectDescription.h
+
+/** Reflected sampler name and complete device-free sampler descriptor. */
+class Tr2SamplerSetup extends CjsModel {
+  /** name (const char*) */
+  name = "";
+
+  /** Whether the source sampler carried a name rather than authored null. */
+  hasName = false;
+
+  /** sampler (Tr2SamplerStateAL) */
+  sampler = null;
+
+  /** Whether the sampler occupies a dynamic register rather than static signature state. */
+  isDynamic = false;
+
+  /**
+   * Construct a canonical sampler record from JS/JSON model values.
+   *
+   * @param {object} values Canonical model values.
+   * @param {object} options CjsModel import options.
+   * @returns {Tr2SamplerSetup} Hydrated sampler.
+   */
+  static from(values = {}, options = {}) {
+    let normalized = values;
+    if (values && Object.hasOwn(values, "name") && !Object.hasOwn(values, "hasName")) {
+      normalized = {
+        ...values,
+        hasName: values.name !== null,
+        name: values.name === null ? "" : values.name
+      };
+    }
+    return super.from(normalized, options);
+  }
+
+  /**
+   * Build one dynamic sampler from its Carbon v15 description record.
+   *
+   * The name is kept whatever `isDynamic` says. Carbon nulls a non-dynamic
+   * sampler's name while reading (`Tr2EffectDescription.cpp:430-433`), but that
+   * is a runtime decision made on the way to a device — the file still carries
+   * the string, and this graph has to be able to re-emit the file it came from.
+   * Dropping it loses arena content: measured across the shipped corpus, this
+   * single rule accounted for every non-byte-identical re-emission.
+   *
+   * A consumer that wants Carbon's runtime view asks for it: the name is
+   * meaningful only when `isDynamic`.
+   *
+   * @param {object} record Carbon sampler record.
+   * @returns {Tr2SamplerSetup} Reflected sampler.
+   */
+  static fromCarbonBinary(record) {
+    if (!isPlainObject(record)) {
+      throw new TypeError("Carbon effect sampler record must be an object");
+    }
+    const sampler = new this();
+    sampler.isDynamic = !!record.isDynamic;
+    sampler.name = recordText(record.name);
+    sampler.hasName = sampler.name !== "";
+    sampler.sampler = {
+      comparison: !!record.comparison,
+      minFilter: record.minFilter,
+      magFilter: record.magFilter,
+      mipFilter: record.mipFilter,
+      addressU: record.addressU,
+      addressV: record.addressV,
+      addressW: record.addressW,
+      mipLODBiasRaw: recordRawBits(record.mipLODBias),
+      maxAnisotropy: record.maxAnisotropy,
+      comparisonFunc: record.comparisonFunc,
+      borderColorRaw: (record.borderColor ?? []).map(recordRawBits),
+      minLODRaw: recordRawBits(record.minLOD),
+      maxLODRaw: recordRawBits(record.maxLOD)
+    };
+    return sampler;
+  }
+
+  /**
+   * Emit this sampler as a Carbon v15 record.
+   *
+   * The name is written whether or not it is meaningful: Carbon's writer always
+   * emits the field, and the string it emits is the one the compiler authored,
+   * not the one Carbon's reader keeps.
+   *
+   * @param {number} registerIndex Register this sampler is bound at.
+   * @returns {object} Carbon sampler record.
+   */
+  toCarbonBinary(registerIndex) {
+    const descriptor = this.sampler ?? {};
+    return {
+      registerIndex,
+      name: toRecordText(this.name),
+      comparison: descriptor.comparison ? 1 : 0,
+      minFilter: descriptor.minFilter,
+      magFilter: descriptor.magFilter,
+      mipFilter: descriptor.mipFilter,
+      addressU: descriptor.addressU,
+      addressV: descriptor.addressV,
+      addressW: descriptor.addressW,
+      mipLODBias: toRecordFloat(descriptor.mipLODBiasRaw),
+      maxAnisotropy: descriptor.maxAnisotropy,
+      comparisonFunc: descriptor.comparisonFunc,
+      // On one line deliberately: the raw-field guard requires the
+      // reinterpretation to be visible on the same line as the raw access.
+      borderColor: (descriptor.borderColorRaw ?? [0, 0, 0, 0]).slice(0, 4).map(toRecordFloat),
+      minLOD: toRecordFloat(descriptor.minLODRaw),
+      maxLOD: toRecordFloat(descriptor.maxLODRaw),
+      isDynamic: this.isDynamic ? 1 : 0
+    };
+  }
+}
+
+// Declared imperatively rather than with decorators, so this module stays
+// plain ESM that loads from source without a transform. The decorator
+// expressions are reused verbatim, so the registered metadata is identical.
+// Statics belong in `methods`: decorateMethod targets the prototype and
+// would register a static as an instance field.
+CjsSchema.define(Tr2SamplerSetup, {
+  className: "Tr2SamplerSetup",
+  family: "shader",
+  fields: {
+    name: type.string,
+    hasName: [impl.adapted, impl.reason("The schema string field cannot distinguish an authored null sampler name from an empty name; portable reflection must retain that distinction for static sampler records."), type.boolean],
+    sampler: type.rawStruct("Tr2SamplerStateAL"),
+    isDynamic: [impl.adapted, impl.reason("The portable effect contract distinguishes dynamic and static sampler declarations before an engine creates sampler state."), type.boolean]
+  }
+});
+
+export { Tr2SamplerSetup };
+//# sourceMappingURL=Tr2SamplerSetup.js.map