@photivra/engine 2.21.0 → 2.22.0

package/dist/gpu/image-kernel-execution.js.map

@@ -1 +1 @@
-{"version":3,"file":"image-kernel-execution.js","sourceRoot":"","sources":["../../src/gpu/image-kernel-execution.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Execution-backend labels, error bounds and domain errors for the optional image-kernel accelerator.\n *\n * `cpu-reference` is the float64 engine reference and the default. `webgpu-f32` is a separate float32\n * approximation backend. Every one of its results carries a forward-error bound worked out in advance\n * from:\n * - IEEE 754 binary32 rounding (unit roundoff u = 2^-24; γ_k = k·u/(1 − k·u), the classical factor\n *   in error bounds for floating-point sums and inner products: Rump & Jeannerod, SIAM J. Matrix\n *   Anal. Appl. 35(2), 2014, sec. 1, free author copy. Also see: Higham, Accuracy and Stability of\n *   Numerical Algorithms, 2nd ed., SIAM 2002, §2–§3);\n * - the WGSL built-in accuracy table (W3C WebGPU Shading Language, §\"Floating Point Accuracy\").\n * See docs/WEBGPU.md.\n */\n\nimport { requireInputObject } from \"../core/record-validation.js\";\nimport { InvalidScientificInputError } from \"../core/validation.js\";\n\n/** Requested or actual execution backend. */\nexport type ImageKernelBackend = \"cpu-reference\" | \"webgpu-f32\";\n\n/** Why a requested WebGPU backend was not used (only with `fallback: \"cpu-reference\"`). */\n/** Why a requested `webgpu-f32` backend ran the CPU reference instead. `webgpu-disabled`: `setWebGpuEnabled(false)` in this realm. */\nexport type ImageKernelFallbackReason = \"webgpu-unavailable\" | \"webgpu-disabled\" | \"adapter-unavailable\" | \"device-request-failed\" |\n  \"insufficient-limits\" | \"unsupported-platform-endianness\";\n\n/**\n * Failure classes reported by {@link ImageKernelExecutionError}. `conformance-failed` (#481): a device failed the display view's\n * run-time self-check with `gpu: \"require\"`.\n */\nexport type ImageKernelFailureReason = ImageKernelFallbackReason | \"device-lost\" | \"out-of-memory\" | \"gpu-validation\" |\n  \"aborted\" | \"disposed\" | \"busy\" | \"unsupported-on-backend\" | \"unsupported-float32-domain\" | \"indeterminate-float32-classification\" | \"conformance-failed\";\n\n/** Domain error for getting and running a backend. Input validation still throws the engine's existing errors. */\nexport class ImageKernelExecutionError extends Error {\n  readonly code = \"IMAGE_KERNEL_EXECUTION\";\n  readonly reason: ImageKernelFailureReason;\n\n  constructor(reason: ImageKernelFailureReason, message: string) {\n    super(message);\n    this.name = \"ImageKernelExecutionError\";\n    this.reason = reason;\n  }\n}\n\n/** Integer output codes: |code_webgpu − code_reference| ≤ maximumAbsoluteCodeDifference for every sample. */\nexport interface ImageKernelCodeErrorBound {\n  kind: \"integer-code-difference\";\n  maximumAbsoluteCodeDifference: number;\n  /** Bound on the float32 linear value entering the sRGB transfer, after tone and gamut handling. */\n  linearAbsoluteBound: number;\n  /** Declared bound on the WGSL sRGB transfer evaluation (pow), see WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND. */\n  transferAbsoluteBound: number;\n}\n\n/** Non-negative linear sums: |v_webgpu − v_reference| ≤ relative·v_reference + absolute for every sample. */\nexport interface ImageKernelRelativeErrorBound {\n  kind: \"relative-to-reference\";\n  relative: number;\n  absolute: number;\n}\n\n/**\n * Seeded stochastic stages (the sensor stage). Random states are integer arithmetic and bit-identical to\n * the reference. A site is flagged when any float32 decision (sampling test, saturation limit, rounding)\n * fell inside its a-priori bound. Every unflagged site has exactly the reference code and flags; only\n * flagged sites may differ, and the statistical-equivalence tests cover them (docs/WEBGPU.md).\n */\nexport interface ImageKernelSeededRealizationBound {\n  kind: \"exact-except-flagged-sites\";\n  /** Number of flagged sites; equal to the execution's `diagnosticUncertaintySampleCount`. */\n  flaggedSiteCount: number;\n  noiseModel: { id: string; version: string };\n  seedSchedule: string;\n}\n\n/**\n * #481: the WebGPU adapter a device came from, as `GPUAdapter.info` describes it (W3C WebGPU, `GPUAdapterInfo`): each field\n * is the browser's string, or empty when the browser withholds it. Diagnostic only; it never changes a result.\n */\nexport interface ImageKernelAdapterDescription {\n  vendor: string;\n  architecture: string;\n  device: string;\n  description: string;\n}\n\n/**\n * A component of the composite chart kernel's double-float32 probe (see {@link ChartCompositeProbeRecord}). The first four are the\n * outputs of the probe before 2.11.0: `two-sum` is TwoSum's low part (`s.l`), `two-product` Dekker's TwoProduct low part (`m.l`),\n * `double-word-add` the double-word sum's low part (`a.l`), `double-word-multiply` the Dekker double-word product (`q.h`, `q.l`).\n */\nexport type ChartCompositeProbeComponent = \"two-sum\" | \"two-product\" | \"double-word-add\" | \"double-word-multiply\" | \"fma-two-product\" | \"fma-double-word-multiply\";\n\n/** One probe output that differs from its expected value: the component, the probe input's index, and the float32 bits (hex). */\nexport interface ChartCompositeProbeMismatch {\n  component: ChartCompositeProbeComponent;\n  input: number;\n  got: string;\n  want: string;\n}\n\n/**\n * The composite chart kernel's device probe (docs/WEBGPU.md, \"Scene radiance on the GPU\"): how the device evaluated the kernel's\n * double-float32 building blocks, and which product path the kernel was compiled with. Diagnostic; it never changes a result.\n *\n * - `deviceClass`: `exact` (the written order, round to nearest); `contracted` (only the Dekker product paths differ, consistent\n *   with a multiply and an add fused into one rounding); `reassociated` (a sum path differs and every differing sum low part is\n *   zero, the value an algebraic simplification of (a + b) − a to b gives); `other` (anything else, such as a sum path that differs\n *   with non-zero low parts, as a rounding not to nearest gives, or a non-finite output).\n * - `productPath`: `dekker` when the Dekker path passes, else `fma` when the fma path passes (which needs a fused `fma`), else null\n *   (the device is refused for composite charts, the 2.3 elements and material-layers scenes).\n * - `fmaFused`: whether every fma TwoProduct low part was exact (a fused `fma`; WGSL also allows an unfused one).\n */\nexport interface ChartCompositeProbeRecord {\n  deviceClass: \"exact\" | \"contracted\" | \"reassociated\" | \"other\";\n  productPath: \"dekker\" | \"fma\" | null;\n  fmaFused: boolean;\n  /** Probe inputs, each checked on every component. */\n  inputs: number;\n  /** Differing outputs per component. */\n  mismatchCounts: Readonly<Record<ChartCompositeProbeComponent, number>>;\n  /** The indices of the probe inputs (`PROBE_INPUTS`) whose output differs, per component. */\n  mismatchedInputs: Readonly<Record<ChartCompositeProbeComponent, readonly number[]>>;\n  /** The first differing outputs (at most eight), in component order. */\n  mismatches: readonly ChartCompositeProbeMismatch[];\n}\n\n/** Label attached to every accelerated result. */\nexport interface ImageKernelExecution {\n  backend: ImageKernelBackend;\n  requestedBackend: ImageKernelBackend;\n  fallbackReason: ImageKernelFallbackReason | null;\n  arithmetic: \"float64\" | \"float32\";\n  assurance: \"engine-reference\" | \"approximation-with-a-priori-bound\";\n  /**\n   * The exact-or-fast flag in the facade's words (#395): false for `cpu-reference` (the engine reference), true for\n   * `webgpu-f32` (a bounded approximation). `backend` still names where the work ran.\n   */\n  fast: boolean;\n  /**\n   * True only for `cpu-reference`. Bit-exact identities (SHA-256 artifact bindings, byte-parity fixtures,\n   * cross-engine determinism hashes) are CPU-only and must never be computed from a `webgpu-f32` result.\n   */\n  bitIdenticalToReference: boolean;\n  errorBound: ImageKernelCodeErrorBound | ImageKernelRelativeErrorBound | ImageKernelSeededRealizationBound | null;\n  /**\n   * Diagnostic counts equal the reference when no sample fell inside a float32 classification band\n   * (`diagnosticUncertaintySampleCount === 0`). Otherwise each count differs by at most that many\n   * samples.\n   */\n  diagnosticsExact: boolean;\n  diagnosticUncertaintySampleCount: number;\n  limitations: readonly string[];\n}\n\n/** IEEE 754 binary32 unit roundoff. */\nexport const WEBGPU_F32_UNIT_ROUNDOFF = 2 ** -24;\n/**\n * Declared absolute error bound for the WGSL sRGB encode on [0, 1]: `1.055·pow(x, 1/2.4) − 0.055`. pow\n * takes its accuracy from exp2(y·log2 x) (log2: 3 ULP, or 2^-21 absolute on [0.5, 2]; exp2: 3 + 2|x|\n * ULP). The worst case over [0.0031308, 1] is about 2.5e-6. The bound 2^-17 ≈ 7.6e-6 keeps a 3× margin,\n * and also covers the small jump where the sRGB segments join (< 1e-7).\n */\nexport const WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND = 2 ** -17;\n/** Largest slope of the sRGB encode on [0, 1] (the linear segment, 12.92). */\nexport const SRGB_ENCODE_LIPSCHITZ = 12.92;\n\n/** Higham's γ_k for binary32. */\nexport function float32Gamma(k: number): number {\n  const ku = k * WEBGPU_F32_UNIT_ROUNDOFF;\n  return ku < 1 ? ku / (1 - ku) : Number.POSITIVE_INFINITY;\n}\n\n/** Integer-code bound from a bound on the linear value: |Δcode| ≤ ⌊maximum·(12.92·δ_L + δ_E)⌋ + 1, capped at maximum. */\nexport function integerCodeBound(maximum: number, linearAbsoluteBound: number): ImageKernelCodeErrorBound {\n  const linear = Math.min(1, linearAbsoluteBound);\n  const real = maximum * (SRGB_ENCODE_LIPSCHITZ * linear + WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND);\n  return { kind: \"integer-code-difference\", maximumAbsoluteCodeDifference: Math.min(maximum, Math.floor(real) + 1),\n    linearAbsoluteBound: linear, transferAbsoluteBound: WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND };\n}\n\n/**\n * Composes two `relative-to-reference` bounds through a pipeline `second ∘ first`, where the second\n * stage is linear with non-negative weights summing to at most `secondWeightSum` per output (convolution,\n * temporal sums). With |ã − a| ≤ r₁a + a₁ elementwise and |B̃x − Bx| ≤ r₂Bx + a₂:\n * |B̃ã − Ba| ≤ |B̃ã − Bã| + |B(ã − a)| ≤ r₂(1 + r₁)Ba + r₂W·a₁ + a₂ + r₁Ba + W·a₁,\n * so r = r₁ + r₂ + r₁r₂ and a = a₂ + W·a₁·(1 + r₂). See docs/WEBGPU.md, \"Accuracy contract\".\n */\nexport function composeRelativeErrorBounds(first: ImageKernelRelativeErrorBound, second: ImageKernelRelativeErrorBound,\n  secondWeightSum: number): ImageKernelRelativeErrorBound {\n  requireInputObject(first, \"composeRelativeErrorBounds first bound\");\n  requireInputObject(second, \"composeRelativeErrorBounds second bound\");\n  for (const v of [first.relative, first.absolute, second.relative, second.absolute, secondWeightSum]) {\n    if (!(typeof v === \"number\" && v >= 0 && v <= Number.MAX_VALUE)) {\n      throw new InvalidScientificInputError(\"Error bounds and weight sums must be finite and non-negative.\");\n    }\n  }\n  return { kind: \"relative-to-reference\", relative: first.relative + second.relative + first.relative * second.relative,\n    absolute: second.absolute + secondWeightSum * first.absolute * (1 + second.relative) };\n}\n\nexport const CPU_REFERENCE_LIMITATIONS = /* @__PURE__ */ Object.freeze([\"Float64 engine reference execution; results are the reference by definition\"]);\nexport const WEBGPU_F32_LIMITATIONS = /* @__PURE__ */ Object.freeze([\n  \"Float32 WebGPU execution is an approximation of the float64 reference within the reported a-priori bound\",\n  \"Not bit-identical to the reference: never use for SHA-256 artifact identities, byte-parity evidence or determinism hashes\",\n  \"Bound assumes a conforming WebGPU implementation (correctly rounded f32 add/multiply/divide, WGSL accuracy table)\",\n  \"Execution speed depends on the adapter; software adapters do not represent GPU performance\"\n]);\n\nexport function cpuExecution(requestedBackend: ImageKernelBackend, fallbackReason: ImageKernelFallbackReason | null): ImageKernelExecution {\n  return { backend: \"cpu-reference\", requestedBackend, fallbackReason, arithmetic: \"float64\", assurance: \"engine-reference\", fast: false,\n    bitIdenticalToReference: true, errorBound: null, diagnosticsExact: true, diagnosticUncertaintySampleCount: 0, limitations: CPU_REFERENCE_LIMITATIONS };\n}\n\nexport function webGpuExecution(errorBound: ImageKernelExecution[\"errorBound\"], uncertainty: number): ImageKernelExecution {\n  return { backend: \"webgpu-f32\", requestedBackend: \"webgpu-f32\", fallbackReason: null, arithmetic: \"float32\",\n    assurance: \"approximation-with-a-priori-bound\", fast: true, bitIdenticalToReference: false, errorBound, diagnosticsExact: uncertainty === 0,\n    diagnosticUncertaintySampleCount: uncertainty, limitations: WEBGPU_F32_LIMITATIONS };\n}\n"]}
+{"version":3,"file":"image-kernel-execution.js","sourceRoot":"","sources":["../../src/gpu/image-kernel-execution.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Execution-backend labels, error bounds and domain errors for the optional image-kernel accelerator.\n *\n * `cpu-reference` is the float64 engine reference and the default. `webgpu-f32` is a separate float32\n * approximation backend. Every one of its results carries a forward-error bound worked out in advance\n * from:\n * - IEEE 754 binary32 rounding (unit roundoff u = 2^-24; γ_k = k·u/(1 − k·u), the classical factor\n *   in error bounds for floating-point sums and inner products: Rump & Jeannerod, SIAM J. Matrix\n *   Anal. Appl. 35(2), 2014, sec. 1, free author copy. Also see: Higham, Accuracy and Stability of\n *   Numerical Algorithms, 2nd ed., SIAM 2002, §2–§3);\n * - the WGSL built-in accuracy table (W3C WebGPU Shading Language, §\"Floating Point Accuracy\").\n * See docs/WEBGPU.md.\n */\n\nimport { requireInputObject } from \"../core/record-validation.js\";\nimport { InvalidScientificInputError } from \"../core/validation.js\";\n\n/** Requested or actual execution backend. */\nexport type ImageKernelBackend = \"cpu-reference\" | \"webgpu-f32\";\n\n/** Why a requested WebGPU backend was not used (only with `fallback: \"cpu-reference\"`). */\nexport { ImageKernelExecutionError, type ImageKernelFailureReason, type ImageKernelFallbackReason } from \"../core/execution-error.js\";\nimport type { ImageKernelFallbackReason } from \"../core/execution-error.js\";\n\n/** Integer output codes: |code_webgpu − code_reference| ≤ maximumAbsoluteCodeDifference for every sample. */\nexport interface ImageKernelCodeErrorBound {\n  kind: \"integer-code-difference\";\n  maximumAbsoluteCodeDifference: number;\n  /** Bound on the float32 linear value entering the sRGB transfer, after tone and gamut handling. */\n  linearAbsoluteBound: number;\n  /** Declared bound on the WGSL sRGB transfer evaluation (pow), see WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND. */\n  transferAbsoluteBound: number;\n}\n\n/** Non-negative linear sums: |v_webgpu − v_reference| ≤ relative·v_reference + absolute for every sample. */\nexport interface ImageKernelRelativeErrorBound {\n  kind: \"relative-to-reference\";\n  relative: number;\n  absolute: number;\n}\n\n/**\n * Seeded stochastic stages (the sensor stage). Random states are integer arithmetic and bit-identical to\n * the reference. A site is flagged when any float32 decision (sampling test, saturation limit, rounding)\n * fell inside its a-priori bound. Every unflagged site has exactly the reference code and flags; only\n * flagged sites may differ, and the statistical-equivalence tests cover them (docs/WEBGPU.md).\n */\nexport interface ImageKernelSeededRealizationBound {\n  kind: \"exact-except-flagged-sites\";\n  /** Number of flagged sites; equal to the execution's `diagnosticUncertaintySampleCount`. */\n  flaggedSiteCount: number;\n  noiseModel: { id: string; version: string };\n  seedSchedule: string;\n}\n\n/**\n * #481: the WebGPU adapter a device came from, as `GPUAdapter.info` describes it (W3C WebGPU, `GPUAdapterInfo`): each field\n * is the browser's string, or empty when the browser withholds it. Diagnostic only; it never changes a result.\n */\nexport interface ImageKernelAdapterDescription {\n  vendor: string;\n  architecture: string;\n  device: string;\n  description: string;\n}\n\n/**\n * A component of the composite chart kernel's double-float32 probe (see {@link ChartCompositeProbeRecord}). The first four are the\n * outputs of the probe before 2.11.0: `two-sum` is TwoSum's low part (`s.l`), `two-product` Dekker's TwoProduct low part (`m.l`),\n * `double-word-add` the double-word sum's low part (`a.l`), `double-word-multiply` the Dekker double-word product (`q.h`, `q.l`).\n */\nexport type ChartCompositeProbeComponent = \"two-sum\" | \"two-product\" | \"double-word-add\" | \"double-word-multiply\" | \"fma-two-product\" | \"fma-double-word-multiply\";\n\n/** One probe output that differs from its expected value: the component, the probe input's index, and the float32 bits (hex). */\nexport interface ChartCompositeProbeMismatch {\n  component: ChartCompositeProbeComponent;\n  input: number;\n  got: string;\n  want: string;\n}\n\n/**\n * The composite chart kernel's device probe (docs/WEBGPU.md, \"Scene radiance on the GPU\"): how the device evaluated the kernel's\n * double-float32 building blocks, and which product path the kernel was compiled with. Diagnostic; it never changes a result.\n *\n * - `deviceClass`: `exact` (the written order, round to nearest); `contracted` (only the Dekker product paths differ, consistent\n *   with a multiply and an add fused into one rounding); `reassociated` (a sum path differs and every differing sum low part is\n *   zero, the value an algebraic simplification of (a + b) − a to b gives); `other` (anything else, such as a sum path that differs\n *   with non-zero low parts, as a rounding not to nearest gives, or a non-finite output).\n * - `productPath`: `dekker` when the Dekker path passes, else `fma` when the fma path passes (which needs a fused `fma`), else null\n *   (the device is refused for composite charts, the 2.3 elements and material-layers scenes).\n * - `fmaFused`: whether every fma TwoProduct low part was exact (a fused `fma`; WGSL also allows an unfused one).\n */\nexport interface ChartCompositeProbeRecord {\n  deviceClass: \"exact\" | \"contracted\" | \"reassociated\" | \"other\";\n  productPath: \"dekker\" | \"fma\" | null;\n  fmaFused: boolean;\n  /** Probe inputs, each checked on every component. */\n  inputs: number;\n  /** Differing outputs per component. */\n  mismatchCounts: Readonly<Record<ChartCompositeProbeComponent, number>>;\n  /** The indices of the probe inputs (`PROBE_INPUTS`) whose output differs, per component. */\n  mismatchedInputs: Readonly<Record<ChartCompositeProbeComponent, readonly number[]>>;\n  /** The first differing outputs (at most eight), in component order. */\n  mismatches: readonly ChartCompositeProbeMismatch[];\n}\n\n/** Label attached to every accelerated result. */\nexport interface ImageKernelExecution {\n  backend: ImageKernelBackend;\n  requestedBackend: ImageKernelBackend;\n  fallbackReason: ImageKernelFallbackReason | null;\n  arithmetic: \"float64\" | \"float32\";\n  assurance: \"engine-reference\" | \"approximation-with-a-priori-bound\";\n  /**\n   * The exact-or-fast flag in the facade's words (#395): false for `cpu-reference` (the engine reference), true for\n   * `webgpu-f32` (a bounded approximation). `backend` still names where the work ran.\n   */\n  fast: boolean;\n  /**\n   * True only for `cpu-reference`. Bit-exact identities (SHA-256 artifact bindings, byte-parity fixtures,\n   * cross-engine determinism hashes) are CPU-only and must never be computed from a `webgpu-f32` result.\n   */\n  bitIdenticalToReference: boolean;\n  errorBound: ImageKernelCodeErrorBound | ImageKernelRelativeErrorBound | ImageKernelSeededRealizationBound | null;\n  /**\n   * Diagnostic counts equal the reference when no sample fell inside a float32 classification band\n   * (`diagnosticUncertaintySampleCount === 0`). Otherwise each count differs by at most that many\n   * samples.\n   */\n  diagnosticsExact: boolean;\n  diagnosticUncertaintySampleCount: number;\n  limitations: readonly string[];\n}\n\n/** IEEE 754 binary32 unit roundoff. */\nexport const WEBGPU_F32_UNIT_ROUNDOFF = 2 ** -24;\n/**\n * Declared absolute error bound for the WGSL sRGB encode on [0, 1]: `1.055·pow(x, 1/2.4) − 0.055`. pow\n * takes its accuracy from exp2(y·log2 x) (log2: 3 ULP, or 2^-21 absolute on [0.5, 2]; exp2: 3 + 2|x|\n * ULP). The worst case over [0.0031308, 1] is about 2.5e-6. The bound 2^-17 ≈ 7.6e-6 keeps a 3× margin,\n * and also covers the small jump where the sRGB segments join (< 1e-7).\n */\nexport const WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND = 2 ** -17;\n/** Largest slope of the sRGB encode on [0, 1] (the linear segment, 12.92). */\nexport const SRGB_ENCODE_LIPSCHITZ = 12.92;\n\n/** Higham's γ_k for binary32. */\nexport function float32Gamma(k: number): number {\n  const ku = k * WEBGPU_F32_UNIT_ROUNDOFF;\n  return ku < 1 ? ku / (1 - ku) : Number.POSITIVE_INFINITY;\n}\n\n/** Integer-code bound from a bound on the linear value: |Δcode| ≤ ⌊maximum·(12.92·δ_L + δ_E)⌋ + 1, capped at maximum. */\nexport function integerCodeBound(maximum: number, linearAbsoluteBound: number): ImageKernelCodeErrorBound {\n  const linear = Math.min(1, linearAbsoluteBound);\n  const real = maximum * (SRGB_ENCODE_LIPSCHITZ * linear + WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND);\n  return { kind: \"integer-code-difference\", maximumAbsoluteCodeDifference: Math.min(maximum, Math.floor(real) + 1),\n    linearAbsoluteBound: linear, transferAbsoluteBound: WEBGPU_F32_TRANSFER_ABSOLUTE_BOUND };\n}\n\n/**\n * Composes two `relative-to-reference` bounds through a pipeline `second ∘ first`, where the second\n * stage is linear with non-negative weights summing to at most `secondWeightSum` per output (convolution,\n * temporal sums). With |ã − a| ≤ r₁a + a₁ elementwise and |B̃x − Bx| ≤ r₂Bx + a₂:\n * |B̃ã − Ba| ≤ |B̃ã − Bã| + |B(ã − a)| ≤ r₂(1 + r₁)Ba + r₂W·a₁ + a₂ + r₁Ba + W·a₁,\n * so r = r₁ + r₂ + r₁r₂ and a = a₂ + W·a₁·(1 + r₂). See docs/WEBGPU.md, \"Accuracy contract\".\n */\nexport function composeRelativeErrorBounds(first: ImageKernelRelativeErrorBound, second: ImageKernelRelativeErrorBound,\n  secondWeightSum: number): ImageKernelRelativeErrorBound {\n  requireInputObject(first, \"composeRelativeErrorBounds first bound\");\n  requireInputObject(second, \"composeRelativeErrorBounds second bound\");\n  for (const v of [first.relative, first.absolute, second.relative, second.absolute, secondWeightSum]) {\n    if (!(typeof v === \"number\" && v >= 0 && v <= Number.MAX_VALUE)) {\n      throw new InvalidScientificInputError(\"Error bounds and weight sums must be finite and non-negative.\");\n    }\n  }\n  return { kind: \"relative-to-reference\", relative: first.relative + second.relative + first.relative * second.relative,\n    absolute: second.absolute + secondWeightSum * first.absolute * (1 + second.relative) };\n}\n\nexport const CPU_REFERENCE_LIMITATIONS = /* @__PURE__ */ Object.freeze([\"Float64 engine reference execution; results are the reference by definition\"]);\nexport const WEBGPU_F32_LIMITATIONS = /* @__PURE__ */ Object.freeze([\n  \"Float32 WebGPU execution is an approximation of the float64 reference within the reported a-priori bound\",\n  \"Not bit-identical to the reference: never use for SHA-256 artifact identities, byte-parity evidence or determinism hashes\",\n  \"Bound assumes a conforming WebGPU implementation (correctly rounded f32 add/multiply/divide, WGSL accuracy table)\",\n  \"Execution speed depends on the adapter; software adapters do not represent GPU performance\"\n]);\n\nexport function cpuExecution(requestedBackend: ImageKernelBackend, fallbackReason: ImageKernelFallbackReason | null): ImageKernelExecution {\n  return { backend: \"cpu-reference\", requestedBackend, fallbackReason, arithmetic: \"float64\", assurance: \"engine-reference\", fast: false,\n    bitIdenticalToReference: true, errorBound: null, diagnosticsExact: true, diagnosticUncertaintySampleCount: 0, limitations: CPU_REFERENCE_LIMITATIONS };\n}\n\nexport function webGpuExecution(errorBound: ImageKernelExecution[\"errorBound\"], uncertainty: number): ImageKernelExecution {\n  return { backend: \"webgpu-f32\", requestedBackend: \"webgpu-f32\", fallbackReason: null, arithmetic: \"float32\",\n    assurance: \"approximation-with-a-priori-bound\", fast: true, bitIdenticalToReference: false, errorBound, diagnosticsExact: uncertainty === 0,\n    diagnosticUncertaintySampleCount: uncertainty, limitations: WEBGPU_F32_LIMITATIONS };\n}\n"]}

