@aura3d/rendering 3.0.1 → 4.0.2

package/dist/reference/PostProcessPass.js

@@ -0,0 +1,2023 @@
+import { BaseRenderPass } from "../RenderPass.js";
+import { RenderDeviceError } from "../RenderDevice.js";
+import { OUTLINE_LUMA_SCALE, createOutlineGradientBound } from "../postprocess/NativeLdrEffectLuts.js";
+export class ToneMappingPass extends BaseRenderPass {
+    options;
+    exposure;
+    whitePoint;
+    gamma;
+    operator;
+    inputColorSpace;
+    outputColorSpace;
+    lastResult = null;
+    constructor(options) {
+        super(options.name ?? "tone-mapping", [options.readResource ?? options.source.label], [options.writeResource ?? options.target?.label ?? "backbuffer"]);
+        this.options = options;
+        this.exposure = options.exposure ?? 1;
+        this.whitePoint = options.whitePoint ?? 1;
+        this.gamma = options.gamma ?? 2.2;
+        this.operator = options.operator ?? "reinhard";
+        this.inputColorSpace = options.inputColorSpace ?? "linear";
+        this.outputColorSpace = options.outputColorSpace ?? "linear";
+        if (!Number.isFinite(this.exposure) || this.exposure < 0) {
+            throw new Error("ToneMappingPass exposure must be finite and non-negative.");
+        }
+        if (!Number.isFinite(this.whitePoint) || this.whitePoint <= 0) {
+            throw new Error("ToneMappingPass whitePoint must be finite and positive.");
+        }
+        if (!Number.isFinite(this.gamma) || this.gamma <= 0) {
+            throw new Error("ToneMappingPass gamma must be finite and positive.");
+        }
+    }
+    execute(context) {
+        context.device.setRenderTarget(this.options.source);
+        const mapped = this.options.source.colorTexture.format === "rgba16f" || this.options.source.colorTexture.format === "rgba32f"
+            ? toneMapFloatPixels(context.device.readFloatPixels(0, 0, this.options.source.width, this.options.source.height), this.options.source.width, this.options.source.height, {
+                exposure: this.exposure,
+                whitePoint: this.whitePoint,
+                gamma: this.gamma,
+                operator: this.operator,
+                outputColorSpace: this.outputColorSpace
+            })
+            : toneMapPixels(context.device.readPixels(0, 0, this.options.source.width, this.options.source.height), this.options.source.width, this.options.source.height, {
+                exposure: this.exposure,
+                whitePoint: this.whitePoint,
+                gamma: this.gamma,
+                operator: this.operator,
+                inputColorSpace: this.inputColorSpace,
+                outputColorSpace: this.outputColorSpace
+            });
+        writeRenderTarget(context.device, this.options.source, this.options.target, mapped.pixels);
+        this.lastResult = mapped;
+    }
+    getLastResult() {
+        return this.lastResult ? { ...this.lastResult, pixels: new Uint8Array(this.lastResult.pixels) } : null;
+    }
+}
+export class DepthVisualizationPass extends BaseRenderPass {
+    options;
+    edgeThreshold;
+    lastResult = null;
+    constructor(options) {
+        super(options.name ?? "depth-visualization", [options.readResource ?? options.source.label], [options.writeResource ?? options.target?.label ?? "depth-visualization-output"]);
+        this.options = options;
+        this.edgeThreshold = options.edgeThreshold ?? 0.08;
+        if (!Number.isFinite(this.edgeThreshold) || this.edgeThreshold < 0 || this.edgeThreshold > 1) {
+            throw new Error("DepthVisualizationPass edgeThreshold must be finite and in [0, 1].");
+        }
+    }
+    execute(context) {
+        const visualized = visualizeDepthTexture(this.options.source, { edgeThreshold: this.edgeThreshold });
+        writeDepthTarget(this.options.target, this.options.source.width, this.options.source.height, visualized.pixels);
+        context.device.setRenderTarget(this.options.target ?? null);
+        this.lastResult = visualized;
+    }
+    getLastResult() {
+        return this.lastResult
+            ? {
+                ...this.lastResult,
+                pixels: new Uint8Array(this.lastResult.pixels),
+                stats: { ...this.lastResult.stats }
+            }
+            : null;
+    }
+}
+export class BloomPass extends BaseRenderPass {
+    options;
+    threshold;
+    intensity;
+    radius;
+    lastResult = null;
+    constructor(options) {
+        super(options.name ?? "bloom", [options.readResource ?? options.source.label], [options.writeResource ?? options.target?.label ?? "bloom-output"]);
+        this.options = options;
+        this.threshold = options.threshold ?? 0.75;
+        this.intensity = options.intensity ?? 0.35;
+        this.radius = options.radius ?? 1;
+        validateBloomOptions(this.threshold, this.intensity, this.radius);
+    }
+    execute(context) {
+        context.device.setRenderTarget(this.options.source);
+        const pixels = context.device.readPixels(0, 0, this.options.source.width, this.options.source.height);
+        const bloomed = bloomPixels(pixels, this.options.source.width, this.options.source.height, {
+            threshold: this.threshold,
+            intensity: this.intensity,
+            radius: this.radius
+        });
+        writeRenderTarget(context.device, this.options.source, this.options.target, bloomed.pixels);
+        this.lastResult = bloomed;
+    }
+    getLastResult() {
+        return this.lastResult
+            ? {
+                ...this.lastResult,
+                pixels: new Uint8Array(this.lastResult.pixels),
+                brightPixels: new Uint8Array(this.lastResult.brightPixels),
+                horizontalBlurPixels: new Uint8Array(this.lastResult.horizontalBlurPixels),
+                verticalBlurPixels: new Uint8Array(this.lastResult.verticalBlurPixels)
+            }
+            : null;
+    }
+}
+export class FXAAPass extends BaseRenderPass {
+    options;
+    edgeThreshold;
+    subpixelBlend;
+    lastResult = null;
+    constructor(options) {
+        super(options.name ?? "fxaa", [options.readResource ?? options.source.label], [options.writeResource ?? options.target?.label ?? "fxaa-output"]);
+        this.options = options;
+        this.edgeThreshold = options.edgeThreshold ?? 0.125;
+        this.subpixelBlend = options.subpixelBlend ?? 0.75;
+        validateFXAAOptions(this.edgeThreshold, this.subpixelBlend);
+    }
+    execute(context) {
+        context.device.setRenderTarget(this.options.source);
+        const pixels = context.device.readPixels(0, 0, this.options.source.width, this.options.source.height);
+        const smoothed = fxaaPixels(pixels, this.options.source.width, this.options.source.height, {
+            edgeThreshold: this.edgeThreshold,
+            subpixelBlend: this.subpixelBlend
+        });
+        writeRenderTarget(context.device, this.options.source, this.options.target, smoothed.pixels);
+        this.lastResult = smoothed;
+    }
+    getLastResult() {
+        return this.lastResult
+            ? {
+                ...this.lastResult,
+                pixels: new Uint8Array(this.lastResult.pixels),
+                edgeMask: new Uint8Array(this.lastResult.edgeMask)
+            }
+            : null;
+    }
+}
+export function toneMapPixels(pixels, width, height, options = {}) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error("Tone mapping dimensions must be positive integers.");
+    }
+    if (pixels.byteLength !== width * height * 4) {
+        throw new Error("Tone mapping input must contain width * height * 4 RGBA bytes.");
+    }
+    const exposure = options.exposure ?? 1;
+    const whitePoint = options.whitePoint ?? 1;
+    const gamma = options.gamma ?? 2.2;
+    const operator = options.operator ?? "reinhard";
+    const inputColorSpace = options.inputColorSpace ?? "linear";
+    const outputColorSpace = options.outputColorSpace ?? "linear";
+    if (!Number.isFinite(exposure) || exposure < 0) {
+        throw new Error("Tone mapping exposure must be finite and non-negative.");
+    }
+    if (!Number.isFinite(whitePoint) || whitePoint <= 0) {
+        throw new Error("Tone mapping whitePoint must be finite and positive.");
+    }
+    if (!Number.isFinite(gamma) || gamma <= 0) {
+        throw new Error("Tone mapping gamma must be finite and positive.");
+    }
+    const output = new Uint8Array(pixels.byteLength);
+    for (let index = 0; index < pixels.length; index += 4) {
+        const decoded = [
+            decodeColorByte(pixels[index], inputColorSpace),
+            decodeColorByte(pixels[index + 1], inputColorSpace),
+            decodeColorByte(pixels[index + 2], inputColorSpace)
+        ];
+        const mapped = operator === "aces" ? acesFilmicRgb(decoded, exposure, whitePoint) : undefined;
+        output[index] = mapped ? encodeColorByte(mapped[0], gamma, outputColorSpace) : encodeToneMappedChannel(decoded[0], exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 1] = mapped ? encodeColorByte(mapped[1], gamma, outputColorSpace) : encodeToneMappedChannel(decoded[1], exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 2] = mapped ? encodeColorByte(mapped[2], gamma, outputColorSpace) : encodeToneMappedChannel(decoded[2], exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 3] = pixels[index + 3];
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        colorSpace: outputColorSpace,
+        calibration: createToneMappingCalibration({ exposure, whitePoint, gamma, operator, inputColorSpace, outputColorSpace })
+    };
+}
+export function toneMapFloatPixels(pixels, width, height, options = {}) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error("HDR tone mapping dimensions must be positive integers.");
+    }
+    if (pixels.length !== width * height * 4) {
+        throw new Error("HDR tone mapping input must contain width * height * 4 RGBA float values.");
+    }
+    const exposure = options.exposure ?? 1;
+    const whitePoint = options.whitePoint ?? 1;
+    const gamma = options.gamma ?? 2.2;
+    const operator = options.operator ?? "reinhard";
+    const outputColorSpace = options.outputColorSpace ?? "linear";
+    if (!Number.isFinite(exposure) || exposure < 0) {
+        throw new Error("HDR tone mapping exposure must be finite and non-negative.");
+    }
+    if (!Number.isFinite(whitePoint) || whitePoint <= 0) {
+        throw new Error("HDR tone mapping whitePoint must be finite and positive.");
+    }
+    if (!Number.isFinite(gamma) || gamma <= 0) {
+        throw new Error("HDR tone mapping gamma must be finite and positive.");
+    }
+    const output = new Uint8Array(pixels.length);
+    let inputOverbrightPixels = 0;
+    let maxInputValue = 0;
+    for (let index = 0; index < pixels.length; index += 4) {
+        const r = finiteHdrChannel(pixels[index], index);
+        const g = finiteHdrChannel(pixels[index + 1], index + 1);
+        const b = finiteHdrChannel(pixels[index + 2], index + 2);
+        const a = finiteHdrChannel(pixels[index + 3], index + 3);
+        if (r > 1 || g > 1 || b > 1)
+            inputOverbrightPixels += 1;
+        maxInputValue = Math.max(maxInputValue, r, g, b);
+        const mapped = operator === "aces" ? acesFilmicRgb([r, g, b], exposure, whitePoint) : undefined;
+        output[index] = mapped ? encodeColorByte(mapped[0], gamma, outputColorSpace) : encodeToneMappedChannel(r, exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 1] = mapped ? encodeColorByte(mapped[1], gamma, outputColorSpace) : encodeToneMappedChannel(g, exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 2] = mapped ? encodeColorByte(mapped[2], gamma, outputColorSpace) : encodeToneMappedChannel(b, exposure, whitePoint, gamma, operator, outputColorSpace);
+        output[index + 3] = clampByte(a * 255);
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        colorSpace: outputColorSpace,
+        calibration: createToneMappingCalibration({ exposure, whitePoint, gamma, operator, inputColorSpace: "linear", outputColorSpace }),
+        inputOverbrightPixels,
+        maxInputValue: Number(maxInputValue.toFixed(6))
+    };
+}
+export function colorGradePixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Color grading");
+    const settings = {
+        contrast: options.contrast ?? 1,
+        temperature: options.temperature ?? 0,
+        tint: options.tint ?? 0,
+        saturation: options.saturation ?? 1,
+        vibrance: options.vibrance ?? 0,
+        vignette: options.vignette ?? 0,
+        sharpening: options.sharpening ?? 0
+    };
+    validateRange(settings.contrast, 0, 3, "Color grading contrast");
+    validateRange(settings.temperature, -1, 1, "Color grading temperature");
+    validateRange(settings.tint, -1, 1, "Color grading tint");
+    validateRange(settings.saturation, 0, 3, "Color grading saturation");
+    validateRange(settings.vibrance, -1, 1, "Color grading vibrance");
+    validateRange(settings.vignette, 0, 1, "Color grading vignette");
+    validateRange(settings.sharpening, 0, 2, "Color grading sharpening");
+    const graded = new Uint8Array(pixels.byteLength);
+    let changedPixels = 0;
+    let vignetteDarkenedPixels = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = (y * width + x) * 4;
+            let r = (pixels[index] ?? 0) / 255;
+            let g = (pixels[index + 1] ?? 0) / 255;
+            let b = (pixels[index + 2] ?? 0) / 255;
+            const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            r = (r - 0.5) * settings.contrast + 0.5;
+            g = (g - 0.5) * settings.contrast + 0.5;
+            b = (b - 0.5) * settings.contrast + 0.5;
+            r += settings.temperature * 0.08 - settings.tint * 0.02;
+            g += settings.tint * 0.06;
+            b -= settings.temperature * 0.08 + settings.tint * 0.02;
+            const vibranceBoost = settings.vibrance * (1 - Math.min(1, Math.abs(r - luma) + Math.abs(g - luma) + Math.abs(b - luma)));
+            const saturation = settings.saturation + vibranceBoost;
+            r = luma + (r - luma) * saturation;
+            g = luma + (g - luma) * saturation;
+            b = luma + (b - luma) * saturation;
+            const centerX = width <= 1 ? 0 : (x / (width - 1)) * 2 - 1;
+            const centerY = height <= 1 ? 0 : (y / (height - 1)) * 2 - 1;
+            const vignette = 1 - settings.vignette * Math.min(1, Math.max(0, Math.hypot(centerX, centerY) - 0.28) / 1.12);
+            if (vignette < 0.98)
+                vignetteDarkenedPixels += 1;
+            r *= vignette;
+            g *= vignette;
+            b *= vignette;
+            graded[index] = clampByte(r * 255);
+            graded[index + 1] = clampByte(g * 255);
+            graded[index + 2] = clampByte(b * 255);
+            graded[index + 3] = pixels[index + 3] ?? 255;
+            if (Math.abs(graded[index] - (pixels[index] ?? 0)) + Math.abs(graded[index + 1] - (pixels[index + 1] ?? 0)) + Math.abs(graded[index + 2] - (pixels[index + 2] ?? 0)) > 3) {
+                changedPixels += 1;
+            }
+        }
+    }
+    const sharpened = settings.sharpening > 0 ? sharpenPixels(graded, width, height, settings.sharpening) : { pixels: graded, sharpenedPixels: 0 };
+    return {
+        width,
+        height,
+        pixels: sharpened.pixels,
+        changedPixels: Math.max(changedPixels, countChangedRgb(pixels, sharpened.pixels)),
+        vignetteDarkenedPixels,
+        sharpenedPixels: sharpened.sharpenedPixels,
+        settings
+    };
+}
+export const toneMappingPresets = {
+    natural: createToneMappingPreset("natural", "Natural", {
+        operator: "neutral",
+        exposure: 1,
+        autoExposure: false
+    }),
+    cinematic: createToneMappingPreset("cinematic", "Cinematic", {
+        operator: "aces",
+        exposure: 1.2,
+        autoExposure: true,
+        adaptationSpeed: 0.3,
+        temperature: -0.1,
+        contrast: 1.1,
+        saturation: 0.95
+    }),
+    vibrant: createToneMappingPreset("vibrant", "Vibrant", {
+        operator: "uncharted2",
+        exposure: 1.3,
+        autoExposure: false,
+        temperature: 0.1,
+        contrast: 1.15,
+        saturation: 1.2
+    }),
+    realistic: createToneMappingPreset("realistic", "Realistic", {
+        operator: "agx",
+        exposure: 1,
+        autoExposure: true,
+        adaptationSpeed: 0.5
+    }),
+    stylized: createToneMappingPreset("stylized", "Stylized", {
+        operator: "filmic",
+        exposure: 1.4,
+        autoExposure: false,
+        temperature: 0.2,
+        contrast: 1.25,
+        saturation: 1.1
+    })
+};
+export function resolveToneMappingPreset(name, overrides = {}) {
+    const preset = toneMappingPresets[name];
+    return {
+        ...preset,
+        toneMapping: {
+            ...preset.toneMapping,
+            exposure: overrides.exposure ?? preset.toneMapping.exposure,
+            whitePoint: overrides.whitePoint ?? preset.toneMapping.whitePoint,
+            gamma: overrides.gamma ?? preset.toneMapping.gamma,
+            operator: overrides.operator ?? preset.toneMapping.operator,
+            inputColorSpace: overrides.inputColorSpace ?? preset.toneMapping.inputColorSpace,
+            outputColorSpace: overrides.outputColorSpace ?? preset.toneMapping.outputColorSpace
+        },
+        colorGrade: {
+            ...preset.colorGrade,
+            contrast: overrides.contrast ?? preset.colorGrade.contrast,
+            temperature: overrides.temperature ?? preset.colorGrade.temperature,
+            tint: overrides.tint ?? preset.colorGrade.tint,
+            saturation: overrides.saturation ?? preset.colorGrade.saturation,
+            vibrance: overrides.vibrance ?? preset.colorGrade.vibrance,
+            vignette: overrides.vignette ?? preset.colorGrade.vignette,
+            sharpening: overrides.sharpening ?? preset.colorGrade.sharpening
+        },
+        autoExposure: overrides.autoExposure ?? preset.autoExposure,
+        adaptationSpeed: overrides.adaptationSpeed ?? preset.adaptationSpeed,
+        minExposure: overrides.minExposure ?? preset.minExposure,
+        maxExposure: overrides.maxExposure ?? preset.maxExposure
+    };
+}
+export function computeExposureHistogramFromPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Exposure histogram");
+    const inputColorSpace = options.inputColorSpace ?? "linear";
+    const binCount = options.binCount ?? 64;
+    const minLuminance = options.minLuminance ?? 0.001;
+    const maxLuminance = options.maxLuminance ?? 16;
+    validateHistogramOptions(binCount, minLuminance, maxLuminance);
+    const bins = Array.from({ length: binCount }, () => 0);
+    const logMin = Math.log2(minLuminance);
+    const logMax = Math.log2(maxLuminance);
+    let luminanceSum = 0;
+    let minObservedLuminance = Number.POSITIVE_INFINITY;
+    let maxObservedLuminance = 0;
+    for (let index = 0; index < pixels.length; index += 4) {
+        const r = decodeColorByte(pixels[index] ?? 0, inputColorSpace);
+        const g = decodeColorByte(pixels[index + 1] ?? 0, inputColorSpace);
+        const b = decodeColorByte(pixels[index + 2] ?? 0, inputColorSpace);
+        const luminance = Math.max(0, 0.2126 * r + 0.7152 * g + 0.0722 * b);
+        luminanceSum += luminance;
+        minObservedLuminance = Math.min(minObservedLuminance, luminance);
+        maxObservedLuminance = Math.max(maxObservedLuminance, luminance);
+        const safeLuminance = Math.max(minLuminance, Math.min(maxLuminance, luminance));
+        const bin = clampInt(Math.round(((Math.log2(safeLuminance) - logMin) / (logMax - logMin)) * (binCount - 1)), 0, binCount - 1);
+        bins[bin] += 1;
+    }
+    const pixelCount = width * height;
+    return {
+        bins,
+        binCount,
+        minLuminance,
+        maxLuminance,
+        pixelCount,
+        averageLuminance: Number((luminanceSum / pixelCount).toFixed(6)),
+        minObservedLuminance: Number((minObservedLuminance === Number.POSITIVE_INFINITY ? 0 : minObservedLuminance).toFixed(6)),
+        maxObservedLuminance: Number(maxObservedLuminance.toFixed(6))
+    };
+}
+export function computeAutoExposureFromHistogram(histogram, options = {}) {
+    if (histogram.pixelCount <= 0 || histogram.bins.length !== histogram.binCount) {
+        throw new Error("Auto exposure histogram must contain bins and a positive pixel count.");
+    }
+    const targetLuminance = options.targetLuminance ?? 0.18;
+    const previousExposure = options.previousExposure ?? 1;
+    const adaptationSpeed = options.adaptationSpeed ?? 1;
+    const deltaTimeSeconds = options.deltaTimeSeconds ?? 1 / 60;
+    const minExposure = options.minExposure ?? 0.1;
+    const maxExposure = options.maxExposure ?? 10;
+    validateRange(targetLuminance, 0.001, 4, "Auto exposure targetLuminance");
+    validateRange(previousExposure, 0.001, 128, "Auto exposure previousExposure");
+    validateRange(adaptationSpeed, 0, 1, "Auto exposure adaptationSpeed");
+    validateRange(deltaTimeSeconds, 0, 10, "Auto exposure deltaTimeSeconds");
+    validateRange(minExposure, 0.001, 128, "Auto exposure minExposure");
+    validateRange(maxExposure, minExposure, 128, "Auto exposure maxExposure");
+    const averageLuminance = histogram.averageLuminance > 0 ? histogram.averageLuminance : histogramAverageFromBins(histogram);
+    const unclampedTarget = targetLuminance / Math.max(0.001, averageLuminance);
+    const targetExposure = Math.max(minExposure, Math.min(maxExposure, unclampedTarget));
+    const adaptationRate = 1 - Math.pow(1 - adaptationSpeed, deltaTimeSeconds * 60);
+    const exposure = previousExposure + (targetExposure - previousExposure) * adaptationRate;
+    return {
+        exposure: Number(exposure.toFixed(6)),
+        targetExposure: Number(targetExposure.toFixed(6)),
+        averageLuminance: Number(averageLuminance.toFixed(6)),
+        adaptationRate: Number(adaptationRate.toFixed(6)),
+        clamped: targetExposure !== unclampedTarget
+    };
+}
+export function applyToneMappingPreset(pixels, width, height, presetName, options = {}) {
+    const preset = resolveToneMappingPreset(presetName, options);
+    const histogram = computeExposureHistogramFromPixels(pixels, width, height, {
+        inputColorSpace: preset.toneMapping.inputColorSpace
+    });
+    const autoExposure = preset.autoExposure
+        ? computeAutoExposureFromHistogram(histogram, {
+            targetLuminance: options.targetLuminance,
+            previousExposure: options.previousExposure ?? preset.toneMapping.exposure,
+            adaptationSpeed: options.adaptationSpeed ?? preset.adaptationSpeed,
+            deltaTimeSeconds: options.deltaTimeSeconds,
+            minExposure: options.minExposure ?? preset.minExposure,
+            maxExposure: options.maxExposure ?? preset.maxExposure
+        })
+        : undefined;
+    const toneMapped = toneMapPixels(pixels, width, height, {
+        ...preset.toneMapping,
+        exposure: autoExposure?.exposure ?? preset.toneMapping.exposure
+    });
+    const colorGraded = colorGradePixels(toneMapped.pixels, width, height, preset.colorGrade);
+    return {
+        width,
+        height,
+        preset: presetName,
+        pixels: colorGraded.pixels,
+        toneMapped,
+        colorGraded,
+        histogram,
+        autoExposure
+    };
+}
+export function chromaticAberrationPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Chromatic aberration");
+    const strength = options.strength ?? 0.35;
+    validateRange(strength, 0, 2, "Chromatic aberration strength");
+    const output = new Uint8Array(pixels);
+    let changedPixels = 0;
+    let maxChannelOffsetPixels = 0;
+    const centerX = (width - 1) / 2;
+    const centerY = (height - 1) / 2;
+    const maxDistance = Math.max(1, Math.hypot(centerX, centerY));
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = (y * width + x) * 4;
+            const directionX = centerX === 0 ? 0 : (x - centerX) / maxDistance;
+            const directionY = centerY === 0 ? 0 : (y - centerY) / maxDistance;
+            const radial = Math.min(1, Math.hypot(x - centerX, y - centerY) / maxDistance);
+            const offset = Math.round(strength * radial * 2);
+            maxChannelOffsetPixels = Math.max(maxChannelOffsetPixels, offset);
+            const redX = clampInt(Math.round(x + directionX * offset), 0, width - 1);
+            const redY = clampInt(Math.round(y + directionY * offset), 0, height - 1);
+            const blueX = clampInt(Math.round(x - directionX * offset), 0, width - 1);
+            const blueY = clampInt(Math.round(y - directionY * offset), 0, height - 1);
+            output[index] = channelAt(pixels, width, height, redX, redY, 0);
+            output[index + 1] = pixels[index + 1] ?? 0;
+            output[index + 2] = channelAt(pixels, width, height, blueX, blueY, 2);
+            output[index + 3] = pixels[index + 3] ?? 255;
+            if (Math.abs(output[index] - (pixels[index] ?? 0)) + Math.abs(output[index + 2] - (pixels[index + 2] ?? 0)) > 2) {
+                changedPixels += 1;
+            }
+        }
+    }
+    return { width, height, pixels: output, changedPixels, maxChannelOffsetPixels };
+}
+export function outlinePixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Outline");
+    const outlineWidth = options.width ?? 1;
+    const threshold = options.threshold ?? 0.22;
+    const opacity = options.opacity ?? 0.85;
+    const color = options.color ?? [255, 188, 64, 255];
+    if (!Number.isInteger(outlineWidth) || outlineWidth < 1 || outlineWidth > 6) {
+        throw new Error("Outline width must be an integer in [1, 6].");
+    }
+    validateRange(threshold, 0, 4, "Outline threshold");
+    validateRange(opacity, 0, 1, "Outline opacity");
+    validateOutlineColor(color);
+    const edgeMask = new Uint8Array(width * height);
+    const gradientBound = createOutlineGradientBound(threshold).numberValue;
+    let maxGradientNumerator = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const { gx, gy } = sobelLumaNumeratorGradient(pixels, width, height, x, y);
+            const squared = gx * gx + gy * gy;
+            if (squared > maxGradientNumerator)
+                maxGradientNumerator = squared;
+            if (outlineEdgeExceedsBound(gx, gy, gradientBound)) {
+                edgeMask[y * width + x] = 255;
+            }
+        }
+    }
+    const maxGradient = Math.sqrt(maxGradientNumerator) / OUTLINE_LUMA_SCALE;
+    const outlineMask = dilateMask(edgeMask, width, height, outlineWidth);
+    const output = new Uint8Array(pixels);
+    let outlinedPixels = 0;
+    let changedPixels = 0;
+    const colorAlpha = (color[3] ?? 255) / 255;
+    const alpha = opacity * colorAlpha;
+    for (let index = 0; index < outlineMask.length; index += 1) {
+        if (outlineMask[index] === 0)
+            continue;
+        outlinedPixels += 1;
+        const pixelIndex = index * 4;
+        const beforeRed = pixels[pixelIndex] ?? 0;
+        const beforeGreen = pixels[pixelIndex + 1] ?? 0;
+        const beforeBlue = pixels[pixelIndex + 2] ?? 0;
+        output[pixelIndex] = clampByte(beforeRed * (1 - alpha) + color[0] * alpha);
+        output[pixelIndex + 1] = clampByte(beforeGreen * (1 - alpha) + color[1] * alpha);
+        output[pixelIndex + 2] = clampByte(beforeBlue * (1 - alpha) + color[2] * alpha);
+        output[pixelIndex + 3] = pixels[pixelIndex + 3] ?? 255;
+        if (Math.abs(output[pixelIndex] - beforeRed) + Math.abs(output[pixelIndex + 1] - beforeGreen) + Math.abs(output[pixelIndex + 2] - beforeBlue) > 3) {
+            changedPixels += 1;
+        }
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        outlineMask,
+        outlinedPixels,
+        changedPixels,
+        maxGradient: Number(maxGradient.toFixed(6)),
+        method: "sobel-luma"
+    };
+}
+export function filmGrainPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Film grain");
+    const intensity = options.intensity ?? 0.08;
+    const seed = options.seed ?? 1;
+    const monochrome = options.monochrome ?? true;
+    validateRange(intensity, 0, 1, "Film grain intensity");
+    if (!Number.isInteger(seed)) {
+        throw new Error("Film grain seed must be an integer.");
+    }
+    const output = new Uint8Array(pixels);
+    let changedPixels = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = (y * width + x) * 4;
+            const luma = ((pixels[index] ?? 0) * 0.2126 + (pixels[index + 1] ?? 0) * 0.7152 + (pixels[index + 2] ?? 0) * 0.0722) / 255;
+            const grain = (noise2d(x, y, seed) +
+                noise2d(Math.floor(x / 2), Math.floor(y / 2), seed + 97) +
+                noise2d(x + 19, y + 31, seed + 193)) / 3 * 2 - 1;
+            const amplitude = intensity * 84 * (0.35 + 0.65 * (1 - luma));
+            const redGrain = grain;
+            const greenGrain = monochrome ? grain : grain * 0.72 + (noise2d(x, y, seed + 17) * 2 - 1) * 0.28;
+            const blueGrain = monochrome ? grain : grain * 0.72 + (noise2d(x, y, seed + 31) * 2 - 1) * 0.28;
+            output[index] = clampByte((pixels[index] ?? 0) + redGrain * amplitude);
+            output[index + 1] = clampByte((pixels[index + 1] ?? 0) + greenGrain * amplitude);
+            output[index + 2] = clampByte((pixels[index + 2] ?? 0) + blueGrain * amplitude);
+            output[index + 3] = pixels[index + 3] ?? 255;
+            if (Math.abs(output[index] - (pixels[index] ?? 0)) + Math.abs(output[index + 1] - (pixels[index + 1] ?? 0)) + Math.abs(output[index + 2] - (pixels[index + 2] ?? 0)) > 0) {
+                changedPixels += 1;
+            }
+        }
+    }
+    return { width, height, pixels: output, changedPixels, seed, intensity, monochrome };
+}
+export function depthOfFieldPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "Depth of field");
+    const focusDepth = options.focusDepth ?? 0.5;
+    const focusRange = options.focusRange ?? 0.12;
+    const maxRadius = options.maxRadius ?? 2;
+    validateRange(focusDepth, 0, 1, "Depth of field focusDepth");
+    validateRange(focusRange, 0.001, 1, "Depth of field focusRange");
+    if (!Number.isInteger(maxRadius) || maxRadius < 0 || maxRadius > 8) {
+        throw new Error("Depth of field maxRadius must be an integer in [0, 8].");
+    }
+    const depthTexture = requireDepthTextureBinding(options.depth, "Depth of field");
+    if (depthTexture.width !== width || depthTexture.height !== height) {
+        throw new Error("Depth of field depth texture dimensions must match source pixels.");
+    }
+    const output = new Uint8Array(pixels);
+    let blurredPixels = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const depth = depthAt(depthTexture, x, y);
+            const radius = Math.min(maxRadius, Math.round(Math.max(0, Math.abs(depth - focusDepth) - focusRange) / Math.max(focusRange, 0.001) * maxRadius));
+            if (radius === 0)
+                continue;
+            blurredPixels += 1;
+            const index = (y * width + x) * 4;
+            let red = 0;
+            let green = 0;
+            let blue = 0;
+            let samples = 0;
+            for (let offsetY = -radius; offsetY <= radius; offsetY += 1) {
+                for (let offsetX = -radius; offsetX <= radius; offsetX += 1) {
+                    if (Math.hypot(offsetX, offsetY) > radius + 0.01)
+                        continue;
+                    const sampleX = clampInt(x + offsetX, 0, width - 1);
+                    const sampleY = clampInt(y + offsetY, 0, height - 1);
+                    const sampleIndex = (sampleY * width + sampleX) * 4;
+                    red += pixels[sampleIndex] ?? 0;
+                    green += pixels[sampleIndex + 1] ?? 0;
+                    blue += pixels[sampleIndex + 2] ?? 0;
+                    samples += 1;
+                }
+            }
+            output[index] = clampByte(red / samples);
+            output[index + 1] = clampByte(green / samples);
+            output[index + 2] = clampByte(blue / samples);
+            output[index + 3] = pixels[index + 3] ?? 255;
+        }
+    }
+    return { width, height, pixels: output, blurredPixels, maxBlurRadius: maxRadius, focusDepth, focusRange };
+}
+export function volumetricLightPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Volumetric light");
+    const depth = requireDepthTextureBinding(options.depth, "Volumetric light");
+    if (depth.width !== width || depth.height !== height) {
+        throw new Error("Volumetric light depth texture dimensions must match source pixels.");
+    }
+    const lightPosition = options.lightPosition ?? [0.5, 0.18];
+    if (lightPosition.length !== 2 || !lightPosition.every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) {
+        throw new RangeError("Volumetric light position must contain two finite normalized coordinates.");
+    }
+    const color = options.color ?? [1, 0.88, 0.62];
+    if (color.length !== 3 || !color.every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) {
+        throw new RangeError("Volumetric light color must contain three finite values within [0, 1].");
+    }
+    const density = numberInRange(options.density ?? 0.9, 0.01, 2, "Volumetric light density");
+    const decay = numberInRange(options.decay ?? 0.96, 0, 1, "Volumetric light decay");
+    const weight = numberInRange(options.weight ?? 0.18, 0, 2, "Volumetric light weight");
+    const exposure = numberInRange(options.exposure ?? 0.72, 0, 4, "Volumetric light exposure");
+    const samples = integerNumberInRange(options.samples ?? 32, 4, 128, "Volumetric light samples");
+    const occlusionThreshold = numberInRange(options.occlusionThreshold ?? 0.985, 0, 1, "Volumetric light occlusionThreshold");
+    const output = new Uint8Array(pixels);
+    const lightX = lightPosition[0] * (width - 1);
+    const lightY = lightPosition[1] * (height - 1);
+    let changedPixels = 0;
+    let occludedSamples = 0;
+    let maxScattering = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const deltaX = ((lightX - x) / samples) * density;
+            const deltaY = ((lightY - y) / samples) * density;
+            let sampleX = x;
+            let sampleY = y;
+            let illuminationDecay = 1;
+            let scattering = 0;
+            for (let sample = 0; sample < samples; sample += 1) {
+                sampleX += deltaX;
+                sampleY += deltaY;
+                const sx = clampInt(Math.round(sampleX), 0, width - 1);
+                const sy = clampInt(Math.round(sampleY), 0, height - 1);
+                const offset = (sy * width + sx) * 4;
+                const luminance = ((pixels[offset] ?? 0) * 0.2126 + (pixels[offset + 1] ?? 0) * 0.7152 + (pixels[offset + 2] ?? 0) * 0.0722) / 255;
+                const source = Math.max(0, luminance - 0.42) / 0.58;
+                const sampleDepth = depthAt(depth, sx, sy);
+                const visible = sampleDepth >= occlusionThreshold || source > 0.05 ? 1 : 0;
+                if (visible === 0)
+                    occludedSamples += 1;
+                scattering += source * visible * illuminationDecay * weight;
+                illuminationDecay *= decay;
+            }
+            const boost = scattering * exposure;
+            maxScattering = Math.max(maxScattering, boost);
+            const offset = (y * width + x) * 4;
+            const beforeR = pixels[offset] ?? 0;
+            const beforeG = pixels[offset + 1] ?? 0;
+            const beforeB = pixels[offset + 2] ?? 0;
+            // A5: ordered Bayer dither (one LSB) so smooth inscatter gradients do
+            // not band in 8-bit output. Off by default to preserve legacy bytes.
+            const dither = options.dither === true ? bayer2(x, y) : 0;
+            output[offset] = clampByte(beforeR + color[0] * boost * 255 + dither);
+            output[offset + 1] = clampByte(beforeG + color[1] * boost * 255 + dither);
+            output[offset + 2] = clampByte(beforeB + color[2] * boost * 255 + dither);
+            if (output[offset] !== beforeR || output[offset + 1] !== beforeG || output[offset + 2] !== beforeB) {
+                changedPixels += 1;
+            }
+        }
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        changedPixels,
+        occludedSamples,
+        maxScattering: Number(maxScattering.toFixed(5)),
+        sampleCount: samples,
+        method: "depth-aware-radial-participating-media"
+    };
+}
+export function motionBlurPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "Motion blur");
+    const samples = options.samples ?? 5;
+    const scale = options.scale ?? 1;
+    if (!Number.isInteger(samples) || samples < 2 || samples > 16) {
+        throw new Error("Motion blur samples must be an integer in [2, 16].");
+    }
+    if (!Number.isFinite(scale) || scale < 0 || scale > 8) {
+        throw new Error("Motion blur scale must be finite in [0, 8].");
+    }
+    if (options.velocity.length !== width * height * 2) {
+        throw new Error("Motion blur velocity must contain width * height * 2 float samples.");
+    }
+    const output = new Uint8Array(pixels);
+    let blurredPixels = 0;
+    let maxVelocityPixels = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const velocityIndex = (y * width + x) * 2;
+            const vx = (options.velocity[velocityIndex] ?? 0) * scale;
+            const vy = (options.velocity[velocityIndex + 1] ?? 0) * scale;
+            const velocityPixels = Math.hypot(vx, vy);
+            maxVelocityPixels = Math.max(maxVelocityPixels, velocityPixels);
+            if (velocityPixels < 0.01)
+                continue;
+            blurredPixels += 1;
+            const index = (y * width + x) * 4;
+            let red = 0;
+            let green = 0;
+            let blue = 0;
+            for (let sample = 0; sample < samples; sample += 1) {
+                const t = samples === 1 ? 0 : sample / (samples - 1) - 0.5;
+                const sampleX = clampInt(Math.round(x - vx * t), 0, width - 1);
+                const sampleY = clampInt(Math.round(y - vy * t), 0, height - 1);
+                const sampleIndex = (sampleY * width + sampleX) * 4;
+                red += pixels[sampleIndex] ?? 0;
+                green += pixels[sampleIndex + 1] ?? 0;
+                blue += pixels[sampleIndex + 2] ?? 0;
+            }
+            output[index] = clampByte(red / samples);
+            output[index + 1] = clampByte(green / samples);
+            output[index + 2] = clampByte(blue / samples);
+            output[index + 3] = pixels[index + 3] ?? 255;
+        }
+    }
+    return { width, height, pixels: output, blurredPixels, samples, maxVelocityPixels };
+}
+export function ssaoPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "SSAO");
+    const depthTexture = requireDepthTextureBinding(options.depth, "SSAO");
+    if (depthTexture.width !== width || depthTexture.height !== height) {
+        throw new Error("SSAO depth texture dimensions must match source pixels.");
+    }
+    const rawRadius = options.radius ?? 2;
+    const radius = rawRadius > 0 && rawRadius < 1
+        ? Math.max(1, Math.min(8, Math.round(rawRadius * 8)))
+        : rawRadius;
+    const intensity = options.intensity ?? 0.38;
+    const bias = options.bias ?? 0.015;
+    if (!Number.isInteger(radius) || radius < 1 || radius > 8) {
+        throw new Error("SSAO radius must be an integer in [1, 8].");
+    }
+    validateRange(intensity, 0, 2, "SSAO intensity");
+    validateRange(bias, 0, 0.25, "SSAO bias");
+    const output = new Uint8Array(pixels);
+    let occludedPixels = 0;
+    let occlusionTotal = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const centerDepth = depthAt(depthTexture, x, y);
+            let occlusion = 0;
+            let samples = 0;
+            for (let offsetY = -radius; offsetY <= radius; offsetY += radius) {
+                for (let offsetX = -radius; offsetX <= radius; offsetX += radius) {
+                    if (offsetX === 0 && offsetY === 0)
+                        continue;
+                    const sampleDepth = depthAt(depthTexture, clampInt(x + offsetX, 0, width - 1), clampInt(y + offsetY, 0, height - 1));
+                    occlusion += Math.max(0, Math.min(1, (centerDepth - sampleDepth - bias) / (0.14 + radius * 0.04)));
+                    samples += 1;
+                }
+            }
+            const factor = Math.max(0.18, 1 - (occlusion / Math.max(1, samples)) * intensity * 0.72);
+            if (factor < 0.995)
+                occludedPixels += 1;
+            occlusionTotal += 1 - factor;
+            const index = (y * width + x) * 4;
+            output[index] = clampByte((pixels[index] ?? 0) * factor);
+            output[index + 1] = clampByte((pixels[index + 1] ?? 0) * factor);
+            output[index + 2] = clampByte((pixels[index + 2] ?? 0) * factor);
+            output[index + 3] = pixels[index + 3] ?? 255;
+        }
+    }
+    return { width, height, pixels: output, occludedPixels, averageOcclusion: Number((occlusionTotal / (width * height)).toFixed(6)), radius, intensity };
+}
+export function contactShadowPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "Contact shadow");
+    const depthTexture = requireDepthTextureBinding(options.depth, "Contact shadow");
+    if (depthTexture.width !== width || depthTexture.height !== height) {
+        throw new Error("Contact shadow depth texture dimensions must match source pixels.");
+    }
+    const radius = options.radius ?? 4;
+    const intensity = options.intensity ?? 0.72;
+    const bias = options.bias ?? 0.008;
+    const thickness = options.thickness ?? 0.12;
+    if (!Number.isInteger(radius) || radius < 1 || radius > 16) {
+        throw new Error("Contact shadow radius must be an integer in [1, 16].");
+    }
+    validateRange(intensity, 0, 2, "Contact shadow intensity");
+    validateRange(bias, 0, 0.25, "Contact shadow bias");
+    validateRange(thickness, 0.005, 1, "Contact shadow thickness");
+    const direction = normalizeContactShadowDirection(options.direction ?? [0.35, 0.8]);
+    const output = new Uint8Array(pixels);
+    let contactPixels = 0;
+    let darkeningTotal = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const receiverDepth = depthAt(depthTexture, x, y);
+            let contact = 0;
+            for (let step = 1; step <= radius; step += 1) {
+                const longitudinal = step / radius;
+                const lateralRadius = Math.max(1, Math.round(radius * 0.28 * (1 - longitudinal * 0.35)));
+                for (let side = -lateralRadius; side <= lateralRadius; side += 1) {
+                    const offsetX = direction[0] * step + -direction[1] * side;
+                    const offsetY = direction[1] * step + direction[0] * side;
+                    const sampleX = clampInt(Math.round(x - offsetX), 0, width - 1);
+                    const sampleY = clampInt(Math.round(y - offsetY), 0, height - 1);
+                    const casterDepth = depthAt(depthTexture, sampleX, sampleY);
+                    const depthGap = receiverDepth - casterDepth - bias;
+                    if (depthGap <= 0 || depthGap > thickness)
+                        continue;
+                    const spatialFalloff = Math.max(0, 1 - longitudinal);
+                    const lateralFalloff = Math.max(0, 1 - Math.abs(side) / (lateralRadius + 1));
+                    const depthFalloff = 1 - depthGap / thickness;
+                    contact = Math.max(contact, spatialFalloff * lateralFalloff * depthFalloff);
+                }
+            }
+            if (contact <= 0)
+                continue;
+            const shadow = Math.min(0.82, contact * intensity * 0.72);
+            const factor = 1 - shadow;
+            const index = (y * width + x) * 4;
+            output[index] = clampByte((pixels[index] ?? 0) * factor);
+            output[index + 1] = clampByte((pixels[index + 1] ?? 0) * factor);
+            output[index + 2] = clampByte((pixels[index + 2] ?? 0) * factor);
+            output[index + 3] = pixels[index + 3] ?? 255;
+            contactPixels += 1;
+            darkeningTotal += shadow;
+        }
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        contactPixels,
+        averageContactDarkening: Number((darkeningTotal / Math.max(1, contactPixels)).toFixed(6)),
+        radius,
+        intensity,
+        mode: "screen-space-depth-contact"
+    };
+}
+export function ssrPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "SSR");
+    const depthTexture = requireDepthTextureBinding(options.depth, "SSR");
+    if (depthTexture.width !== width || depthTexture.height !== height) {
+        throw new Error("SSR depth texture dimensions must match source pixels.");
+    }
+    const intensity = options.intensity ?? 0.32;
+    const maxDistance = options.maxDistance ?? 16;
+    validateRange(intensity, 0, 2, "SSR intensity");
+    if (!Number.isInteger(maxDistance) || maxDistance < 1 || maxDistance > 64) {
+        throw new Error("SSR maxDistance must be an integer in [1, 64].");
+    }
+    const output = new Uint8Array(pixels);
+    let reflectedPixels = 0;
+    let maxReflectionBoost = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const depth = depthAt(depthTexture, x, y);
+            const rayDistance = Math.max(1, Math.round((1 - depth) * maxDistance));
+            const sampleX = clampInt(x + (x < width / 2 ? rayDistance : -rayDistance), 0, width - 1);
+            const sampleY = clampInt(height - 1 - y, 0, height - 1);
+            const sourceIndex = (sampleY * width + sampleX) * 4;
+            const targetIndex = (y * width + x) * 4;
+            const sourceLuma = ((pixels[sourceIndex] ?? 0) + (pixels[sourceIndex + 1] ?? 0) + (pixels[sourceIndex + 2] ?? 0)) / (3 * 255);
+            if (sourceLuma < 0.18 || depth > 0.92)
+                continue;
+            const boost = sourceLuma * intensity * (1 - depth);
+            maxReflectionBoost = Math.max(maxReflectionBoost, boost);
+            reflectedPixels += 1;
+            output[targetIndex] = clampByte((pixels[targetIndex] ?? 0) + (pixels[sourceIndex] ?? 0) * boost);
+            output[targetIndex + 1] = clampByte((pixels[targetIndex + 1] ?? 0) + (pixels[sourceIndex + 1] ?? 0) * boost);
+            output[targetIndex + 2] = clampByte((pixels[targetIndex + 2] ?? 0) + (pixels[sourceIndex + 2] ?? 0) * boost);
+            output[targetIndex + 3] = pixels[targetIndex + 3] ?? 255;
+        }
+    }
+    return { width, height, pixels: output, reflectedPixels, maxReflectionBoost: Number(maxReflectionBoost.toFixed(6)), intensity, maxDistance };
+}
+export function taaPixels(pixels, width, height, options) {
+    validatePixelBuffer(pixels, width, height, "TAA");
+    if (options.history.byteLength !== pixels.byteLength) {
+        throw new Error("TAA history must contain width * height * 4 RGBA bytes.");
+    }
+    const blend = options.blend ?? 0.18;
+    validateRange(blend, 0, 0.95, "TAA blend");
+    const output = new Uint8Array(pixels.byteLength);
+    let blendedPixels = 0;
+    for (let index = 0; index < pixels.length; index += 4) {
+        output[index] = clampByte((pixels[index] ?? 0) * (1 - blend) + (options.history[index] ?? 0) * blend);
+        output[index + 1] = clampByte((pixels[index + 1] ?? 0) * (1 - blend) + (options.history[index + 1] ?? 0) * blend);
+        output[index + 2] = clampByte((pixels[index + 2] ?? 0) * (1 - blend) + (options.history[index + 2] ?? 0) * blend);
+        output[index + 3] = pixels[index + 3] ?? 255;
+        if (Math.abs(output[index] - (pixels[index] ?? 0)) + Math.abs(output[index + 1] - (pixels[index + 1] ?? 0)) + Math.abs(output[index + 2] - (pixels[index + 2] ?? 0)) > 0) {
+            blendedPixels += 1;
+        }
+    }
+    return { width, height, pixels: output, blendedPixels, blend };
+}
+export function bloomPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Bloom");
+    const threshold = options.threshold ?? 0.75;
+    const intensity = options.intensity ?? 0.35;
+    const radius = options.radius ?? 1;
+    validateBloomOptions(threshold, intensity, radius);
+    const { pixels: brightPixels, brightPixelCount, brightEnergy } = extractBloomBrightPixels(pixels, width, height, threshold);
+    const horizontalBlurPixels = blurBloomPixelsHorizontal(brightPixels, width, height, radius);
+    const verticalBlurPixels = blurBloomPixelsVertical(horizontalBlurPixels, width, height, radius);
+    const composite = compositeBloomPixels(pixels, verticalBlurPixels, width, height, intensity, brightPixels);
+    return {
+        width,
+        height,
+        pixels: composite.pixels,
+        brightPixels,
+        horizontalBlurPixels,
+        verticalBlurPixels,
+        brightPixelCount,
+        brightEnergy,
+        maxNeighborBoost: composite.maxNeighborBoost,
+        changedPixels: composite.changedPixels,
+        maxChannelDelta: composite.maxChannelDelta,
+        pipeline: ["bright-extract", "horizontal-blur", "vertical-blur", "composite"]
+    };
+}
+export function extractBloomBrightPixels(pixels, width, height, threshold) {
+    validatePixelBuffer(pixels, width, height, "Bloom bright extraction");
+    if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+        throw new Error("Bloom threshold must be finite and in [0, 1].");
+    }
+    const brightPixels = new Uint8Array(pixels.byteLength);
+    let brightPixelCount = 0;
+    let brightEnergy = 0;
+    for (let index = 0; index < pixels.length; index += 4) {
+        const luma = (0.2126 * pixels[index] + 0.7152 * pixels[index + 1] + 0.0722 * pixels[index + 2]) / 255;
+        if (luma >= threshold) {
+            brightPixelCount += 1;
+            brightEnergy += luma;
+            brightPixels[index] = pixels[index];
+            brightPixels[index + 1] = pixels[index + 1];
+            brightPixels[index + 2] = pixels[index + 2];
+            brightPixels[index + 3] = pixels[index + 3];
+        }
+    }
+    return { pixels: brightPixels, brightPixelCount, brightEnergy };
+}
+/**
+ * Separable Gaussian weights shared by the CPU bloom kernels and the native
+ * WebGL2 `webgl2-bloom-blur` program, so the byte kernels remain the exact
+ * mirror of the device pass.
+ *
+ * The 3.0.1 parity contract (muse3jsparity-PRD, native bloom item 2) upgraded
+ * the native pass to a separable Gaussian; the CPU mirror was left as a uniform
+ * box average, which made the native-vs-CPU equality proof in
+ * tests/browser/native-outline-pixel.spec.ts unsatisfiable. `sigma`,
+ * `coefficient` and the truncation at 16 taps are the same expressions the
+ * shader uses.
+ */
+export function bloomBlurWeights(radius) {
+    const sigma = Math.max(radius / 3, 0.5);
+    const coefficient = 0.39894 / sigma;
+    const weights = [Math.fround(coefficient)];
+    let weightSum = Math.fround(coefficient);
+    for (let offset = 1; offset <= 16; offset += 1) {
+        if (offset > radius) {
+            weights.push(0);
+            continue;
+        }
+        const weight = Math.fround(coefficient * Math.exp(-0.5 * offset * offset / (sigma * sigma)));
+        weights.push(weight);
+        weightSum = Math.fround(weightSum + Math.fround(2 * weight));
+    }
+    return { weights, weightSum: Math.max(weightSum, 0.000001) };
+}
+export function blurBloomPixelsHorizontal(pixels, width, height, radius) {
+    validatePixelBuffer(pixels, width, height, "Bloom horizontal blur");
+    validateBloomBlurRadius(radius);
+    const { weights, weightSum } = bloomBlurWeights(radius);
+    const output = new Uint8Array(pixels.byteLength);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const targetIndex = (y * width + x) * 4;
+            const centerIndex = (y * width + x) * 4;
+            let red = pixels[centerIndex] * weights[0];
+            let green = pixels[centerIndex + 1] * weights[0];
+            let blue = pixels[centerIndex + 2] * weights[0];
+            let alpha = pixels[centerIndex + 3] * weights[0];
+            for (let offsetX = 1; offsetX <= radius; offsetX += 1) {
+                const weight = weights[offsetX];
+                const lowIndex = (y * width + clampInt(x - offsetX, 0, width - 1)) * 4;
+                const highIndex = (y * width + clampInt(x + offsetX, 0, width - 1)) * 4;
+                red += (pixels[lowIndex] + pixels[highIndex]) * weight;
+                green += (pixels[lowIndex + 1] + pixels[highIndex + 1]) * weight;
+                blue += (pixels[lowIndex + 2] + pixels[highIndex + 2]) * weight;
+                alpha += (pixels[lowIndex + 3] + pixels[highIndex + 3]) * weight;
+            }
+            output[targetIndex] = clampByte(red / weightSum);
+            output[targetIndex + 1] = clampByte(green / weightSum);
+            output[targetIndex + 2] = clampByte(blue / weightSum);
+            output[targetIndex + 3] = clampByte(alpha / weightSum);
+        }
+    }
+    return output;
+}
+export function blurBloomPixelsVertical(pixels, width, height, radius) {
+    validatePixelBuffer(pixels, width, height, "Bloom vertical blur");
+    validateBloomBlurRadius(radius);
+    const { weights, weightSum } = bloomBlurWeights(radius);
+    const output = new Uint8Array(pixels.byteLength);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const targetIndex = (y * width + x) * 4;
+            const centerIndex = (y * width + x) * 4;
+            let red = pixels[centerIndex] * weights[0];
+            let green = pixels[centerIndex + 1] * weights[0];
+            let blue = pixels[centerIndex + 2] * weights[0];
+            let alpha = pixels[centerIndex + 3] * weights[0];
+            for (let offsetY = 1; offsetY <= radius; offsetY += 1) {
+                const weight = weights[offsetY];
+                const lowIndex = (clampInt(y - offsetY, 0, height - 1) * width + x) * 4;
+                const highIndex = (clampInt(y + offsetY, 0, height - 1) * width + x) * 4;
+                red += (pixels[lowIndex] + pixels[highIndex]) * weight;
+                green += (pixels[lowIndex + 1] + pixels[highIndex + 1]) * weight;
+                blue += (pixels[lowIndex + 2] + pixels[highIndex + 2]) * weight;
+                alpha += (pixels[lowIndex + 3] + pixels[highIndex + 3]) * weight;
+            }
+            output[targetIndex] = clampByte(red / weightSum);
+            output[targetIndex + 1] = clampByte(green / weightSum);
+            output[targetIndex + 2] = clampByte(blue / weightSum);
+            output[targetIndex + 3] = clampByte(alpha / weightSum);
+        }
+    }
+    return output;
+}
+export function compositeBloomPixels(sourcePixels, blurredPixels, width, height, intensity, brightPixels) {
+    validatePixelBuffer(sourcePixels, width, height, "Bloom composite source");
+    validatePixelBuffer(blurredPixels, width, height, "Bloom composite blur");
+    if (brightPixels)
+        validatePixelBuffer(brightPixels, width, height, "Bloom composite bright source");
+    if (!Number.isFinite(intensity) || intensity < 0) {
+        throw new Error("Bloom intensity must be finite and non-negative.");
+    }
+    const output = new Uint8Array(sourcePixels);
+    let maxNeighborBoost = 0;
+    let changedPixels = 0;
+    let maxChannelDelta = 0;
+    for (let index = 0; index < sourcePixels.length; index += 4) {
+        const previousRed = output[index];
+        const previousGreen = output[index + 1];
+        const previousBlue = output[index + 2];
+        const redBoost = blurredPixels[index] * intensity;
+        const greenBoost = blurredPixels[index + 1] * intensity;
+        const blueBoost = blurredPixels[index + 2] * intensity;
+        output[index] = clampByte(output[index] + redBoost);
+        output[index + 1] = clampByte(output[index + 1] + greenBoost);
+        output[index + 2] = clampByte(output[index + 2] + blueBoost);
+        output[index + 3] = sourcePixels[index + 3];
+        const redDelta = Math.abs(output[index] - previousRed);
+        const greenDelta = Math.abs(output[index + 1] - previousGreen);
+        const blueDelta = Math.abs(output[index + 2] - previousBlue);
+        const pixelDelta = Math.max(redDelta, greenDelta, blueDelta);
+        if (pixelDelta > 0) {
+            changedPixels += 1;
+            maxChannelDelta = Math.max(maxChannelDelta, pixelDelta);
+        }
+        if (!brightPixels || (brightPixels[index] === 0 && brightPixels[index + 1] === 0 && brightPixels[index + 2] === 0)) {
+            maxNeighborBoost = Math.max(maxNeighborBoost, redBoost, greenBoost, blueBoost);
+        }
+    }
+    return { pixels: output, maxNeighborBoost, changedPixels, maxChannelDelta };
+}
+export function bloomFloatPixels(pixels, width, height, options = {}) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error("HDR bloom dimensions must be positive integers.");
+    }
+    if (pixels.length !== width * height * 4) {
+        throw new Error("HDR bloom input must contain width * height * 4 RGBA float values.");
+    }
+    const threshold = options.threshold ?? 0.75;
+    const intensity = options.intensity ?? 0.35;
+    const radius = options.radius ?? 1;
+    validateBloomOptions(threshold, intensity, radius);
+    const brightPixels = new Float32Array(pixels.length);
+    let brightPixelCount = 0;
+    let brightEnergy = 0;
+    let maxInputValue = 0;
+    for (let index = 0; index < pixels.length; index += 4) {
+        const red = finiteHdrChannel(pixels[index], index);
+        const green = finiteHdrChannel(pixels[index + 1], index + 1);
+        const blue = finiteHdrChannel(pixels[index + 2], index + 2);
+        const alpha = finiteHdrChannel(pixels[index + 3], index + 3);
+        maxInputValue = Math.max(maxInputValue, red, green, blue);
+        const luma = 0.2126 * red + 0.7152 * green + 0.0722 * blue;
+        if (luma >= threshold) {
+            brightPixelCount += 1;
+            brightEnergy += luma;
+            brightPixels[index] = red;
+            brightPixels[index + 1] = green;
+            brightPixels[index + 2] = blue;
+            brightPixels[index + 3] = alpha;
+        }
+    }
+    const horizontalBlurPixels = blurBloomFloatPixelsHorizontal(brightPixels, width, height, radius);
+    const verticalBlurPixels = blurBloomFloatPixelsVertical(horizontalBlurPixels, width, height, radius);
+    const composite = compositeBloomFloatPixels(pixels, verticalBlurPixels, width, height, intensity, brightPixels);
+    return {
+        width,
+        height,
+        pixels: composite.pixels,
+        brightPixels,
+        horizontalBlurPixels,
+        verticalBlurPixels,
+        brightPixelCount,
+        brightEnergy: Number(brightEnergy.toFixed(6)),
+        maxNeighborBoost: Number(composite.maxNeighborBoost.toFixed(6)),
+        changedPixels: composite.changedPixels,
+        maxChannelDelta: Number(composite.maxChannelDelta.toFixed(6)),
+        maxInputValue: Number(maxInputValue.toFixed(6)),
+        pipeline: ["bright-extract", "horizontal-blur", "vertical-blur", "composite"]
+    };
+}
+function blurBloomFloatPixelsHorizontal(pixels, width, height, radius) {
+    validateFloatPixelBuffer(pixels, width, height, "HDR bloom horizontal blur");
+    validateBloomBlurRadius(radius);
+    const kernelSize = radius * 2 + 1;
+    const output = new Float32Array(pixels.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const targetIndex = (y * width + x) * 4;
+            let red = 0;
+            let green = 0;
+            let blue = 0;
+            let alpha = 0;
+            for (let offsetX = -radius; offsetX <= radius; offsetX += 1) {
+                const sampleX = clampInt(x + offsetX, 0, width - 1);
+                const sampleIndex = (y * width + sampleX) * 4;
+                red += finiteHdrChannel(pixels[sampleIndex], sampleIndex);
+                green += finiteHdrChannel(pixels[sampleIndex + 1], sampleIndex + 1);
+                blue += finiteHdrChannel(pixels[sampleIndex + 2], sampleIndex + 2);
+                alpha += finiteHdrChannel(pixels[sampleIndex + 3], sampleIndex + 3);
+            }
+            output[targetIndex] = red / kernelSize;
+            output[targetIndex + 1] = green / kernelSize;
+            output[targetIndex + 2] = blue / kernelSize;
+            output[targetIndex + 3] = alpha / kernelSize;
+        }
+    }
+    return output;
+}
+function blurBloomFloatPixelsVertical(pixels, width, height, radius) {
+    validateFloatPixelBuffer(pixels, width, height, "HDR bloom vertical blur");
+    validateBloomBlurRadius(radius);
+    const kernelSize = radius * 2 + 1;
+    const output = new Float32Array(pixels.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const targetIndex = (y * width + x) * 4;
+            let red = 0;
+            let green = 0;
+            let blue = 0;
+            let alpha = 0;
+            for (let offsetY = -radius; offsetY <= radius; offsetY += 1) {
+                const sampleY = clampInt(y + offsetY, 0, height - 1);
+                const sampleIndex = (sampleY * width + x) * 4;
+                red += finiteHdrChannel(pixels[sampleIndex], sampleIndex);
+                green += finiteHdrChannel(pixels[sampleIndex + 1], sampleIndex + 1);
+                blue += finiteHdrChannel(pixels[sampleIndex + 2], sampleIndex + 2);
+                alpha += finiteHdrChannel(pixels[sampleIndex + 3], sampleIndex + 3);
+            }
+            output[targetIndex] = red / kernelSize;
+            output[targetIndex + 1] = green / kernelSize;
+            output[targetIndex + 2] = blue / kernelSize;
+            output[targetIndex + 3] = alpha / kernelSize;
+        }
+    }
+    return output;
+}
+function compositeBloomFloatPixels(sourcePixels, blurredPixels, width, height, intensity, brightPixels) {
+    validateFloatPixelBuffer(sourcePixels, width, height, "HDR bloom composite source");
+    validateFloatPixelBuffer(blurredPixels, width, height, "HDR bloom composite blur");
+    if (brightPixels)
+        validateFloatPixelBuffer(brightPixels, width, height, "HDR bloom composite bright source");
+    if (!Number.isFinite(intensity) || intensity < 0) {
+        throw new Error("Bloom intensity must be finite and non-negative.");
+    }
+    const output = new Float32Array(sourcePixels);
+    let maxNeighborBoost = 0;
+    let changedPixels = 0;
+    let maxChannelDelta = 0;
+    for (let index = 0; index < sourcePixels.length; index += 4) {
+        const previousRed = finiteHdrChannel(output[index], index);
+        const previousGreen = finiteHdrChannel(output[index + 1], index + 1);
+        const previousBlue = finiteHdrChannel(output[index + 2], index + 2);
+        const redBoost = finiteHdrChannel(blurredPixels[index], index) * intensity;
+        const greenBoost = finiteHdrChannel(blurredPixels[index + 1], index + 1) * intensity;
+        const blueBoost = finiteHdrChannel(blurredPixels[index + 2], index + 2) * intensity;
+        output[index] = previousRed + redBoost;
+        output[index + 1] = previousGreen + greenBoost;
+        output[index + 2] = previousBlue + blueBoost;
+        output[index + 3] = finiteHdrChannel(output[index + 3], index + 3);
+        const pixelDelta = Math.max(Math.abs(output[index] - previousRed), Math.abs(output[index + 1] - previousGreen), Math.abs(output[index + 2] - previousBlue));
+        if (pixelDelta > 0) {
+            changedPixels += 1;
+            maxChannelDelta = Math.max(maxChannelDelta, pixelDelta);
+        }
+        if (!brightPixels || (brightPixels[index] === 0 && brightPixels[index + 1] === 0 && brightPixels[index + 2] === 0)) {
+            maxNeighborBoost = Math.max(maxNeighborBoost, redBoost, greenBoost, blueBoost);
+        }
+    }
+    return { pixels: output, maxNeighborBoost, changedPixels, maxChannelDelta };
+}
+export function createDepthTextureBinding(options) {
+    const { label, width, height } = options;
+    if (!label)
+        throw new Error("Depth texture label is required.");
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error("Depth texture dimensions must be positive integers.");
+    }
+    const data = options.data ? new Float32Array(options.data) : new Float32Array(width * height);
+    if (data.length !== width * height) {
+        throw new Error("Depth texture data must contain width * height float samples.");
+    }
+    for (const value of data) {
+        if (!Number.isFinite(value) || value < 0 || value > 1) {
+            throw new Error("Depth texture samples must be finite normalized values in [0, 1].");
+        }
+    }
+    return { label, width, height, format: "depth24", data };
+}
+export function createToneMappingCalibration(options) {
+    const samples = [0, 0.18, 0.5, 1].map((inputLinear) => {
+        const mappedLinear = applyToneMapping(inputLinear, options.exposure, options.whitePoint, options.operator);
+        return {
+            inputLinear,
+            mappedLinear,
+            encodedByte: encodeColorByte(mappedLinear, options.gamma, options.outputColorSpace)
+        };
+    });
+    return {
+        operator: options.operator,
+        exposure: options.exposure,
+        whitePoint: options.whitePoint,
+        gamma: options.gamma,
+        inputColorSpace: options.inputColorSpace,
+        outputColorSpace: options.outputColorSpace,
+        samples,
+        monotonic: samples.every((sample, index) => index === 0 || sample.encodedByte >= samples[index - 1].encodedByte)
+    };
+}
+export function visualizeDepthTexture(texture, options = {}) {
+    const edgeThreshold = options.edgeThreshold ?? 0.08;
+    if (!Number.isFinite(edgeThreshold) || edgeThreshold < 0 || edgeThreshold > 1) {
+        throw new Error("Depth visualization edgeThreshold must be finite and in [0, 1].");
+    }
+    const stats = depthTextureStats(texture, edgeThreshold);
+    const pixels = new Uint8Array(texture.width * texture.height * 4);
+    for (let y = 0; y < texture.height; y += 1) {
+        for (let x = 0; x < texture.width; x += 1) {
+            const pixelIndex = (y * texture.width + x) * 4;
+            const depth = depthAt(texture, x, y);
+            const edge = isDepthEdge(texture, x, y, edgeThreshold);
+            const shade = clampByte((1 - depth) * 255);
+            pixels[pixelIndex] = edge ? 255 : shade;
+            pixels[pixelIndex + 1] = edge ? 98 : shade;
+            pixels[pixelIndex + 2] = edge ? 36 : shade;
+            pixels[pixelIndex + 3] = 255;
+        }
+    }
+    return { width: texture.width, height: texture.height, pixels, stats };
+}
+export function depthTextureStats(texture, edgeThreshold = 0.08) {
+    if (texture.data.length !== texture.width * texture.height) {
+        throw new Error("Depth texture data length does not match dimensions.");
+    }
+    let minDepth = Number.POSITIVE_INFINITY;
+    let maxDepth = Number.NEGATIVE_INFINITY;
+    let edgePixelCount = 0;
+    for (let y = 0; y < texture.height; y += 1) {
+        for (let x = 0; x < texture.width; x += 1) {
+            const depth = depthAt(texture, x, y);
+            minDepth = Math.min(minDepth, depth);
+            maxDepth = Math.max(maxDepth, depth);
+            if (isDepthEdge(texture, x, y, edgeThreshold))
+                edgePixelCount += 1;
+        }
+    }
+    return {
+        label: texture.label,
+        width: texture.width,
+        height: texture.height,
+        format: texture.format,
+        byteLength: texture.data.byteLength,
+        minDepth,
+        maxDepth,
+        centerDepth: depthAt(texture, Math.floor(texture.width / 2), Math.floor(texture.height / 2)),
+        nearSample: depthAt(texture, Math.floor(texture.width * 0.48), Math.floor(texture.height * 0.44)),
+        farSample: depthAt(texture, 1, 1),
+        edgePixelCount
+    };
+}
+export function fxaaPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "FXAA");
+    const edgeThreshold = options.edgeThreshold ?? 0.125;
+    const subpixelBlend = options.subpixelBlend ?? 0.75;
+    validateFXAAOptions(edgeThreshold, subpixelBlend);
+    const output = new Uint8Array(pixels);
+    const edgeMask = new Uint8Array(width * height);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = (y * width + x) * 4;
+            const centerLuma = lumaAt(pixels, width, height, x, y);
+            const northLuma = lumaAt(pixels, width, height, x, y - 1);
+            const southLuma = lumaAt(pixels, width, height, x, y + 1);
+            const westLuma = lumaAt(pixels, width, height, x - 1, y);
+            const eastLuma = lumaAt(pixels, width, height, x + 1, y);
+            const minLuma = Math.min(centerLuma, northLuma, southLuma, westLuma, eastLuma);
+            const maxLuma = Math.max(centerLuma, northLuma, southLuma, westLuma, eastLuma);
+            if (maxLuma - minLuma < edgeThreshold) {
+                continue;
+            }
+            edgeMask[y * width + x] = 255;
+            for (let channel = 0; channel < 3; channel += 1) {
+                const average = (channelAt(pixels, width, height, x, y - 1, channel)
+                    + channelAt(pixels, width, height, x, y + 1, channel)
+                    + channelAt(pixels, width, height, x - 1, y, channel)
+                    + channelAt(pixels, width, height, x + 1, y, channel)) / 4;
+                output[index + channel] = clampByte(pixels[index + channel] * (1 - subpixelBlend) + average * subpixelBlend);
+            }
+            output[index + 3] = pixels[index + 3];
+        }
+    }
+    return { width, height, pixels: output, edgeMask };
+}
+export function fusedLdrPostprocessPixels(pixels, width, height, passes, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Fused LDR postprocess");
+    const bloom = passes.find((pass) => pass.name === "bloom");
+    const toneMapping = passes.find((pass) => pass.name === "tone-mapping");
+    const colorGrade = passes.find((pass) => pass.name === "color-grade");
+    const fxaa = passes.find((pass) => pass.name === "fxaa");
+    const toneMappingLookup = toneMapping
+        ? getToneMappingLookup({
+            ...(options.toneMappingDefaults ?? {}),
+            ...toneMapping.options
+        }, options.scratch)
+        : undefined;
+    const colorGradeSettings = colorGrade ? normalizeColorGradeOptions(colorGrade.options) : undefined;
+    const byteLength = pixels.byteLength;
+    let current = bloom
+        ? bloomPixels(pixels, width, height, bloom.options).pixels
+        : pixels;
+    if (toneMappingLookup || colorGradeSettings) {
+        const target = options.mutateInput
+            ? pixels
+            : acquireFusedLdrBuffer(options.scratch, byteLength, 0);
+        const vignetteFactors = colorGradeSettings && colorGradeSettings.vignette > 0
+            ? getVignetteFactors(width, height, colorGradeSettings.vignette, options.scratch)
+            : undefined;
+        applyToneMappingAndColorGrade(current, target, width, height, toneMappingLookup, colorGradeSettings, vignetteFactors);
+        current = target;
+    }
+    if (colorGradeSettings && colorGradeSettings.sharpening > 0) {
+        const target = acquireFusedLdrBuffer(options.scratch, byteLength, current === options.scratch?.bufferA ? 1 : 0);
+        sharpenPixelsInto(current, target, width, height, colorGradeSettings.sharpening);
+        current = target;
+    }
+    if (fxaa) {
+        const settings = normalizeFXAAOptions(fxaa.options);
+        const target = acquireFusedLdrBuffer(options.scratch, byteLength, current === options.scratch?.bufferA ? 1 : 0);
+        fxaaPixelsInto(current, target, width, height, settings.edgeThreshold, settings.subpixelBlend);
+        current = target;
+    }
+    return current;
+}
+function validatePixelBuffer(pixels, width, height, label) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error(`${label} dimensions must be positive integers.`);
+    }
+    if (pixels.byteLength !== width * height * 4) {
+        throw new Error(`${label} input must contain width * height * 4 RGBA bytes.`);
+    }
+}
+function validateFloatPixelBuffer(pixels, width, height, label) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error(`${label} dimensions must be positive integers.`);
+    }
+    if (pixels.length !== width * height * 4) {
+        throw new Error(`${label} input must contain width * height * 4 RGBA float values.`);
+    }
+}
+function requireDepthTextureBinding(depth, label) {
+    if (!depth) {
+        throw new Error(`${label} requires a depth texture binding. Renderer-owned postprocess passes inject this automatically when the backend exposes depth readback.`);
+    }
+    return depth;
+}
+function validateFXAAOptions(edgeThreshold, subpixelBlend) {
+    if (!Number.isFinite(edgeThreshold) || edgeThreshold < 0 || edgeThreshold > 1) {
+        throw new Error("FXAA edgeThreshold must be finite and in [0, 1].");
+    }
+    if (!Number.isFinite(subpixelBlend) || subpixelBlend < 0 || subpixelBlend > 1) {
+        throw new Error("FXAA subpixelBlend must be finite and in [0, 1].");
+    }
+}
+function normalizeColorGradeOptions(options) {
+    const settings = {
+        contrast: options.contrast ?? 1,
+        temperature: options.temperature ?? 0,
+        tint: options.tint ?? 0,
+        saturation: options.saturation ?? 1,
+        vibrance: options.vibrance ?? 0,
+        vignette: options.vignette ?? 0,
+        sharpening: options.sharpening ?? 0
+    };
+    validateRange(settings.contrast, 0, 3, "Color grading contrast");
+    validateRange(settings.temperature, -1, 1, "Color grading temperature");
+    validateRange(settings.tint, -1, 1, "Color grading tint");
+    validateRange(settings.saturation, 0, 3, "Color grading saturation");
+    validateRange(settings.vibrance, -1, 1, "Color grading vibrance");
+    validateRange(settings.vignette, 0, 1, "Color grading vignette");
+    validateRange(settings.sharpening, 0, 2, "Color grading sharpening");
+    return settings;
+}
+function normalizeFXAAOptions(options) {
+    const settings = {
+        edgeThreshold: options.edgeThreshold ?? 0.125,
+        subpixelBlend: options.subpixelBlend ?? 0.75,
+        variant: options.variant ?? "legacy"
+    };
+    validateFXAAOptions(settings.edgeThreshold, settings.subpixelBlend);
+    return settings;
+}
+function acquireFusedLdrBuffer(scratch, byteLength, slot) {
+    if (!scratch)
+        return new Uint8Array(byteLength);
+    if (slot === 0) {
+        if (!scratch.bufferA || scratch.bufferA.byteLength !== byteLength) {
+            scratch.bufferA = new Uint8Array(byteLength);
+        }
+        return scratch.bufferA;
+    }
+    if (!scratch.bufferB || scratch.bufferB.byteLength !== byteLength) {
+        scratch.bufferB = new Uint8Array(byteLength);
+    }
+    return scratch.bufferB;
+}
+function getToneMappingLookup(options, scratch) {
+    const exposure = options.exposure ?? 1;
+    const whitePoint = options.whitePoint ?? 1;
+    const gamma = options.gamma ?? 2.2;
+    const operator = options.operator ?? "reinhard";
+    const inputColorSpace = options.inputColorSpace ?? "linear";
+    const outputColorSpace = options.outputColorSpace ?? "linear";
+    if (!Number.isFinite(exposure) || exposure < 0) {
+        throw new Error("Tone mapping exposure must be finite and non-negative.");
+    }
+    if (!Number.isFinite(whitePoint) || whitePoint <= 0) {
+        throw new Error("Tone mapping whitePoint must be finite and positive.");
+    }
+    if (!Number.isFinite(gamma) || gamma <= 0) {
+        throw new Error("Tone mapping gamma must be finite and positive.");
+    }
+    const key = `${exposure}|${whitePoint}|${gamma}|${operator}|${inputColorSpace}|${outputColorSpace}`;
+    if (scratch?.toneMappingLookup && scratch.toneMappingLookupKey === key) {
+        return scratch.toneMappingLookup;
+    }
+    const lookup = scratch?.toneMappingLookup ?? new Uint8Array(256);
+    for (let value = 0; value < 256; value += 1) {
+        lookup[value] = encodeToneMappedChannel(decodeColorByte(value, inputColorSpace), exposure, whitePoint, gamma, operator, outputColorSpace);
+    }
+    if (scratch) {
+        scratch.toneMappingLookup = lookup;
+        scratch.toneMappingLookupKey = key;
+    }
+    return lookup;
+}
+function getVignetteFactors(width, height, vignette, scratch) {
+    const key = `${width}x${height}|${vignette}`;
+    if (scratch?.vignetteFactors && scratch.vignetteFactorsKey === key) {
+        return scratch.vignetteFactors;
+    }
+    const factors = scratch?.vignetteFactors && scratch.vignetteFactors.length === width * height
+        ? scratch.vignetteFactors
+        : new Float32Array(width * height);
+    for (let y = 0; y < height; y += 1) {
+        const centerY = height <= 1 ? 0 : (y / (height - 1)) * 2 - 1;
+        for (let x = 0; x < width; x += 1) {
+            const centerX = width <= 1 ? 0 : (x / (width - 1)) * 2 - 1;
+            factors[y * width + x] = 1 - vignette * Math.min(1, Math.max(0, Math.sqrt(centerX * centerX + centerY * centerY) - 0.28) / 1.12);
+        }
+    }
+    if (scratch) {
+        scratch.vignetteFactors = factors;
+        scratch.vignetteFactorsKey = key;
+    }
+    return factors;
+}
+function applyToneMappingAndColorGrade(input, output, width, height, toneMappingLookup, colorGradeSettings, vignetteFactors) {
+    const contrast = colorGradeSettings?.contrast ?? 1;
+    const contrastOffset = 0.5 - 0.5 * contrast;
+    const temperature = colorGradeSettings?.temperature ?? 0;
+    const tint = colorGradeSettings?.tint ?? 0;
+    const redShift = temperature * 0.08 - tint * 0.02;
+    const greenShift = tint * 0.06;
+    const blueShift = -temperature * 0.08 - tint * 0.02;
+    const saturationBase = colorGradeSettings?.saturation ?? 1;
+    const vibrance = colorGradeSettings?.vibrance ?? 0;
+    const applyColorGrade = colorGradeSettings !== undefined;
+    for (let pixel = 0, index = 0; pixel < width * height; pixel += 1, index += 4) {
+        const toneRed = toneMappingLookup ? toneMappingLookup[input[index]] : input[index];
+        const toneGreen = toneMappingLookup ? toneMappingLookup[input[index + 1]] : input[index + 1];
+        const toneBlue = toneMappingLookup ? toneMappingLookup[input[index + 2]] : input[index + 2];
+        if (!applyColorGrade) {
+            output[index] = toneRed;
+            output[index + 1] = toneGreen;
+            output[index + 2] = toneBlue;
+            output[index + 3] = input[index + 3] ?? 255;
+            continue;
+        }
+        let red = toneRed / 255;
+        let green = toneGreen / 255;
+        let blue = toneBlue / 255;
+        const luma = 0.2126 * red + 0.7152 * green + 0.0722 * blue;
+        red = red * contrast + contrastOffset + redShift;
+        green = green * contrast + contrastOffset + greenShift;
+        blue = blue * contrast + contrastOffset + blueShift;
+        const vibranceBoost = vibrance === 0
+            ? 0
+            : vibrance * (1 - Math.min(1, Math.abs(red - luma) + Math.abs(green - luma) + Math.abs(blue - luma)));
+        const saturation = saturationBase + vibranceBoost;
+        red = luma + (red - luma) * saturation;
+        green = luma + (green - luma) * saturation;
+        blue = luma + (blue - luma) * saturation;
+        const vignette = vignetteFactors ? vignetteFactors[pixel] : 1;
+        output[index] = clampByteFast(red * vignette * 255);
+        output[index + 1] = clampByteFast(green * vignette * 255);
+        output[index + 2] = clampByteFast(blue * vignette * 255);
+        output[index + 3] = input[index + 3] ?? 255;
+    }
+}
+function sharpenPixelsInto(input, output, width, height, amount) {
+    output.set(input);
+    const rowStride = width * 4;
+    for (let y = 1; y < height - 1; y += 1) {
+        const rowOffset = y * rowStride;
+        for (let x = 1; x < width - 1; x += 1) {
+            const index = rowOffset + x * 4;
+            for (let channel = 0; channel < 3; channel += 1) {
+                const center = input[index + channel] ?? 0;
+                const blur = ((input[index - 4 + channel] ?? 0) +
+                    (input[index + 4 + channel] ?? 0) +
+                    (input[index - rowStride + channel] ?? 0) +
+                    (input[index + rowStride + channel] ?? 0)) / 4;
+                output[index + channel] = clampByteFast(center + (center - blur) * amount);
+            }
+        }
+    }
+}
+function fxaaPixelsInto(input, output, width, height, edgeThreshold, subpixelBlend) {
+    output.set(input);
+    const rowStride = width * 4;
+    for (let y = 0; y < height; y += 1) {
+        const rowOffset = y * rowStride;
+        const northOffset = y > 0 ? rowOffset - rowStride : rowOffset;
+        const southOffset = y < height - 1 ? rowOffset + rowStride : rowOffset;
+        for (let x = 0; x < width; x += 1) {
+            const index = rowOffset + x * 4;
+            const westIndex = x > 0 ? index - 4 : index;
+            const eastIndex = x < width - 1 ? index + 4 : index;
+            const northIndex = northOffset + x * 4;
+            const southIndex = southOffset + x * 4;
+            const centerLuma = lumaAtIndex(input, index);
+            const northLuma = lumaAtIndex(input, northIndex);
+            const southLuma = lumaAtIndex(input, southIndex);
+            const westLuma = lumaAtIndex(input, westIndex);
+            const eastLuma = lumaAtIndex(input, eastIndex);
+            const minLuma = Math.min(centerLuma, northLuma, southLuma, westLuma, eastLuma);
+            const maxLuma = Math.max(centerLuma, northLuma, southLuma, westLuma, eastLuma);
+            if (maxLuma - minLuma < edgeThreshold)
+                continue;
+            for (let channel = 0; channel < 3; channel += 1) {
+                const average = ((input[northIndex + channel] ?? 0) +
+                    (input[southIndex + channel] ?? 0) +
+                    (input[westIndex + channel] ?? 0) +
+                    (input[eastIndex + channel] ?? 0)) / 4;
+                output[index + channel] = clampByteFast(input[index + channel] * (1 - subpixelBlend) + average * subpixelBlend);
+            }
+            output[index + 3] = input[index + 3];
+        }
+    }
+}
+function lumaAtIndex(pixels, index) {
+    return (0.2126 * pixels[index] + 0.7152 * pixels[index + 1] + 0.0722 * pixels[index + 2]) / 255;
+}
+function clampByteFast(value) {
+    if (value <= 0)
+        return 0;
+    if (value >= 255)
+        return 255;
+    return Math.round(value);
+}
+function validateBloomOptions(threshold, intensity, radius) {
+    if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+        throw new Error("Bloom threshold must be finite and in [0, 1].");
+    }
+    if (!Number.isFinite(intensity) || intensity < 0) {
+        throw new Error("Bloom intensity must be finite and non-negative.");
+    }
+    validateBloomBlurRadius(radius);
+}
+function validateBloomBlurRadius(radius) {
+    if (!Number.isInteger(radius) || radius < 0 || radius > 16) {
+        throw new Error("Bloom radius must be an integer in [0, 16].");
+    }
+}
+function validateOutlineColor(color) {
+    for (let index = 0; index < color.length; index += 1) {
+        const channel = color[index] ?? 0;
+        if (!Number.isFinite(channel) || channel < 0 || channel > 255) {
+            throw new Error(`Outline color channel ${index} must be finite and within [0, 255].`);
+        }
+    }
+}
+/**
+ * Sobel response of the integer luma numerator `2126 * r + 7152 * g + 722 * b`.
+ *
+ * This is the same operator as {@link sobelLumaGradient} scaled by `OUTLINE_LUMA_SCALE`, but every
+ * intermediate is an exact integer: each numerator is at most `2550000`, so a response is at most
+ * `4 * 2550000` and the squared magnitude used by {@link outlineEdgeExceedsBound} stays below 2^48,
+ * well inside the range where float64 represents integers exactly.
+ */
+function sobelLumaNumeratorGradient(pixels, width, height, x, y) {
+    const nw = lumaNumeratorAt(pixels, width, height, x - 1, y - 1);
+    const n = lumaNumeratorAt(pixels, width, height, x, y - 1);
+    const ne = lumaNumeratorAt(pixels, width, height, x + 1, y - 1);
+    const w = lumaNumeratorAt(pixels, width, height, x - 1, y);
+    const e = lumaNumeratorAt(pixels, width, height, x + 1, y);
+    const sw = lumaNumeratorAt(pixels, width, height, x - 1, y + 1);
+    const s = lumaNumeratorAt(pixels, width, height, x, y + 1);
+    const se = lumaNumeratorAt(pixels, width, height, x + 1, y + 1);
+    return {
+        gx: -nw - 2 * w - sw + ne + 2 * e + se,
+        gy: -nw - 2 * n - ne + sw + 2 * s + se
+    };
+}
+/**
+ * Exact outline edge predicate shared by the CPU kernel and the WebGL2 shader.
+ *
+ * Equivalent to `hypot(gx, gy) >= threshold` on the real numbers, but decided with integers so
+ * that it never depends on float rounding. `bound` comes from {@link createOutlineGradientBound},
+ * which pre-squares the threshold as an exact rational and rounds up.
+ */
+function outlineEdgeExceedsBound(gx, gy, bound) {
+    return gx * gx + gy * gy >= bound;
+}
+function dilateMask(mask, width, height, radius) {
+    const output = new Uint8Array(mask.length);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            let outlined = false;
+            for (let offsetY = -radius; offsetY <= radius && !outlined; offsetY += 1) {
+                for (let offsetX = -radius; offsetX <= radius; offsetX += 1) {
+                    if (Math.hypot(offsetX, offsetY) > radius + 0.01)
+                        continue;
+                    const sampleX = clampInt(x + offsetX, 0, width - 1);
+                    const sampleY = clampInt(y + offsetY, 0, height - 1);
+                    if (mask[sampleY * width + sampleX] !== 0) {
+                        outlined = true;
+                        break;
+                    }
+                }
+            }
+            if (outlined)
+                output[y * width + x] = 255;
+        }
+    }
+    return output;
+}
+export function writePostProcessPixels(device, source, target, pixels) {
+    if (!target) {
+        if (!device.presentRenderTarget) {
+            throw new RenderDeviceError("Post-process presentation requires a render device with presentRenderTarget support", "POSTPROCESS_PRESENT_UNSUPPORTED", {
+                source: source.label
+            });
+        }
+        const presentationTarget = device.createRenderTarget({
+            width: source.width,
+            height: source.height,
+            label: `${source.label}-postprocess-present`,
+            format: "rgba8",
+            depth: false
+        });
+        try {
+            if (!device.writeRenderTargetPixels) {
+                throw new RenderDeviceError("Post-process presentation requires a render device with writeRenderTargetPixels support", "POSTPROCESS_WRITE_UNSUPPORTED", {
+                    source: source.label
+                });
+            }
+            device.writeRenderTargetPixels(presentationTarget, pixels);
+            device.presentRenderTarget(presentationTarget);
+        }
+        finally {
+            presentationTarget.dispose();
+        }
+        return;
+    }
+    if (target.width !== source.width || target.height !== source.height) {
+        throw new Error("Post-process source and target dimensions must match.");
+    }
+    if (device.writeRenderTargetPixels) {
+        device.writeRenderTargetPixels(target, pixels);
+    }
+    else {
+        const writable = target;
+        if (writable.colorPixels) {
+            writable.colorPixels.set(pixels);
+        }
+        else {
+            throw new RenderDeviceError("Post-process target does not support byte pixel writes", "POSTPROCESS_WRITE_UNSUPPORTED", {
+                target: target.label
+            });
+        }
+    }
+    device.setRenderTarget(target);
+}
+function writeDepthTarget(target, width, height, pixels) {
+    if (!target)
+        return;
+    if (target.width !== width || target.height !== height) {
+        throw new Error("Depth visualization target dimensions must match source depth texture.");
+    }
+    const writable = target;
+    if (writable.colorPixels) {
+        writable.colorPixels.set(pixels);
+    }
+}
+function writeRenderTarget(device, source, target, pixels) {
+    writePostProcessPixels(device, source, target, pixels);
+}
+function encodeToneMappedChannel(value, exposure, whitePoint, gamma, operator, outputColorSpace) {
+    return encodeColorByte(applyToneMapping(value, exposure, whitePoint, operator), gamma, outputColorSpace);
+}
+function finiteHdrChannel(value, index) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`HDR tone mapping input contains non-finite float value at channel ${index}.`);
+    }
+    return Math.max(0, value);
+}
+function applyToneMapping(value, exposure, whitePoint, operator) {
+    const exposed = Math.max(0, value * exposure) / whitePoint;
+    return operator === "linear"
+        ? Math.min(1, exposed)
+        : operator === "reinhard"
+            ? exposed / (1 + exposed)
+            : operator === "aces"
+                ? aces(exposed)
+                : operator === "filmic"
+                    ? filmic(exposed)
+                    : operator === "uncharted2"
+                        ? uncharted2(exposed)
+                        : operator === "agx"
+                            ? agx(exposed)
+                            : neutral(exposed);
+}
+function decodeColorByte(value, colorSpace) {
+    const normalized = Math.max(0, Math.min(1, value / 255));
+    if (colorSpace === "linear")
+        return normalized;
+    if (normalized <= 0.04045)
+        return normalized / 12.92;
+    return Math.pow((normalized + 0.055) / 1.055, 2.4);
+}
+function encodeColorByte(value, gamma, colorSpace) {
+    const linear = Math.max(0, Math.min(1, value));
+    if (colorSpace === "linear") {
+        return clampByte(linear * 255);
+    }
+    const encoded = linear <= 0.0031308
+        ? linear * 12.92
+        : 1.055 * Math.pow(linear, 1 / 2.4) - 0.055;
+    return clampByte(encoded * 255);
+}
+function aces(value) {
+    return (value * (2.51 * value + 0.03)) / (value * (2.43 * value + 0.59) + 0.14);
+}
+function acesFilmicRgb(color, exposure, whitePoint) {
+    const scale = exposure / Math.max(0.0001, whitePoint) / 0.6;
+    const input = [color[0] * scale, color[1] * scale, color[2] * scale];
+    const aces = [
+        0.59719 * input[0] + 0.35458 * input[1] + 0.04823 * input[2],
+        0.07600 * input[0] + 0.90834 * input[1] + 0.01566 * input[2],
+        0.02840 * input[0] + 0.13383 * input[1] + 0.83777 * input[2]
+    ].map(acesRrtAndOdtFit);
+    return [
+        Math.max(0, Math.min(1, 1.60475 * aces[0] - 0.53108 * aces[1] - 0.07367 * aces[2])),
+        Math.max(0, Math.min(1, -0.10208 * aces[0] + 1.10813 * aces[1] - 0.00605 * aces[2])),
+        Math.max(0, Math.min(1, -0.00327 * aces[0] - 0.07276 * aces[1] + 1.07602 * aces[2]))
+    ];
+}
+function acesRrtAndOdtFit(value) {
+    return (value * (value + 0.0245786) - 0.000090537) / (value * (0.983729 * value + 0.4329510) + 0.238081);
+}
+function filmic(value) {
+    const x = Math.max(0, value);
+    const toe = Math.max(0, x - 0.004);
+    const curve = (toe * (6.2 * toe + 0.5)) / (toe * (6.2 * toe + 1.7) + 0.06);
+    return Math.min(curve, x * 1.08);
+}
+function uncharted2(value) {
+    const a = 0.15;
+    const b = 0.5;
+    const c = 0.1;
+    const d = 0.2;
+    const e = 0.02;
+    const f = 0.3;
+    const w = 11.2;
+    const curve = (x) => ((x * (a * x + c * b) + d * e) / (x * (a * x + b) + d * f)) - e / f;
+    return Math.max(0, Math.min(1, curve(value * 2) / curve(w)));
+}
+function agx(value) {
+    const x = Math.max(0, value);
+    const logEncoded = Math.log2(1 + x) / Math.log2(1 + 16);
+    const shaped = logEncoded * logEncoded * (3 - 2 * logEncoded);
+    return Math.max(0, Math.min(1, shaped));
+}
+function neutral(value) {
+    const x = Math.max(0, value);
+    return Math.min(1, (x * (1 + x / 7.5)) / (1 + x));
+}
+function createToneMappingPreset(name, label, options) {
+    return {
+        name,
+        label,
+        toneMapping: {
+            exposure: options.exposure ?? 1,
+            whitePoint: options.whitePoint ?? 1,
+            gamma: options.gamma ?? 2.2,
+            operator: options.operator ?? "reinhard",
+            inputColorSpace: options.inputColorSpace ?? "linear",
+            // Display presets feed display-referred chains (public composer, parity
+            // probes): linear-out crushed every preset to near-black (5 buckets on
+            // the comprehensive fixture). Explicit overrides still win.
+            outputColorSpace: options.outputColorSpace ?? "srgb"
+        },
+        colorGrade: {
+            contrast: options.contrast ?? 1,
+            temperature: options.temperature ?? 0,
+            tint: options.tint ?? 0,
+            saturation: options.saturation ?? 1,
+            vibrance: options.vibrance ?? 0,
+            vignette: options.vignette ?? 0,
+            sharpening: options.sharpening ?? 0
+        },
+        autoExposure: options.autoExposure,
+        adaptationSpeed: options.adaptationSpeed ?? 0.5,
+        minExposure: options.minExposure ?? 0.1,
+        maxExposure: options.maxExposure ?? 10
+    };
+}
+function validateHistogramOptions(binCount, minLuminance, maxLuminance) {
+    if (!Number.isInteger(binCount) || binCount < 4 || binCount > 1024) {
+        throw new Error("Exposure histogram binCount must be an integer in [4, 1024].");
+    }
+    validateRange(minLuminance, 0.000001, 128, "Exposure histogram minLuminance");
+    validateRange(maxLuminance, minLuminance, 1024, "Exposure histogram maxLuminance");
+}
+function histogramAverageFromBins(histogram) {
+    const logMin = Math.log2(histogram.minLuminance);
+    const logMax = Math.log2(histogram.maxLuminance);
+    let weighted = 0;
+    let count = 0;
+    for (let index = 0; index < histogram.binCount; index += 1) {
+        const binValue = histogram.bins[index] ?? 0;
+        const t = histogram.binCount <= 1 ? 0 : index / (histogram.binCount - 1);
+        const luminance = Math.pow(2, logMin + (logMax - logMin) * t);
+        weighted += luminance * binValue;
+        count += binValue;
+    }
+    return count > 0 ? weighted / count : 0.18;
+}
+function noise2d(x, y, seed) {
+    let value = (x + 1) * 374761393 + (y + 1) * 668265263 + seed * 2147483647;
+    value = (value ^ (value >>> 13)) * 1274126177;
+    return ((value ^ (value >>> 16)) >>> 0) / 0xffffffff;
+}
+function sharpenPixels(pixels, width, height, amount) {
+    const output = new Uint8Array(pixels);
+    let sharpenedPixels = 0;
+    for (let y = 1; y < height - 1; y += 1) {
+        for (let x = 1; x < width - 1; x += 1) {
+            const index = (y * width + x) * 4;
+            for (let channel = 0; channel < 3; channel += 1) {
+                const center = pixels[index + channel] ?? 0;
+                const blur = ((pixels[index - 4 + channel] ?? 0) +
+                    (pixels[index + 4 + channel] ?? 0) +
+                    (pixels[index - width * 4 + channel] ?? 0) +
+                    (pixels[index + width * 4 + channel] ?? 0)) / 4;
+                output[index + channel] = clampByte(center + (center - blur) * amount);
+            }
+            if (Math.abs(output[index] - (pixels[index] ?? 0)) + Math.abs(output[index + 1] - (pixels[index + 1] ?? 0)) + Math.abs(output[index + 2] - (pixels[index + 2] ?? 0)) > 3) {
+                sharpenedPixels += 1;
+            }
+        }
+    }
+    return { pixels: output, sharpenedPixels };
+}
+function countChangedRgb(before, after) {
+    let count = 0;
+    for (let index = 0; index < before.length; index += 4) {
+        if (Math.abs((before[index] ?? 0) - (after[index] ?? 0)) + Math.abs((before[index + 1] ?? 0) - (after[index + 1] ?? 0)) + Math.abs((before[index + 2] ?? 0) - (after[index + 2] ?? 0)) > 3)
+            count += 1;
+    }
+    return count;
+}
+function validateRange(value, min, max, label) {
+    if (!Number.isFinite(value) || value < min || value > max) {
+        throw new Error(`${label} must be finite and within [${min}, ${max}].`);
+    }
+}
+function numberInRange(value, min, max, label) {
+    validateRange(value, min, max, label);
+    return value;
+}
+function integerNumberInRange(value, min, max, label) {
+    validateRange(value, min, max, label);
+    if (!Number.isInteger(value))
+        throw new Error(`${label} must be an integer.`);
+    return value;
+}
+function clampByte(value) {
+    return Math.round(Math.max(0, Math.min(255, value)));
+}
+/** 2x2 Bayer ordered dither in [-0.5, 0.5]; A5 one-LSB anti-banding. */
+function bayer2(x, y) {
+    const index = ((y & 1) << 1) | (x & 1);
+    return (index === 0 ? -0.375 : index === 1 ? 0.375 : index === 2 ? -0.125 : 0.125);
+}
+function clampInt(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function lumaAt(pixels, width, height, x, y) {
+    const sampleX = clampInt(x, 0, width - 1);
+    const sampleY = clampInt(y, 0, height - 1);
+    const index = (sampleY * width + sampleX) * 4;
+    return (0.2126 * pixels[index] + 0.7152 * pixels[index + 1] + 0.0722 * pixels[index + 2]) / 255;
+}
+/** Integer luma numerator at a clamped coordinate, matching the outline shader exactly. */
+function lumaNumeratorAt(pixels, width, height, x, y) {
+    const sampleX = clampInt(x, 0, width - 1);
+    const sampleY = clampInt(y, 0, height - 1);
+    const index = (sampleY * width + sampleX) * 4;
+    return 2126 * pixels[index] + 7152 * pixels[index + 1] + 722 * pixels[index + 2];
+}
+function channelAt(pixels, width, height, x, y, channel) {
+    const sampleX = clampInt(x, 0, width - 1);
+    const sampleY = clampInt(y, 0, height - 1);
+    return pixels[(sampleY * width + sampleX) * 4 + channel];
+}
+function normalizeContactShadowDirection(direction) {
+    const [x, y] = direction;
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+        throw new Error("Contact shadow direction must contain finite x/y values.");
+    }
+    const length = Math.hypot(x, y);
+    if (length < 0.0001) {
+        throw new Error("Contact shadow direction must not be zero length.");
+    }
+    return [x / length, y / length];
+}
+function depthAt(texture, x, y) {
+    const sampleX = clampInt(x, 0, texture.width - 1);
+    const sampleY = clampInt(y, 0, texture.height - 1);
+    return texture.data[sampleY * texture.width + sampleX];
+}
+function isDepthEdge(texture, x, y, edgeThreshold) {
+    const center = depthAt(texture, x, y);
+    const delta = Math.max(Math.abs(center - depthAt(texture, x + 1, y)), Math.abs(center - depthAt(texture, x - 1, y)), Math.abs(center - depthAt(texture, x, y + 1)), Math.abs(center - depthAt(texture, x, y - 1)));
+    return delta >= edgeThreshold;
+}
+//# sourceMappingURL=PostProcessPass.js.map