package/dist/gpu/wgsl-display-view-coupled-stub.d.ts

@@ -0,0 +1,8 @@
+/**
+ * #593, #601: the default form of the display view's coupled GPU steps (no coupled step), statically part of the kernels; the
+ * coupled steps themselves (`wgsl-display-view-coupled.ts`) are loaded on demand, only for a view that asks for them.
+ */
+/** The functions' shared declarations (both forms). */
+export declare const DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL = "\nstruct CpOut { hm: vec3<f32>, hv: vec3<f32>, a0: vec3<f32>, a1: vec3<f32>, a2: vec3<f32>, bm: vec3<f32>, bv: vec3<f32>, ju: f32, flag: bool, top: bool };\nfn cp_on() -> bool { return cp_k(0u) != 0.0; }\n";
+/** The default form: no coupled step (the buffer holds one zero word). */
+export declare const DISPLAY_VIEW_COUPLED_STUB_WGSL = "\nstruct CpOut { hm: vec3<f32>, hv: vec3<f32>, a0: vec3<f32>, a1: vec3<f32>, a2: vec3<f32>, bm: vec3<f32>, bv: vec3<f32>, ju: f32, flag: bool, top: bool };\nfn cp_on() -> bool { return cp_k(0u) != 0.0; }\n\nfn cp_zero() -> CpOut { var t: CpOut; return t; }\nfn cp_luminance() -> bool { return false; }\nfn cp_reconstruct() -> bool { return false; }\nfn cp_desaturate() -> bool { return false; }\nfn cp_reconstruct_reach(cm: vec3<f32>, cv: vec3<f32>) -> u32 { return 0u; }\nfn cp_tone(mu: vec3<f32>, s0: vec3<f32>, s1: vec3<f32>, s2: vec3<f32>, dmu: vec3<f32>, dsv: vec3<f32>) -> CpOut { return cp_zero(); }\nfn cp_chain(cm: vec3<f32>, c00: f32, c01: f32, c02: f32, c11: f32, c12: f32, c22: f32, dcm: vec3<f32>, dcv: vec3<f32>) -> CpOut { return cp_zero(); }\n";

package/dist/gpu/wgsl-display-view-coupled-stub.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * #593, #601: the default form of the display view's coupled GPU steps (no coupled step), statically part of the kernels; the
+ * coupled steps themselves (`wgsl-display-view-coupled.ts`) are loaded on demand, only for a view that asks for them.
+ */
+/** The functions' shared declarations (both forms). */
+export const DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL = /* wgsl */ `
+struct CpOut { hm: vec3<f32>, hv: vec3<f32>, a0: vec3<f32>, a1: vec3<f32>, a2: vec3<f32>, bm: vec3<f32>, bv: vec3<f32>, ju: f32, flag: bool, top: bool };
+fn cp_on() -> bool { return cp_k(0u) != 0.0; }
+`;
+/** The default form: no coupled step (the buffer holds one zero word). */
+export const DISPLAY_VIEW_COUPLED_STUB_WGSL = /* wgsl */ `${DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL}
+fn cp_zero() -> CpOut { var t: CpOut; return t; }
+fn cp_luminance() -> bool { return false; }
+fn cp_reconstruct() -> bool { return false; }
+fn cp_desaturate() -> bool { return false; }
+fn cp_reconstruct_reach(cm: vec3<f32>, cv: vec3<f32>) -> u32 { return 0u; }
+fn cp_tone(mu: vec3<f32>, s0: vec3<f32>, s1: vec3<f32>, s2: vec3<f32>, dmu: vec3<f32>, dsv: vec3<f32>) -> CpOut { return cp_zero(); }
+fn cp_chain(cm: vec3<f32>, c00: f32, c01: f32, c02: f32, c11: f32, c12: f32, c22: f32, dcm: vec3<f32>, dcv: vec3<f32>) -> CpOut { return cp_zero(); }
+`;
+//# sourceMappingURL=wgsl-display-view-coupled-stub.js.map

package/dist/gpu/wgsl-display-view-coupled-stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgsl-display-view-coupled-stub.js","sourceRoot":"","sources":["../../src/gpu/wgsl-display-view-coupled-stub.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;GAGG;AAEH,uDAAuD;AACvD,MAAM,CAAC,MAAM,sCAAsC,GAAG,UAAU,CAAC;;;CAGhE,CAAC;AAEF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC,GAAG,sCAAsC;;;;;;;;CAQjG,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * #593, #601: the default form of the display view's coupled GPU steps (no coupled step), statically part of the kernels; the\n * coupled steps themselves (`wgsl-display-view-coupled.ts`) are loaded on demand, only for a view that asks for them.\n */\n\n/** The functions' shared declarations (both forms). */\nexport const DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL = /* wgsl */ `\nstruct CpOut { hm: vec3<f32>, hv: vec3<f32>, a0: vec3<f32>, a1: vec3<f32>, a2: vec3<f32>, bm: vec3<f32>, bv: vec3<f32>, ju: f32, flag: bool, top: bool };\nfn cp_on() -> bool { return cp_k(0u) != 0.0; }\n`;\n\n/** The default form: no coupled step (the buffer holds one zero word). */\nexport const DISPLAY_VIEW_COUPLED_STUB_WGSL = /* wgsl */ `${DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL}\nfn cp_zero() -> CpOut { var t: CpOut; return t; }\nfn cp_luminance() -> bool { return false; }\nfn cp_reconstruct() -> bool { return false; }\nfn cp_desaturate() -> bool { return false; }\nfn cp_reconstruct_reach(cm: vec3<f32>, cv: vec3<f32>) -> u32 { return 0u; }\nfn cp_tone(mu: vec3<f32>, s0: vec3<f32>, s1: vec3<f32>, s2: vec3<f32>, dmu: vec3<f32>, dsv: vec3<f32>) -> CpOut { return cp_zero(); }\nfn cp_chain(cm: vec3<f32>, c00: f32, c01: f32, c02: f32, c11: f32, c12: f32, c22: f32, dcm: vec3<f32>, dcv: vec3<f32>) -> CpOut { return cp_zero(); }\n`;\n\n"]}

package/dist/gpu/wgsl-display-view-coupled.d.ts

@@ -0,0 +1,88 @@
+/**
+ * #593, #601 (2.22.0): the display view's coupled rendering steps on the GPU, shared by the Speed kernel and the Quality pixel
+ * pass: the luminance tone curves by conditioning on luminance (`cp_tone`), and `highlightMode: "reconstruct"` and the
+ * desaturation by the 3-D Gauss–Hermite rule over the development chain (`cp_chain`), the float32 forms of
+ * src/facade/display-view-rendering.ts with the request's fast or full rule. On demand: a kernel takes this text only for a view
+ * that asks for the coupled steps (its pipeline label ends in `+coupled`); every other view takes `DISPLAY_VIEW_COUPLED_STUB_WGSL`.
+ *
+ * Constants come from the kernel's aux table after its own entries (`cp_k(i)`, which each kernel defines), laid out as
+ * `DISPLAY_VIEW_COUPLED` (the host's `displayViewCoupledConstants`). The kernels define `phi` and `pq` (Abramowitz–Stegun) and
+ * `CLIP_REACH`; nothing else is shared.
+ *
+ * Error bounds (first order, float32, E = 2^-23; docs/WEBGPU.md, "Coupled rendering steps"). Every function returns, besides
+ * its moments, absolute bounds of the mean and the variance against the float64 reference and the slopes' relative bound:
+ * - tone: per node the clipped-normal terms (`CLIP_MEAN_U`·r·σ, `CLIP_VARIANCE_U`·r²·σ²), the conditional variance's
+ *   cancellation (0.8·r·√(32·E·Σ_kk)), the node position through the slope and the ratio's relative error (log2 and exp2 per the
+ *   WGSL accuracy table, the image-kernel accelerator's tone analysis); then one E per node of the sums;
+ * - chain: per node the rounding of the developed pixel (white balance and blend 8E of the largest channel, matrix 3E per term,
+ *   tone ratio η, desaturation 8E) carried to the output through the node's own slopes, plus the node point's rounding through
+ *   the slopes; then one E per node of the sums. The chain is continuous (clip, blend, maximum and desaturation all are), so a
+ *   branch taken differently on either side of a kink moves the output by at most the slope times the input's error;
+ * - inputs: the caller's bounds of the means through |slopes|, of the variances through 0.8·|slopes|·√δ.
+ * A decision the reference takes on a threshold (the blend's reach, a component reaching 1 with the desaturation, the fast
+ * rule's range, a node at L = 0 where the ratio jumps) that the float32 values cannot settle sets the pixel's recompute flag:
+ * the host renders that display pixel with the reference.
+ */
+/** Layout of the coupled-constants buffer (float32 words). */
+export declare const DISPLAY_VIEW_COUPLED: Readonly<{
+    on: 0;
+    luminance: 1;
+    tone: 2;
+    a: 3;
+    n: 4;
+    inverseWhite: 5;
+    ratioAtZero: 6;
+    weights: 7;
+    reconstruct: 10;
+    desaturate: 11;
+    fast: 12;
+    gains: 13;
+    clipLevel: 16;
+    matrix: 17;
+    chainPoints: 26;
+    chainX: 27;
+    chainW: 43;
+    hermiteX: 59;
+    hermiteW: 67;
+    legendreX: 75;
+    legendreW: 91;
+    size: 107;
+}>;
+/** The largest finite float32 stands for r(0+) = ∞ (Naka–Rushton below exponent 1). */
+export declare const DISPLAY_VIEW_COUPLED_INFINITE_RATIO = 3.4028234663852886e+38;
+/** The coupled steps (see the module comment). */
+export declare const DISPLAY_VIEW_COUPLED_WGSL: string;
+/** The host's coupled-constants buffer of a view (`DISPLAY_VIEW_COUPLED` layout), or the one-word stub buffer. */
+export declare function displayViewCoupledConstants(setup: {
+    gains: readonly number[];
+    clipLevel: number;
+    matrix: readonly (readonly number[])[];
+    rendering?: {
+        toneCurve: string;
+        toneCurveParameters?: {
+            whiteLuminance: number;
+        } | {
+            exponent: number;
+            semiSaturation: number;
+            whiteLuminance: number;
+        };
+        highlightMode: string;
+        gamutHandling: string;
+        fast: boolean;
+    };
+    coupled?: {
+        chainRule: {
+            x: Float64Array;
+            w: Float64Array;
+        };
+        luminanceRule: {
+            x: Float64Array;
+            w: Float64Array;
+        };
+        ratioAtZero: number;
+        luminanceTone: boolean;
+    };
+}, weights: readonly number[], legendre: {
+    x: ArrayLike<number>;
+    w: ArrayLike<number>;
+}): Float32Array<ArrayBuffer>;

package/dist/gpu/wgsl-display-view-coupled.js

@@ -0,0 +1,353 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * #593, #601 (2.22.0): the display view's coupled rendering steps on the GPU, shared by the Speed kernel and the Quality pixel
+ * pass: the luminance tone curves by conditioning on luminance (`cp_tone`), and `highlightMode: "reconstruct"` and the
+ * desaturation by the 3-D Gauss–Hermite rule over the development chain (`cp_chain`), the float32 forms of
+ * src/facade/display-view-rendering.ts with the request's fast or full rule. On demand: a kernel takes this text only for a view
+ * that asks for the coupled steps (its pipeline label ends in `+coupled`); every other view takes `DISPLAY_VIEW_COUPLED_STUB_WGSL`.
+ *
+ * Constants come from the kernel's aux table after its own entries (`cp_k(i)`, which each kernel defines), laid out as
+ * `DISPLAY_VIEW_COUPLED` (the host's `displayViewCoupledConstants`). The kernels define `phi` and `pq` (Abramowitz–Stegun) and
+ * `CLIP_REACH`; nothing else is shared.
+ *
+ * Error bounds (first order, float32, E = 2^-23; docs/WEBGPU.md, "Coupled rendering steps"). Every function returns, besides
+ * its moments, absolute bounds of the mean and the variance against the float64 reference and the slopes' relative bound:
+ * - tone: per node the clipped-normal terms (`CLIP_MEAN_U`·r·σ, `CLIP_VARIANCE_U`·r²·σ²), the conditional variance's
+ *   cancellation (0.8·r·√(32·E·Σ_kk)), the node position through the slope and the ratio's relative error (log2 and exp2 per the
+ *   WGSL accuracy table, the image-kernel accelerator's tone analysis); then one E per node of the sums;
+ * - chain: per node the rounding of the developed pixel (white balance and blend 8E of the largest channel, matrix 3E per term,
+ *   tone ratio η, desaturation 8E) carried to the output through the node's own slopes, plus the node point's rounding through
+ *   the slopes; then one E per node of the sums. The chain is continuous (clip, blend, maximum and desaturation all are), so a
+ *   branch taken differently on either side of a kink moves the output by at most the slope times the input's error;
+ * - inputs: the caller's bounds of the means through |slopes|, of the variances through 0.8·|slopes|·√δ.
+ * A decision the reference takes on a threshold (the blend's reach, a component reaching 1 with the desaturation, the fast
+ * rule's range, a node at L = 0 where the ratio jumps) that the float32 values cannot settle sets the pixel's recompute flag:
+ * the host renders that display pixel with the reference.
+ */
+/** Layout of the coupled-constants buffer (float32 words). */
+export const DISPLAY_VIEW_COUPLED = /* @__PURE__ */ Object.freeze({
+    on: 0, luminance: 1, tone: 2, a: 3, n: 4, inverseWhite: 5, ratioAtZero: 6, weights: 7, reconstruct: 10, desaturate: 11, fast: 12,
+    gains: 13, clipLevel: 16, matrix: 17, chainPoints: 26, chainX: 27, chainW: 43, hermiteX: 59, hermiteW: 67, legendreX: 75, legendreW: 91, size: 107
+});
+/** The largest finite float32 stands for r(0+) = ∞ (Naka–Rushton below exponent 1). */
+export const DISPLAY_VIEW_COUPLED_INFINITE_RATIO = 3.4028234663852886e38;
+import { DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL } from "./wgsl-display-view-coupled-stub.js";
+const E_LITERAL = "1.1920928955078125e-7";
+const C = DISPLAY_VIEW_COUPLED;
+/** The coupled steps (see the module comment). */
+export const DISPLAY_VIEW_COUPLED_WGSL = /* wgsl */ `${DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL}
+const CP_E: f32 = ${E_LITERAL};
+const CP_CLIP_MEAN_U: f32 = 1400.0;
+const CP_CLIP_VARIANCE_U: f32 = 36000.0;
+const CP_START: f32 = 0.8;
+fn cp_luminance() -> bool { return cp_k(${C.luminance}u) != 0.0; }
+fn cp_reconstruct() -> bool { return cp_k(${C.reconstruct}u) != 0.0; }
+fn cp_desaturate() -> bool { return cp_k(${C.desaturate}u) != 0.0; }
+fn cp_w() -> vec3<f32> { return vec3<f32>(cp_k(${C.weights}u), cp_k(${C.weights + 1}u), cp_k(${C.weights + 2}u)); }
+fn cp_m(r: u32) -> vec3<f32> { return vec3<f32>(cp_k(${C.matrix}u + 3u * r), cp_k(${C.matrix + 1}u + 3u * r), cp_k(${C.matrix + 2}u + 3u * r)); }
+fn cp_dot(a: vec3<f32>, b: vec3<f32>) -> f32 { return (a.x * b.x + a.y * b.y) + a.z * b.z; }
+fn cp_unit(k: u32) -> vec3<f32> { return vec3<f32>(select(0.0, 1.0, k == 0u), select(0.0, 1.0, k == 1u), select(0.0, 1.0, k == 2u)); }
+
+fn cp_ratio(l: f32) -> vec3<f32> {
+  let a = cp_k(${C.a}u);
+  if (cp_k(${C.tone}u) == 2.0) { let d = 1.0 + l; return vec3<f32>((1.0 + l * a) / d, (a - 1.0) / (d * d), 16.0); }
+  let n = cp_k(${C.n}u);
+  let iw = cp_k(${C.inverseWhite}u);
+let lg = log2(a / l);
+let z = n * lg;
+var g = 0.0; var ug = 0.0;
+if (z >= 0.0) { let p = exp2(-z); g = p / (1.0 + p); ug = 1.0 / (1.0 + p); }
+else { let u = exp2(z); g = 1.0 / (1.0 + u); ug = u / (1.0 + u); }
+let dz = n * (8.5 + 3.0 * abs(lg)) + abs(z);
+return vec3<f32>(g * iw / l, g * (n * ug - 1.0) * iw / (l * l), 2.0 * (0.7 * dz + 3.0 + 2.0 * abs(z)) + 24.0);
+}
+
+fn cp_clip(m: f32, v: f32) -> vec4<f32> {
+if (!(v > 0.0)) { let inside = m > 0.0 && m < 1.0; return vec4<f32>(clamp(m, 0.0, 1.0), 0.0, select(0.0, 1.0, inside), select(0.0, 1.0, m >= 1.0)); }
+let s = sqrt(v);
+let a = -m / s;
+let b = (1.0 - m) / s;
+var pa = 0.0; var da = 0.0;
+if (a > CLIP_REACH) { pa = 1.0; } else if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }
+var pb = 1.0; var qb = 0.0; var db = 0.0;
+if (b < -CLIP_REACH) { pb = 0.0; qb = 1.0; } else if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }
+let inside = pb - pa;
+let eg = a * pa + (da - db) + b * qb;
+let eg2 = a * a * pa + inside - (b * db - a * da) + b * b * qb;
+return vec4<f32>(m + s * eg, max(0.0, v * (eg2 - eg * eg)), inside, qb);
+}
+
+fn cp_reconstruct_reach(cm: vec3<f32>, cv: vec3<f32>) -> u32 {
+var state = 0u;
+for (var k = 0u; k < 3u; k = k + 1u) {
+let top = cm[k] + CLIP_REACH * sqrt(max(0.0, cv[k]));
+let margin = 16.0 * CP_E * (abs(cm[k]) + abs(top));
+if (!(top < CP_START - margin)) { if (top >= CP_START + margin) { return 1u; } state = 2u; }
+}
+return state;
+}
+fn cp_tone(mu: vec3<f32>, s0: vec3<f32>, s1: vec3<f32>, s2: vec3<f32>, dmu: vec3<f32>, dsv: vec3<f32>) -> CpOut {
+let w = cp_w();
+let mul = cp_dot(w, mu);
+let sw = vec3<f32>(cp_dot(s0, w), cp_dot(s1, w), cp_dot(s2, w));
+let vl = cp_dot(w, sw);
+let sl = select(0.0, sqrt(vl), vl > 0.0);
+var beta = vec3<f32>(0.0);
+if (sl > 0.0) { beta = sw / vl; }
+let skk = vec3<f32>(s0.x, s1.y, s2.z);
+let cv = max(vec3<f32>(0.0), skk - beta * sw);
+var centre = clamp(mu, vec3<f32>(0.0), vec3<f32>(1.0));
+if (mul > 0.0) { centre = clamp(mu * cp_ratio(mul).x, vec3<f32>(0.0), vec3<f32>(1.0)); }
+var t: CpOut;
+var second = vec3<f32>(0.0);
+var j = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));
+let dl = 8.0 * CP_E * (abs(mul) + 9.0 * sl);
+let hi = mul + CLIP_REACH * sl;
+let ratio_margin = 64.0 * CP_E * (abs(mul) + sl);
+
+let fast_test = mul - 2.0 * CLIP_REACH * sl;
+  let fast = cp_k(${C.fast}u) != 0.0 && (fast_test > 0.0 || hi < 0.0);
+  if (cp_k(${C.fast}u) != 0.0 && sl > 0.0 && abs(fast_test) <= ratio_margin) { t.flag = true; }
+let split = mul - CLIP_REACH * sl < 0.0 && hi > 0.0;
+if (sl > 0.0 && (abs(mul - CLIP_REACH * sl) <= ratio_margin || abs(hi) <= ratio_margin)) { t.flag = true; }
+var pieces = 1u; var nodes = 1u;
+if (sl > 0.0) { if (fast) { nodes = 8u; } else { nodes = 64u; if (split) { pieces = 2u; } } }
+var count = 0.0;
+for (var piece = 0u; piece < pieces; piece = piece + 1u) {
+var za = -CLIP_REACH; var zb = CLIP_REACH;
+if (pieces == 2u) { if (piece == 0u) { zb = -mul / sl; } else { za = -mul / sl; } }
+for (var i = 0u; i < nodes; i = i + 1u) {
+var l = mul; var weight = 1.0;
+      if (nodes == 8u) { l = mul + sl * cp_k(${C.hermiteX}u + i); weight = cp_k(${C.hermiteW}u + i); }
+else if (nodes == 64u) {
+let width = (zb - za) / 4.0;
+let hw = width / 2.0;
+        let z = za + (f32(i / 16u) + 0.5) * width + hw * cp_k(${C.legendreX}u + (i % 16u));
+l = mul + sl * z;
+        weight = hw * cp_k(${C.legendreW}u + (i % 16u)) * phi(z);
+}
+count = count + 1.0;
+var r = 1.0; var rp = 0.0; var eta = 0.0;
+if (l > 0.0) { let q = cp_ratio(l); r = q.x; rp = q.y; eta = q.z; }
+t.ju = max(t.ju, eta);
+for (var k = 0u; k < 3u; k = k + 1u) {
+let m = mu[k] + beta[k] * (l - mul);
+let c = cp_clip(r * m, r * r * cv[k]);
+let d = c.x - centre[k];
+t.hm[k] = t.hm[k] + weight * c.x;
+second[k] = second[k] + weight * (c.y + d * d);
+
+let zv = r * r * cv[k];
+if (zv > 0.0) {
+let b = (1.0 - r * m) / sqrt(zv);
+if (!(b > CLIP_REACH)) { t.top = true; }
+if (abs(b - CLIP_REACH) <= 64.0 * CP_E * (CLIP_REACH + abs(r * m) / sqrt(zv))) { t.flag = true; }
+} else if (r * m >= 1.0) { t.top = true; }
+let e1 = c.x - c.w;
+j[k] = j[k] + weight * (cp_unit(k) * (r * c.z) + select(vec3<f32>(0.0), w * (rp * e1 / r), rp != 0.0));
+let err = CP_CLIP_MEAN_U * CP_E * r * sqrt(cv[k]) + 0.8 * r * sqrt(32.0 * CP_E * skk[k]) + c.z * (abs(rp * m) + r * abs(beta[k])) * dl + abs(c.x) * eta * CP_E;
+t.bm[k] = t.bm[k] + weight * err;
+t.bv[k] = t.bv[k] + weight * (2.0 * err + CP_CLIP_VARIANCE_U * CP_E * r * r * cv[k]);
+}
+}
+}
+  let r0 = cp_k(${C.ratioAtZero}u);
+if (sl > 0.0 && r0 != 1.0 && abs(mul) < CLIP_REACH * sl) {
+let density = phi(mul / sl) / sl;
+for (var k = 0u; k < 3u; k = k + 1u) {
+let m = mu[k] - beta[k] * mul;
+let below = cp_clip(m, cv[k]).x;
+var above = 0.0;
+if (r0 > 1e30) { if (cv[k] > 0.0) { above = pq(m / sqrt(cv[k])).x; } else { above = select(0.0, 1.0, m > 0.0); } }
+else { above = cp_clip(r0 * m, r0 * r0 * cv[k]).x; }
+j[k] = j[k] + w * (density * (above - below));
+}
+}
+let shifted = t.hm - centre;
+t.hv = max(vec3<f32>(0.0), second - shifted * shifted);
+t.a0 = j[0]; t.a1 = j[1]; t.a2 = j[2];
+for (var k = 0u; k < 3u; k = k + 1u) {
+let ak = abs(j[k]);
+t.bm[k] = t.bm[k] + count * CP_E * abs(t.hm[k]) + cp_dot(ak, dmu) + 0.8 * cp_dot(ak, sqrt(dsv));
+t.bv[k] = t.bv[k] + count * CP_E * second[k] + 2.0 * abs(shifted[k]) * t.bm[k] + cp_dot(ak * ak, dsv);
+}
+t.ju = (t.ju + 4.0 * count) * CP_E;
+return t;
+}
+
+
+struct CpNode { out: vec3<f32>, t0: vec3<f32>, t1: vec3<f32>, t2: vec3<f32>, err: vec3<f32>, flag: bool };
+fn cp_develop(c: vec3<f32>) -> CpNode {
+  let g = vec3<f32>(cp_k(${C.gains}u), cp_k(${C.gains + 1}u), cp_k(${C.gains + 2}u));
+  let lc = cp_k(${C.clipLevel}u);
+let u = c * g;
+var b = u;
+var jb = array<vec3<f32>, 3>(vec3<f32>(g.x, 0.0, 0.0), vec3<f32>(0.0, g.y, 0.0), vec3<f32>(0.0, 0.0, g.z));
+var node: CpNode;
+if (!cp_reconstruct()) {
+for (var k = 0u; k < 3u; k = k + 1u) { if (u[k] > lc) { b[k] = lc; jb[k][k] = 0.0; } }
+} else {
+let s = select(select(c.z, c.y, c.y > c.z), select(c.z, c.x, c.x > c.z), c.x > c.y);
+if (s > CP_START) {
+let si = select(select(2u, 1u, c.y > c.z), select(2u, 0u, c.x > c.z), c.x > c.y);
+let kk = min(u, vec3<f32>(lc));
+let n = select(select(kk.z, kk.y, kk.y > kk.z), select(kk.z, kk.x, kk.x > kk.z), kk.x > kk.y);
+let ni = select(select(2u, 1u, kk.y > kk.z), select(2u, 0u, kk.x > kk.z), kk.x > kk.y);
+let ns = select(g[ni], 0.0, u[ni] > lc);
+let t = select((s - CP_START) / (1.0 - CP_START), 1.0, s >= 1.0);
+let ts = select(1.0 / (1.0 - CP_START), 0.0, s >= 1.0);
+b = (1.0 - t) * u + t * n;
+for (var k = 0u; k < 3u; k = k + 1u) {
+var row = cp_unit(k) * ((1.0 - t) * g[k]);
+row = row + cp_unit(ni) * (t * ns) + cp_unit(si) * ((n - u[k]) * ts);
+jb[k] = row;
+}
+}
+}
+let eb = 8.0 * CP_E * max(abs(u.x), max(abs(u.y), abs(u.z)));
+var y = vec3<f32>(0.0); var ey = vec3<f32>(0.0);
+var mj = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));
+for (var r = 0u; r < 3u; r = r + 1u) {
+let m = cp_m(r);
+y[r] = cp_dot(m, b);
+ey[r] = cp_dot(abs(m), 3.0 * CP_E * abs(b) + vec3<f32>(eb));
+mj[r] = m.x * jb[0] + m.y * jb[1] + m.z * jb[2];
+}
+
+var z = y;
+var jt = array<vec3<f32>, 3>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0));
+var eta = 0.0;
+let w = cp_w();
+if (cp_luminance()) {
+let l = cp_dot(w, y);
+let el = cp_dot(abs(w), ey) + 4.0 * CP_E * cp_dot(abs(w), abs(y));
+    if (cp_k(${C.ratioAtZero}u) != 1.0 && abs(l) <= el) { node.flag = true; }
+if (l > 0.0) {
+let q = cp_ratio(l);
+eta = q.z;
+z = y * q.x;
+for (var k = 0u; k < 3u; k = k + 1u) { jt[k] = cp_unit(k) * q.x + w * (y[k] * q.y); }
+}
+  } else if (cp_k(${C.tone}u) == 1.0) {
+for (var k = 0u; k < 3u; k = k + 1u) { if (y[k] > 0.0) { z[k] = y[k] / (1.0 + y[k]); jt[k] = cp_unit(k) / ((1.0 + y[k]) * (1.0 + y[k])); } }
+}
+var ez = vec3<f32>(0.0);
+for (var k = 0u; k < 3u; k = k + 1u) { ez[k] = cp_dot(abs(jt[k]), ey) + abs(z[k]) * (eta + 4.0) * CP_E; }
+
+var jz = array<vec3<f32>, 3>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0));
+let ti = select(select(2u, 1u, z.y > z.z), select(2u, 0u, z.x > z.z), z.x > z.y);
+let zt = z[ti];
+if (cp_desaturate() && zt > 1.0) {
+let lp = cp_dot(w, z);
+if (lp >= 1.0) {
+node.out = vec3<f32>(1.0);
+node.err = vec3<f32>(0.0);
+return node;
+}
+let d = zt - lp;
+let a = (1.0 - lp) / d;
+for (var k = 0u; k < 3u; k = k + 1u) {
+let da = (-w * d - (1.0 - lp) * (cp_unit(ti) - w)) / (d * d);
+jz[k] = w * (1.0 - a) + cp_unit(k) * a + (z[k] - lp) * da;
+}
+z = lp + a * (z - lp);
+var ez2 = vec3<f32>(0.0);
+for (var k = 0u; k < 3u; k = k + 1u) { ez2[k] = cp_dot(abs(jz[k]), ez) + 8.0 * CP_E * (1.0 + abs(z[k])); }
+ez = ez2;
+}
+node.out = clamp(z, vec3<f32>(0.0), vec3<f32>(1.0));
+node.err = ez;
+var jo = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));
+for (var k = 0u; k < 3u; k = k + 1u) {
+if (z[k] > 0.0 && z[k] < 1.0) { jo[k] = jz[k].x * jt[0] + jz[k].y * jt[1] + jz[k].z * jt[2]; }
+}
+node.t0 = jo[0].x * mj[0] + jo[0].y * mj[1] + jo[0].z * mj[2];
+node.t1 = jo[1].x * mj[0] + jo[1].y * mj[1] + jo[1].z * mj[2];
+node.t2 = jo[2].x * mj[0] + jo[2].y * mj[1] + jo[2].z * mj[2];
+return node;
+}
+fn cp_chain(cm: vec3<f32>, c00: f32, c01: f32, c02: f32, c11: f32, c12: f32, c22: f32, dcm: vec3<f32>, dcv: vec3<f32>) -> CpOut {
+let l00 = sqrt(max(0.0, c00));
+let l10 = select(0.0, c01 / l00, l00 > 0.0);
+let l20 = select(0.0, c02 / l00, l00 > 0.0);
+let l11 = sqrt(max(0.0, c11 - l10 * l10));
+let l21 = select(0.0, (c12 - l20 * l10) / l11, l11 > 0.0);
+let l22 = sqrt(max(0.0, c22 - l20 * l20 - l21 * l21));
+let any_noise = l00 > 0.0 || l11 > 0.0 || l22 > 0.0;
+let second_axis = l11 > 0.0 || l21 != 0.0 || l22 > 0.0;
+  let n = select(1u, u32(cp_k(${C.chainPoints}u)), any_noise);
+let nj = select(1u, n, second_axis);
+let nk = select(1u, n, l22 > 0.0);
+let centre = cp_develop(cm).out;
+var t: CpOut;
+var e = vec3<f32>(0.0); var q = vec3<f32>(0.0); var count = 0.0;
+for (var i = 0u; i < n; i = i + 1u) {
+    let x0 = select(0.0, cp_k(${C.chainX}u + i), any_noise);
+    let wi = select(1.0, cp_k(${C.chainW}u + i), any_noise);
+for (var jj = 0u; jj < nj; jj = jj + 1u) {
+      let x1 = select(0.0, cp_k(${C.chainX}u + jj), second_axis);
+      let wj = select(wi, wi * cp_k(${C.chainW}u + jj), second_axis);
+for (var kk = 0u; kk < nk; kk = kk + 1u) {
+        let x2 = select(0.0, cp_k(${C.chainX}u + kk), l22 > 0.0);
+        let weight = select(wj, wj * cp_k(${C.chainW}u + kk), l22 > 0.0);
+let c = vec3<f32>(cm.x + l00 * x0, cm.y + l10 * x0 + l11 * x1, cm.z + l20 * x0 + l21 * x1 + l22 * x2);
+let dc = 3.0 * CP_E * (abs(cm) + vec3<f32>(abs(l00 * x0), abs(l10 * x0) + abs(l11 * x1), abs(l20 * x0) + abs(l21 * x1) + abs(l22 * x2)));
+let node = cp_develop(c);
+if (node.flag) { t.flag = true; }
+count = count + 1.0;
+let d = node.out - centre;
+e = e + weight * node.out;
+q = q + weight * (d * d);
+t.a0 = t.a0 + weight * node.t0; t.a1 = t.a1 + weight * node.t1; t.a2 = t.a2 + weight * node.t2;
+let err = node.err + vec3<f32>(cp_dot(abs(node.t0), dc), cp_dot(abs(node.t1), dc), cp_dot(abs(node.t2), dc));
+t.bm = t.bm + weight * err;
+t.bv = t.bv + 2.0 * (weight * err);
+}
+}
+}
+let shifted = e - centre;
+t.hm = e;
+t.hv = max(vec3<f32>(0.0), q - shifted * shifted);
+let rows = array<vec3<f32>, 3>(abs(t.a0), abs(t.a1), abs(t.a2));
+for (var k = 0u; k < 3u; k = k + 1u) {
+t.bm[k] = t.bm[k] + count * CP_E * abs(e[k]) + cp_dot(rows[k], dcm) + 0.8 * cp_dot(rows[k], sqrt(dcv));
+t.bv[k] = t.bv[k] + count * CP_E * q[k] + 2.0 * abs(shifted[k]) * t.bm[k] + cp_dot(rows[k] * rows[k], dcv);
+}
+t.ju = (4.0 * count + 64.0) * CP_E;
+return t;
+}
+`;
+/** The host's coupled-constants buffer of a view (`DISPLAY_VIEW_COUPLED` layout), or the one-word stub buffer. */
+export function displayViewCoupledConstants(setup, weights, legendre) {
+    const r = setup.rendering, k = setup.coupled;
+    if (!r || !k)
+        return new Float32Array(1);
+    const out = new Float32Array(C.size), p = r.toneCurveParameters;
+    out[C.on] = 1;
+    out[C.luminance] = k.luminanceTone ? 1 : 0;
+    out[C.tone] = r.toneCurve === "extended-reinhard-luminance" ? 2 : r.toneCurve === "naka-rushton-luminance" ? 3 : r.toneCurve === "positive-reinhard-per-channel" ? 1 : 0;
+    if (p && "exponent" in p) {
+        out[C.a] = p.semiSaturation;
+        out[C.n] = p.exponent;
+        out[C.inverseWhite] = 1 + (p.semiSaturation / p.whiteLuminance) ** p.exponent;
+    }
+    else if (p)
+        out[C.a] = 1 / (p.whiteLuminance * p.whiteLuminance);
+    out[C.ratioAtZero] = k.ratioAtZero === Infinity ? DISPLAY_VIEW_COUPLED_INFINITE_RATIO : k.ratioAtZero;
+    out.set(weights, C.weights);
+    out[C.reconstruct] = r.highlightMode === "reconstruct" ? 1 : 0;
+    out[C.desaturate] = r.gamutHandling === "desaturate-to-luminance" ? 1 : 0;
+    out[C.fast] = r.fast ? 1 : 0;
+    out.set(setup.gains, C.gains);
+    out[C.clipLevel] = setup.clipLevel;
+    out.set(setup.matrix.flat(), C.matrix);
+    out[C.chainPoints] = k.chainRule.x.length;
+    out.set(k.chainRule.x, C.chainX);
+    out.set(k.chainRule.w, C.chainW);
+    out.set(k.luminanceRule.x, C.hermiteX);
+    out.set(k.luminanceRule.w, C.hermiteW);
+    out.set(Array.from(legendre.x), C.legendreX);
+    out.set(Array.from(legendre.w), C.legendreW);
+    return out;
+}
+//# sourceMappingURL=wgsl-display-view-coupled.js.map

package/dist/gpu/wgsl-display-view-coupled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgsl-display-view-coupled.js","sourceRoot":"","sources":["../../src/gpu/wgsl-display-view-coupled.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * #593, #601 (2.22.0): the display view's coupled rendering steps on the GPU, shared by the Speed kernel and the Quality pixel\n * pass: the luminance tone curves by conditioning on luminance (`cp_tone`), and `highlightMode: \"reconstruct\"` and the\n * desaturation by the 3-D Gauss–Hermite rule over the development chain (`cp_chain`), the float32 forms of\n * src/facade/display-view-rendering.ts with the request's fast or full rule. On demand: a kernel takes this text only for a view\n * that asks for the coupled steps (its pipeline label ends in `+coupled`); every other view takes `DISPLAY_VIEW_COUPLED_STUB_WGSL`.\n *\n * Constants come from the kernel's aux table after its own entries (`cp_k(i)`, which each kernel defines), laid out as\n * `DISPLAY_VIEW_COUPLED` (the host's `displayViewCoupledConstants`). The kernels define `phi` and `pq` (Abramowitz–Stegun) and\n * `CLIP_REACH`; nothing else is shared.\n *\n * Error bounds (first order, float32, E = 2^-23; docs/WEBGPU.md, \"Coupled rendering steps\"). Every function returns, besides\n * its moments, absolute bounds of the mean and the variance against the float64 reference and the slopes' relative bound:\n * - tone: per node the clipped-normal terms (`CLIP_MEAN_U`·r·σ, `CLIP_VARIANCE_U`·r²·σ²), the conditional variance's\n *   cancellation (0.8·r·√(32·E·Σ_kk)), the node position through the slope and the ratio's relative error (log2 and exp2 per the\n *   WGSL accuracy table, the image-kernel accelerator's tone analysis); then one E per node of the sums;\n * - chain: per node the rounding of the developed pixel (white balance and blend 8E of the largest channel, matrix 3E per term,\n *   tone ratio η, desaturation 8E) carried to the output through the node's own slopes, plus the node point's rounding through\n *   the slopes; then one E per node of the sums. The chain is continuous (clip, blend, maximum and desaturation all are), so a\n *   branch taken differently on either side of a kink moves the output by at most the slope times the input's error;\n * - inputs: the caller's bounds of the means through |slopes|, of the variances through 0.8·|slopes|·√δ.\n * A decision the reference takes on a threshold (the blend's reach, a component reaching 1 with the desaturation, the fast\n * rule's range, a node at L = 0 where the ratio jumps) that the float32 values cannot settle sets the pixel's recompute flag:\n * the host renders that display pixel with the reference.\n */\n\n/** Layout of the coupled-constants buffer (float32 words). */\nexport const DISPLAY_VIEW_COUPLED = /* @__PURE__ */ Object.freeze({\n  on: 0, luminance: 1, tone: 2, a: 3, n: 4, inverseWhite: 5, ratioAtZero: 6, weights: 7, reconstruct: 10, desaturate: 11, fast: 12,\n  gains: 13, clipLevel: 16, matrix: 17, chainPoints: 26, chainX: 27, chainW: 43, hermiteX: 59, hermiteW: 67, legendreX: 75, legendreW: 91, size: 107\n});\n/** The largest finite float32 stands for r(0+) = ∞ (Naka–Rushton below exponent 1). */\nexport const DISPLAY_VIEW_COUPLED_INFINITE_RATIO = 3.4028234663852886e38;\n\nimport { DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL } from \"./wgsl-display-view-coupled-stub.js\";\n\nconst E_LITERAL = \"1.1920928955078125e-7\";\nconst C = DISPLAY_VIEW_COUPLED;\n\n/** The coupled steps (see the module comment). */\nexport const DISPLAY_VIEW_COUPLED_WGSL = /* wgsl */ `${DISPLAY_VIEW_COUPLED_DECLARATIONS_WGSL}\nconst CP_E: f32 = ${E_LITERAL};\nconst CP_CLIP_MEAN_U: f32 = 1400.0;\nconst CP_CLIP_VARIANCE_U: f32 = 36000.0;\nconst CP_START: f32 = 0.8;\nfn cp_luminance() -> bool { return cp_k(${C.luminance}u) != 0.0; }\nfn cp_reconstruct() -> bool { return cp_k(${C.reconstruct}u) != 0.0; }\nfn cp_desaturate() -> bool { return cp_k(${C.desaturate}u) != 0.0; }\nfn cp_w() -> vec3<f32> { return vec3<f32>(cp_k(${C.weights}u), cp_k(${C.weights + 1}u), cp_k(${C.weights + 2}u)); }\nfn cp_m(r: u32) -> vec3<f32> { return vec3<f32>(cp_k(${C.matrix}u + 3u * r), cp_k(${C.matrix + 1}u + 3u * r), cp_k(${C.matrix + 2}u + 3u * r)); }\nfn cp_dot(a: vec3<f32>, b: vec3<f32>) -> f32 { return (a.x * b.x + a.y * b.y) + a.z * b.z; }\nfn cp_unit(k: u32) -> vec3<f32> { return vec3<f32>(select(0.0, 1.0, k == 0u), select(0.0, 1.0, k == 1u), select(0.0, 1.0, k == 2u)); }\n// The tone ratio r(L) = f(L)/L, its slope r′ and its relative bound η in units of E (L > 0).\nfn cp_ratio(l: f32) -> vec3<f32> {\n  let a = cp_k(${C.a}u);\n  if (cp_k(${C.tone}u) == 2.0) { let d = 1.0 + l; return vec3<f32>((1.0 + l * a) / d, (a - 1.0) / (d * d), 16.0); }\n  let n = cp_k(${C.n}u);\n  let iw = cp_k(${C.inverseWhite}u);\n  let lg = log2(a / l);\n  let z = n * lg;\n  var g = 0.0; var ug = 0.0;\n  if (z >= 0.0) { let p = exp2(-z); g = p / (1.0 + p); ug = 1.0 / (1.0 + p); }\n  else { let u = exp2(z); g = 1.0 / (1.0 + u); ug = u / (1.0 + u); }\n  let dz = n * (8.5 + 3.0 * abs(lg)) + abs(z);\n  return vec3<f32>(g * iw / l, g * (n * ug - 1.0) * iw / (l * l), 2.0 * (0.7 * dz + 3.0 + 2.0 * abs(z)) + 24.0);\n}\n// clip(Z, 0, 1) for Z ~ N(m, v), standardized (cancellation-free): (mean, variance, P(0 < Z < 1), P(Z ≥ 1)).\nfn cp_clip(m: f32, v: f32) -> vec4<f32> {\n  if (!(v > 0.0)) { let inside = m > 0.0 && m < 1.0; return vec4<f32>(clamp(m, 0.0, 1.0), 0.0, select(0.0, 1.0, inside), select(0.0, 1.0, m >= 1.0)); }\n  let s = sqrt(v);\n  let a = -m / s;\n  let b = (1.0 - m) / s;\n  var pa = 0.0; var da = 0.0;\n  if (a > CLIP_REACH) { pa = 1.0; } else if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }\n  var pb = 1.0; var qb = 0.0; var db = 0.0;\n  if (b < -CLIP_REACH) { pb = 0.0; qb = 1.0; } else if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }\n  let inside = pb - pa;\n  let eg = a * pa + (da - db) + b * qb;\n  let eg2 = a * a * pa + inside - (b * db - a * da) + b * b * qb;\n  return vec4<f32>(m + s * eg, max(0.0, v * (eg2 - eg * eg)), inside, qb);\n}\n// Whether the reconstruct blend is within reach of channels with means cm and variances cv: 0 no, 1 yes, 2 undecided in float32.\nfn cp_reconstruct_reach(cm: vec3<f32>, cv: vec3<f32>) -> u32 {\n  var state = 0u;\n  for (var k = 0u; k < 3u; k = k + 1u) {\n    let top = cm[k] + CLIP_REACH * sqrt(max(0.0, cv[k]));\n    let margin = 16.0 * CP_E * (abs(cm[k]) + abs(top));\n    if (!(top < CP_START - margin)) { if (top >= CP_START + margin) { return 1u; } state = 2u; }\n  }\n  return state;\n}\nfn cp_tone(mu: vec3<f32>, s0: vec3<f32>, s1: vec3<f32>, s2: vec3<f32>, dmu: vec3<f32>, dsv: vec3<f32>) -> CpOut {\n  let w = cp_w();\n  let mul = cp_dot(w, mu);\n  let sw = vec3<f32>(cp_dot(s0, w), cp_dot(s1, w), cp_dot(s2, w));\n  let vl = cp_dot(w, sw);\n  let sl = select(0.0, sqrt(vl), vl > 0.0);\n  var beta = vec3<f32>(0.0);\n  if (sl > 0.0) { beta = sw / vl; }\n  let skk = vec3<f32>(s0.x, s1.y, s2.z);\n  let cv = max(vec3<f32>(0.0), skk - beta * sw);\n  var centre = clamp(mu, vec3<f32>(0.0), vec3<f32>(1.0));\n  if (mul > 0.0) { centre = clamp(mu * cp_ratio(mul).x, vec3<f32>(0.0), vec3<f32>(1.0)); }\n  var t: CpOut;\n  var second = vec3<f32>(0.0);\n  var j = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));\n  let dl = 8.0 * CP_E * (abs(mul) + 9.0 * sl);\n  let hi = mul + CLIP_REACH * sl;\n  let ratio_margin = 64.0 * CP_E * (abs(mul) + sl);\n  // The fast rule's range test and the split at L = 0, as the reference takes them (undecided: recompute).\n  let fast_test = mul - 2.0 * CLIP_REACH * sl;\n  let fast = cp_k(${C.fast}u) != 0.0 && (fast_test > 0.0 || hi < 0.0);\n  if (cp_k(${C.fast}u) != 0.0 && sl > 0.0 && abs(fast_test) <= ratio_margin) { t.flag = true; }\n  let split = mul - CLIP_REACH * sl < 0.0 && hi > 0.0;\n  if (sl > 0.0 && (abs(mul - CLIP_REACH * sl) <= ratio_margin || abs(hi) <= ratio_margin)) { t.flag = true; }\n  var pieces = 1u; var nodes = 1u;\n  if (sl > 0.0) { if (fast) { nodes = 8u; } else { nodes = 64u; if (split) { pieces = 2u; } } }\n  var count = 0.0;\n  for (var piece = 0u; piece < pieces; piece = piece + 1u) {\n    var za = -CLIP_REACH; var zb = CLIP_REACH;\n    if (pieces == 2u) { if (piece == 0u) { zb = -mul / sl; } else { za = -mul / sl; } }\n    for (var i = 0u; i < nodes; i = i + 1u) {\n      var l = mul; var weight = 1.0;\n      if (nodes == 8u) { l = mul + sl * cp_k(${C.hermiteX}u + i); weight = cp_k(${C.hermiteW}u + i); }\n      else if (nodes == 64u) {\n        let width = (zb - za) / 4.0;\n        let hw = width / 2.0;\n        let z = za + (f32(i / 16u) + 0.5) * width + hw * cp_k(${C.legendreX}u + (i % 16u));\n        l = mul + sl * z;\n        weight = hw * cp_k(${C.legendreW}u + (i % 16u)) * phi(z);\n      }\n      count = count + 1.0;\n      var r = 1.0; var rp = 0.0; var eta = 0.0;\n      if (l > 0.0) { let q = cp_ratio(l); r = q.x; rp = q.y; eta = q.z; }\n      t.ju = max(t.ju, eta);\n      for (var k = 0u; k < 3u; k = k + 1u) {\n        let m = mu[k] + beta[k] * (l - mul);\n        let c = cp_clip(r * m, r * r * cv[k]);\n        let d = c.x - centre[k];\n        t.hm[k] = t.hm[k] + weight * c.x;\n        second[k] = second[k] + weight * (c.y + d * d);\n        // The reference's test of a component reaching 1 (b ≤ 8.5 standard deviations); undecided in float32: recompute.\n        let zv = r * r * cv[k];\n        if (zv > 0.0) {\n          let b = (1.0 - r * m) / sqrt(zv);\n          if (!(b > CLIP_REACH)) { t.top = true; }\n          if (abs(b - CLIP_REACH) <= 64.0 * CP_E * (CLIP_REACH + abs(r * m) / sqrt(zv))) { t.flag = true; }\n        } else if (r * m >= 1.0) { t.top = true; }\n        let e1 = c.x - c.w;\n        j[k] = j[k] + weight * (cp_unit(k) * (r * c.z) + select(vec3<f32>(0.0), w * (rp * e1 / r), rp != 0.0));\n        let err = CP_CLIP_MEAN_U * CP_E * r * sqrt(cv[k]) + 0.8 * r * sqrt(32.0 * CP_E * skk[k]) + c.z * (abs(rp * m) + r * abs(beta[k])) * dl + abs(c.x) * eta * CP_E;\n        t.bm[k] = t.bm[k] + weight * err;\n        t.bv[k] = t.bv[k] + weight * (2.0 * err + CP_CLIP_VARIANCE_U * CP_E * r * r * cv[k]);\n      }\n    }\n  }\n  let r0 = cp_k(${C.ratioAtZero}u);\n  if (sl > 0.0 && r0 != 1.0 && abs(mul) < CLIP_REACH * sl) {\n    let density = phi(mul / sl) / sl;\n    for (var k = 0u; k < 3u; k = k + 1u) {\n      let m = mu[k] - beta[k] * mul;\n      let below = cp_clip(m, cv[k]).x;\n      var above = 0.0;\n      if (r0 > 1e30) { if (cv[k] > 0.0) { above = pq(m / sqrt(cv[k])).x; } else { above = select(0.0, 1.0, m > 0.0); } }\n      else { above = cp_clip(r0 * m, r0 * r0 * cv[k]).x; }\n      j[k] = j[k] + w * (density * (above - below));\n    }\n  }\n  let shifted = t.hm - centre;\n  t.hv = max(vec3<f32>(0.0), second - shifted * shifted);\n  t.a0 = j[0]; t.a1 = j[1]; t.a2 = j[2];\n  for (var k = 0u; k < 3u; k = k + 1u) {\n    let ak = abs(j[k]);\n    t.bm[k] = t.bm[k] + count * CP_E * abs(t.hm[k]) + cp_dot(ak, dmu) + 0.8 * cp_dot(ak, sqrt(dsv));\n    t.bv[k] = t.bv[k] + count * CP_E * second[k] + 2.0 * abs(shifted[k]) * t.bm[k] + cp_dot(ak * ak, dsv);\n  }\n  t.ju = (t.ju + 4.0 * count) * CP_E;\n  return t;\n}\n// One node of the development chain at camera channels c: the rendered pixel, the slopes ∂out/∂c (rows), the rounding bound\n// per component (before the node point's own rounding) and whether a luminance at 0 makes the ratio's jump undecided.\nstruct CpNode { out: vec3<f32>, t0: vec3<f32>, t1: vec3<f32>, t2: vec3<f32>, err: vec3<f32>, flag: bool };\nfn cp_develop(c: vec3<f32>) -> CpNode {\n  let g = vec3<f32>(cp_k(${C.gains}u), cp_k(${C.gains + 1}u), cp_k(${C.gains + 2}u));\n  let lc = cp_k(${C.clipLevel}u);\n  let u = c * g;\n  var b = u;\n  var jb = array<vec3<f32>, 3>(vec3<f32>(g.x, 0.0, 0.0), vec3<f32>(0.0, g.y, 0.0), vec3<f32>(0.0, 0.0, g.z));\n  var node: CpNode;\n  if (!cp_reconstruct()) {\n    for (var k = 0u; k < 3u; k = k + 1u) { if (u[k] > lc) { b[k] = lc; jb[k][k] = 0.0; } }\n  } else {\n    let s = select(select(c.z, c.y, c.y > c.z), select(c.z, c.x, c.x > c.z), c.x > c.y);\n    if (s > CP_START) {\n      let si = select(select(2u, 1u, c.y > c.z), select(2u, 0u, c.x > c.z), c.x > c.y);\n      let kk = min(u, vec3<f32>(lc));\n      let n = select(select(kk.z, kk.y, kk.y > kk.z), select(kk.z, kk.x, kk.x > kk.z), kk.x > kk.y);\n      let ni = select(select(2u, 1u, kk.y > kk.z), select(2u, 0u, kk.x > kk.z), kk.x > kk.y);\n      let ns = select(g[ni], 0.0, u[ni] > lc);\n      let t = select((s - CP_START) / (1.0 - CP_START), 1.0, s >= 1.0);\n      let ts = select(1.0 / (1.0 - CP_START), 0.0, s >= 1.0);\n      b = (1.0 - t) * u + t * n;\n      for (var k = 0u; k < 3u; k = k + 1u) {\n        var row = cp_unit(k) * ((1.0 - t) * g[k]);\n        row = row + cp_unit(ni) * (t * ns) + cp_unit(si) * ((n - u[k]) * ts);\n        jb[k] = row;\n      }\n    }\n  }\n  let eb = 8.0 * CP_E * max(abs(u.x), max(abs(u.y), abs(u.z)));\n  var y = vec3<f32>(0.0); var ey = vec3<f32>(0.0);\n  var mj = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));\n  for (var r = 0u; r < 3u; r = r + 1u) {\n    let m = cp_m(r);\n    y[r] = cp_dot(m, b);\n    ey[r] = cp_dot(abs(m), 3.0 * CP_E * abs(b) + vec3<f32>(eb));\n    mj[r] = m.x * jb[0] + m.y * jb[1] + m.z * jb[2];\n  }\n  // Tone (luminance curve, positive Reinhard or identity).\n  var z = y;\n  var jt = array<vec3<f32>, 3>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0));\n  var eta = 0.0;\n  let w = cp_w();\n  if (cp_luminance()) {\n    let l = cp_dot(w, y);\n    let el = cp_dot(abs(w), ey) + 4.0 * CP_E * cp_dot(abs(w), abs(y));\n    if (cp_k(${C.ratioAtZero}u) != 1.0 && abs(l) <= el) { node.flag = true; }\n    if (l > 0.0) {\n      let q = cp_ratio(l);\n      eta = q.z;\n      z = y * q.x;\n      for (var k = 0u; k < 3u; k = k + 1u) { jt[k] = cp_unit(k) * q.x + w * (y[k] * q.y); }\n    }\n  } else if (cp_k(${C.tone}u) == 1.0) {\n    for (var k = 0u; k < 3u; k = k + 1u) { if (y[k] > 0.0) { z[k] = y[k] / (1.0 + y[k]); jt[k] = cp_unit(k) / ((1.0 + y[k]) * (1.0 + y[k])); } }\n  }\n  var ez = vec3<f32>(0.0);\n  for (var k = 0u; k < 3u; k = k + 1u) { ez[k] = cp_dot(abs(jt[k]), ey) + abs(z[k]) * (eta + 4.0) * CP_E; }\n  // Desaturation toward the luminance (#601).\n  var jz = array<vec3<f32>, 3>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0));\n  let ti = select(select(2u, 1u, z.y > z.z), select(2u, 0u, z.x > z.z), z.x > z.y);\n  let zt = z[ti];\n  if (cp_desaturate() && zt > 1.0) {\n    let lp = cp_dot(w, z);\n    if (lp >= 1.0) {\n      node.out = vec3<f32>(1.0);\n      node.err = vec3<f32>(0.0);\n      return node;\n    }\n    let d = zt - lp;\n    let a = (1.0 - lp) / d;\n    for (var k = 0u; k < 3u; k = k + 1u) {\n      let da = (-w * d - (1.0 - lp) * (cp_unit(ti) - w)) / (d * d);\n      jz[k] = w * (1.0 - a) + cp_unit(k) * a + (z[k] - lp) * da;\n    }\n    z = lp + a * (z - lp);\n    var ez2 = vec3<f32>(0.0);\n    for (var k = 0u; k < 3u; k = k + 1u) { ez2[k] = cp_dot(abs(jz[k]), ez) + 8.0 * CP_E * (1.0 + abs(z[k])); }\n    ez = ez2;\n  }\n  node.out = clamp(z, vec3<f32>(0.0), vec3<f32>(1.0));\n  node.err = ez;\n  var jo = array<vec3<f32>, 3>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));\n  for (var k = 0u; k < 3u; k = k + 1u) {\n    if (z[k] > 0.0 && z[k] < 1.0) { jo[k] = jz[k].x * jt[0] + jz[k].y * jt[1] + jz[k].z * jt[2]; }\n  }\n  node.t0 = jo[0].x * mj[0] + jo[0].y * mj[1] + jo[0].z * mj[2];\n  node.t1 = jo[1].x * mj[0] + jo[1].y * mj[1] + jo[1].z * mj[2];\n  node.t2 = jo[2].x * mj[0] + jo[2].y * mj[1] + jo[2].z * mj[2];\n  return node;\n}\nfn cp_chain(cm: vec3<f32>, c00: f32, c01: f32, c02: f32, c11: f32, c12: f32, c22: f32, dcm: vec3<f32>, dcv: vec3<f32>) -> CpOut {\n  let l00 = sqrt(max(0.0, c00));\n  let l10 = select(0.0, c01 / l00, l00 > 0.0);\n  let l20 = select(0.0, c02 / l00, l00 > 0.0);\n  let l11 = sqrt(max(0.0, c11 - l10 * l10));\n  let l21 = select(0.0, (c12 - l20 * l10) / l11, l11 > 0.0);\n  let l22 = sqrt(max(0.0, c22 - l20 * l20 - l21 * l21));\n  let any_noise = l00 > 0.0 || l11 > 0.0 || l22 > 0.0;\n  let second_axis = l11 > 0.0 || l21 != 0.0 || l22 > 0.0;\n  let n = select(1u, u32(cp_k(${C.chainPoints}u)), any_noise);\n  let nj = select(1u, n, second_axis);\n  let nk = select(1u, n, l22 > 0.0);\n  let centre = cp_develop(cm).out;\n  var t: CpOut;\n  var e = vec3<f32>(0.0); var q = vec3<f32>(0.0); var count = 0.0;\n  for (var i = 0u; i < n; i = i + 1u) {\n    let x0 = select(0.0, cp_k(${C.chainX}u + i), any_noise);\n    let wi = select(1.0, cp_k(${C.chainW}u + i), any_noise);\n    for (var jj = 0u; jj < nj; jj = jj + 1u) {\n      let x1 = select(0.0, cp_k(${C.chainX}u + jj), second_axis);\n      let wj = select(wi, wi * cp_k(${C.chainW}u + jj), second_axis);\n      for (var kk = 0u; kk < nk; kk = kk + 1u) {\n        let x2 = select(0.0, cp_k(${C.chainX}u + kk), l22 > 0.0);\n        let weight = select(wj, wj * cp_k(${C.chainW}u + kk), l22 > 0.0);\n        let c = vec3<f32>(cm.x + l00 * x0, cm.y + l10 * x0 + l11 * x1, cm.z + l20 * x0 + l21 * x1 + l22 * x2);\n        let dc = 3.0 * CP_E * (abs(cm) + vec3<f32>(abs(l00 * x0), abs(l10 * x0) + abs(l11 * x1), abs(l20 * x0) + abs(l21 * x1) + abs(l22 * x2)));\n        let node = cp_develop(c);\n        if (node.flag) { t.flag = true; }\n        count = count + 1.0;\n        let d = node.out - centre;\n        e = e + weight * node.out;\n        q = q + weight * (d * d);\n        t.a0 = t.a0 + weight * node.t0; t.a1 = t.a1 + weight * node.t1; t.a2 = t.a2 + weight * node.t2;\n        let err = node.err + vec3<f32>(cp_dot(abs(node.t0), dc), cp_dot(abs(node.t1), dc), cp_dot(abs(node.t2), dc));\n        t.bm = t.bm + weight * err;\n        t.bv = t.bv + 2.0 * (weight * err);\n      }\n    }\n  }\n  let shifted = e - centre;\n  t.hm = e;\n  t.hv = max(vec3<f32>(0.0), q - shifted * shifted);\n  let rows = array<vec3<f32>, 3>(abs(t.a0), abs(t.a1), abs(t.a2));\n  for (var k = 0u; k < 3u; k = k + 1u) {\n    t.bm[k] = t.bm[k] + count * CP_E * abs(e[k]) + cp_dot(rows[k], dcm) + 0.8 * cp_dot(rows[k], sqrt(dcv));\n    t.bv[k] = t.bv[k] + count * CP_E * q[k] + 2.0 * abs(shifted[k]) * t.bm[k] + cp_dot(rows[k] * rows[k], dcv);\n  }\n  t.ju = (4.0 * count + 64.0) * CP_E;\n  return t;\n}\n`;\n\n/** The host's coupled-constants buffer of a view (`DISPLAY_VIEW_COUPLED` layout), or the one-word stub buffer. */\nexport function displayViewCoupledConstants(setup: {\n  gains: readonly number[]; clipLevel: number; matrix: readonly (readonly number[])[];\n  rendering?: { toneCurve: string; toneCurveParameters?: { whiteLuminance: number } | { exponent: number; semiSaturation: number; whiteLuminance: number }; highlightMode: string; gamutHandling: string; fast: boolean };\n  coupled?: { chainRule: { x: Float64Array; w: Float64Array }; luminanceRule: { x: Float64Array; w: Float64Array }; ratioAtZero: number; luminanceTone: boolean };\n}, weights: readonly number[], legendre: { x: ArrayLike<number>; w: ArrayLike<number> }): Float32Array<ArrayBuffer> {\n  const r = setup.rendering, k = setup.coupled;\n  if (!r || !k) return new Float32Array(1);\n  const out = new Float32Array(C.size), p = r.toneCurveParameters;\n  out[C.on] = 1; out[C.luminance] = k.luminanceTone ? 1 : 0;\n  out[C.tone] = r.toneCurve === \"extended-reinhard-luminance\" ? 2 : r.toneCurve === \"naka-rushton-luminance\" ? 3 : r.toneCurve === \"positive-reinhard-per-channel\" ? 1 : 0;\n  if (p && \"exponent\" in p) {\n    out[C.a] = p.semiSaturation; out[C.n] = p.exponent; out[C.inverseWhite] = 1 + (p.semiSaturation / p.whiteLuminance) ** p.exponent;\n  } else if (p) out[C.a] = 1 / (p.whiteLuminance * p.whiteLuminance);\n  out[C.ratioAtZero] = k.ratioAtZero === Infinity ? DISPLAY_VIEW_COUPLED_INFINITE_RATIO : k.ratioAtZero;\n  out.set(weights, C.weights);\n  out[C.reconstruct] = r.highlightMode === \"reconstruct\" ? 1 : 0; out[C.desaturate] = r.gamutHandling === \"desaturate-to-luminance\" ? 1 : 0; out[C.fast] = r.fast ? 1 : 0;\n  out.set(setup.gains, C.gains); out[C.clipLevel] = setup.clipLevel; out.set(setup.matrix.flat(), C.matrix);\n  out[C.chainPoints] = k.chainRule.x.length; out.set(k.chainRule.x, C.chainX); out.set(k.chainRule.w, C.chainW);\n  out.set(k.luminanceRule.x, C.hermiteX); out.set(k.luminanceRule.w, C.hermiteW);\n  out.set(Array.from(legendre.x), C.legendreX); out.set(Array.from(legendre.w), C.legendreW);\n  return out;\n}\n"]}