framefields 2.0.2

package/dist/dist-C_hjvkdN.mjs

@@ -0,0 +1,2220 @@
+//#region ../tensor-webgpu/dist/index.mjs
+var ControlNetMultiplexer = class {
+	textures = /* @__PURE__ */ new Map();
+	set(type, texture) {
+		this.textures.set(type, texture);
+	}
+	get(type) {
+		return this.textures.get(type);
+	}
+	has(type) {
+		return this.textures.has(type);
+	}
+	getOutputs() {
+		return {
+			canny: this.textures.get("canny"),
+			depth: this.textures.get("depth"),
+			normals: this.textures.get("normals"),
+			poseSkeleton: this.textures.get("poseSkeleton"),
+			segmentationMask: this.textures.get("segmentationMask"),
+			faceLandmarks: this.textures.get("faceLandmarks"),
+			motionVectors: this.textures.get("motionVectors"),
+			deflickered: this.textures.get("deflickered")
+		};
+	}
+	createBindGroupEntry(type, bindingIndex) {
+		const tex = this.textures.get(type);
+		if (!tex) throw new Error(`[ControlNetMultiplexer] Cannot create bind group entry: conditioning texture "${type}" is not registered in VRAM.`);
+		return {
+			binding: bindingIndex,
+			resource: tex.createView({ label: `controlnet_${type}_view` })
+		};
+	}
+	exportTensorView(type) {
+		const tex = this.textures.get(type);
+		if (!tex) throw new Error(`[ControlNetMultiplexer] Conditioning tensor "${type}" not found in multiplexer.`);
+		return {
+			texture: tex,
+			width: tex.width,
+			height: tex.height,
+			format: tex.format
+		};
+	}
+	async readPixelsAsync(device, type) {
+		const tex = this.textures.get(type);
+		if (!tex) throw new Error(`[ControlNetMultiplexer] Cannot read pixels: conditioning texture "${type}" is missing.`);
+		const width = tex.width;
+		const height = tex.height;
+		const format = tex.format;
+		let bytesPerPixel = 4;
+		if (format === "rgba16float" || format === "rg32float") bytesPerPixel = 8;
+		else if (format === "r32float") bytesPerPixel = 4;
+		else if (format === "rgba32float") bytesPerPixel = 16;
+		const unalignedBytesPerRow = width * bytesPerPixel;
+		const bytesPerRow = Math.ceil(unalignedBytesPerRow / 256) * 256;
+		const bufferSize = bytesPerRow * height;
+		const stagingBuffer = device.createBuffer({
+			size: bufferSize,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+			label: `controlnet_readback_staging_${type}`
+		});
+		const encoder = device.createCommandEncoder({ label: `readback_encoder_${type}` });
+		encoder.copyTextureToBuffer({ texture: tex }, {
+			buffer: stagingBuffer,
+			bytesPerRow,
+			rowsPerImage: height
+		}, [
+			width,
+			height,
+			1
+		]);
+		device.queue.submit([encoder.finish()]);
+		await stagingBuffer.mapAsync(GPUMapMode.READ);
+		const mappedRange = stagingBuffer.getMappedRange();
+		const resultData = new Uint8Array(width * height * bytesPerPixel);
+		const sourceBytes = new Uint8Array(mappedRange);
+		if (bytesPerRow === unalignedBytesPerRow) resultData.set(sourceBytes.subarray(0, width * height * bytesPerPixel));
+		else for (let y = 0; y < height; y++) {
+			const srcOffset = y * bytesPerRow;
+			const dstOffset = y * unalignedBytesPerRow;
+			resultData.set(sourceBytes.subarray(srcOffset, srcOffset + unalignedBytesPerRow), dstOffset);
+		}
+		stagingBuffer.unmap();
+		stagingBuffer.destroy();
+		return {
+			width,
+			height,
+			format,
+			data: resultData
+		};
+	}
+	destroy() {
+		for (const tex of this.textures.values()) try {
+			tex.destroy();
+		} catch (_) {}
+		this.textures.clear();
+	}
+};
+/**
+* @file canny.wgsl.ts
+* High-performance WebGPU Canny Edge Compute Shaders
+* Pass 1: Sobel gradient magnitude & quantized angle
+* Pass 2: Non-Maximum Suppression (NMS) & Dual-Threshold Hysteresis
+*/
+const cannySobelWgsl = `
+struct CannyParams {
+  lowThreshold: f32,
+  highThreshold: f32,
+  width: u32,
+  height: u32,
+};
+
+@group(0) @binding(0) var inputTex: texture_2d<f32>;
+@group(0) @binding(1) var magnitudeTex: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(2) var<uniform> params: CannyParams;
+
+fn getLuma(coord: vec2<i32>, maxCoord: vec2<i32>) -> f32 {
+  let clamped = clamp(coord, vec2<i32>(0), maxCoord);
+  let c = textureLoad(inputTex, clamped, 0);
+  return dot(c.rgb, vec3<f32>(0.299, 0.587, 0.114));
+}
+
+@compute @workgroup_size(16, 16)
+fn computeSobel(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) { return; }
+
+  let x = i32(id.x);
+  let y = i32(id.y);
+  let maxCoord = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);
+
+  let p00 = getLuma(vec2<i32>(x - 1, y - 1), maxCoord);
+  let p10 = getLuma(vec2<i32>(x,     y - 1), maxCoord);
+  let p20 = getLuma(vec2<i32>(x + 1, y - 1), maxCoord);
+  let p01 = getLuma(vec2<i32>(x - 1, y),     maxCoord);
+  let p21 = getLuma(vec2<i32>(x + 1, y),     maxCoord);
+  let p02 = getLuma(vec2<i32>(x - 1, y + 1), maxCoord);
+  let p12 = getLuma(vec2<i32>(x,     y + 1), maxCoord);
+  let p22 = getLuma(vec2<i32>(x + 1, y + 1), maxCoord);
+
+  let gx = (p20 + 2.0 * p21 + p22) - (p00 + 2.0 * p01 + p02);
+  let gy = (p02 + 2.0 * p12 + p22) - (p00 + 2.0 * p10 + p20);
+
+  let mag = sqrt(gx * gx + gy * gy);
+  let angle = atan2(gy, gx);
+
+  // Quantize angle into 4 sectors (0: 0 deg, 1: 45 deg, 2: 90 deg, 3: 135 deg)
+  var sector: f32 = 0.0;
+  let a = (angle * 180.0 / 3.14159265 + 180.0) % 180.0;
+  if ((a >= 0.0 && a < 22.5) || (a >= 157.5 && a <= 180.0)) {
+    sector = 0.0;
+  } else if (a >= 22.5 && a < 67.5) {
+    sector = 1.0;
+  } else if (a >= 67.5 && a < 112.5) {
+    sector = 2.0;
+  } else {
+    sector = 3.0;
+  }
+
+  textureStore(magnitudeTex, id.xy, vec4<f32>(mag, sector, 0.0, 1.0));
+}
+`;
+const cannyNmsRgba8Wgsl = `
+struct CannyParams {
+  lowThreshold: f32,
+  highThreshold: f32,
+  width: u32,
+  height: u32,
+};
+
+@group(0) @binding(0) var magnitudeTex: texture_2d<f32>;
+@group(0) @binding(1) var edgeTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(2) var<uniform> params: CannyParams;
+
+@compute @workgroup_size(16, 16)
+fn computeNonMaxSuppression(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) { return; }
+
+  let x = i32(id.x);
+  let y = i32(id.y);
+  let maxCoord = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);
+
+  let center = textureLoad(magnitudeTex, vec2<i32>(x, y), 0);
+  let mag = center.r;
+  let sector = u32(round(center.g));
+
+  var n1 = 0.0;
+  var n2 = 0.0;
+
+  switch (sector) {
+    case 0u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y), vec2<i32>(0), maxCoord), 0).r;
+    }
+    case 1u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+    case 2u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+    default: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+  }
+
+  var edge = 0.0;
+  // Non-maximum suppression along gradient sector with directional tie-breaking
+  if (mag > n1 && mag >= n2 && mag > 0.0) {
+    if (mag >= params.highThreshold) {
+      edge = 1.0;
+    } else if (mag >= params.lowThreshold) {
+      edge = 0.5;
+    }
+  }
+
+  textureStore(edgeTex, id.xy, vec4<f32>(edge, edge, edge, 1.0));
+}
+`;
+const cannyNmsR32fWgsl = `
+struct CannyParams {
+  lowThreshold: f32,
+  highThreshold: f32,
+  width: u32,
+  height: u32,
+};
+
+@group(0) @binding(0) var magnitudeTex: texture_2d<f32>;
+@group(0) @binding(1) var edgeTex: texture_storage_2d<r32float, write>;
+@group(0) @binding(2) var<uniform> params: CannyParams;
+
+@compute @workgroup_size(16, 16)
+fn computeNonMaxSuppression(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) { return; }
+
+  let x = i32(id.x);
+  let y = i32(id.y);
+  let maxCoord = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);
+
+  let center = textureLoad(magnitudeTex, vec2<i32>(x, y), 0);
+  let mag = center.r;
+  let sector = u32(round(center.g));
+
+  var n1 = 0.0;
+  var n2 = 0.0;
+
+  switch (sector) {
+    case 0u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y), vec2<i32>(0), maxCoord), 0).r;
+    }
+    case 1u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+    case 2u: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+    default: {
+      n1 = textureLoad(magnitudeTex, clamp(vec2<i32>(x - 1, y - 1), vec2<i32>(0), maxCoord), 0).r;
+      n2 = textureLoad(magnitudeTex, clamp(vec2<i32>(x + 1, y + 1), vec2<i32>(0), maxCoord), 0).r;
+    }
+  }
+
+  var edge = 0.0;
+  // Non-maximum suppression along gradient sector with directional tie-breaking
+  if (mag > n1 && mag >= n2 && mag > 0.0) {
+    if (mag >= params.highThreshold) {
+      edge = 1.0;
+    } else if (mag >= params.lowThreshold) {
+      edge = 0.5;
+    }
+  }
+
+  textureStore(edgeTex, id.xy, vec4<f32>(edge, 0.0, 0.0, 1.0));
+}
+`;
+var CannyComputePipeline = class {
+	sobelPipeline;
+	nmsRgba8Pipeline;
+	nmsR32fPipeline;
+	uniformBuffer;
+	cachedIntermediateTexture;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const sobelModule = device.createShaderModule({
+			label: "canny_sobel.wgsl",
+			code: cannySobelWgsl
+		});
+		this.sobelPipeline = device.createComputePipeline({
+			label: "CannySobelPipeline",
+			layout: "auto",
+			compute: {
+				module: sobelModule,
+				entryPoint: "computeSobel"
+			}
+		});
+		const nmsRgba8Module = device.createShaderModule({
+			label: "canny_nms_rgba8.wgsl",
+			code: cannyNmsRgba8Wgsl
+		});
+		this.nmsRgba8Pipeline = device.createComputePipeline({
+			label: "CannyNmsRgba8Pipeline",
+			layout: "auto",
+			compute: {
+				module: nmsRgba8Module,
+				entryPoint: "computeNonMaxSuppression"
+			}
+		});
+		const nmsR32fModule = device.createShaderModule({
+			label: "canny_nms_r32f.wgsl",
+			code: cannyNmsR32fWgsl
+		});
+		this.nmsR32fPipeline = device.createComputePipeline({
+			label: "CannyNmsR32fPipeline",
+			layout: "auto",
+			compute: {
+				module: nmsR32fModule,
+				entryPoint: "computeNonMaxSuppression"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 16,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "canny_uniform_buffer"
+		});
+	}
+	execute(inputTexture, options = {}) {
+		const width = inputTexture.width;
+		const height = inputTexture.height;
+		const lowThreshold = options.low ?? .1;
+		const highThreshold = options.high ?? .3;
+		const outputFormat = options.outputFormat ?? "rgba8unorm";
+		const uniformData = /* @__PURE__ */ new ArrayBuffer(16);
+		const f32View = new Float32Array(uniformData);
+		const u32View = new Uint32Array(uniformData);
+		f32View[0] = lowThreshold;
+		f32View[1] = highThreshold;
+		u32View[2] = width;
+		u32View[3] = height;
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, uniformData);
+		if (!this.cachedIntermediateTexture || this.cachedIntermediateTexture.width !== width || this.cachedIntermediateTexture.height !== height) {
+			this.cachedIntermediateTexture?.destroy();
+			this.cachedIntermediateTexture = this.device.createTexture({
+				label: "canny_magnitude_intermediate",
+				size: [width, height],
+				format: "rgba16float",
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
+			});
+		}
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height || this.cachedOutputTexture.format !== outputFormat) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: `canny_edge_output_${outputFormat}`,
+				size: [width, height],
+				format: outputFormat,
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+			});
+		}
+		const commandEncoder = this.device.createCommandEncoder({ label: "canny_command_encoder" });
+		const sobelBindGroup = this.device.createBindGroup({
+			layout: this.sobelPipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: inputTexture.createView()
+				},
+				{
+					binding: 1,
+					resource: this.cachedIntermediateTexture.createView()
+				},
+				{
+					binding: 2,
+					resource: { buffer: this.uniformBuffer }
+				}
+			]
+		});
+		const pass1 = commandEncoder.beginComputePass({ label: "canny_sobel_pass" });
+		pass1.setPipeline(this.sobelPipeline);
+		pass1.setBindGroup(0, sobelBindGroup);
+		pass1.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+		pass1.end();
+		const nmsPipeline = outputFormat === "r32float" ? this.nmsR32fPipeline : this.nmsRgba8Pipeline;
+		const nmsBindGroup = this.device.createBindGroup({
+			layout: nmsPipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: this.cachedIntermediateTexture.createView()
+				},
+				{
+					binding: 1,
+					resource: this.cachedOutputTexture.createView()
+				},
+				{
+					binding: 2,
+					resource: { buffer: this.uniformBuffer }
+				}
+			]
+		});
+		const pass2 = commandEncoder.beginComputePass({ label: "canny_nms_pass" });
+		pass2.setPipeline(nmsPipeline);
+		pass2.setBindGroup(0, nmsBindGroup);
+		pass2.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+		pass2.end();
+		this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.cachedIntermediateTexture?.destroy();
+		this.cachedOutputTexture?.destroy();
+		this.uniformBuffer.destroy();
+	}
+};
+/**
+* @file depth-normals.wgsl.ts
+* Screen-Space Normal Map Reconstruction from Depth Tensor
+* Analytical cross-product of spatial partial derivatives:
+* dP/dx = [1, 0, dD/dx]^T, dP/dy = [0, 1, dD/dy]^T
+* N = normalize(dP/dx x dP/dy) = normalize([-dx, -dy, 1.0])
+*/
+const depthNormalsRgba16fWgsl = `
+struct DepthNormalParams {
+  width: u32,
+  height: u32,
+  depthScale: f32,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var depthTex: texture_2d<f32>;
+@group(0) @binding(1) var normalTex: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(2) var<uniform> params: DepthNormalParams;
+
+@compute @workgroup_size(16, 16)
+fn computeNormals(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) { return; }
+
+  let c = id.xy;
+  let maxX = params.width - 1u;
+  let maxY = params.height - 1u;
+
+  let left  = textureLoad(depthTex, vec2<u32>(max(c.x - 1u, 0u), c.y), 0).r;
+  let right = textureLoad(depthTex, vec2<u32>(min(c.x + 1u, maxX), c.y), 0).r;
+  let up    = textureLoad(depthTex, vec2<u32>(c.x, max(c.y - 1u, 0u)), 0).r;
+  let down  = textureLoad(depthTex, vec2<u32>(c.x, min(c.y + 1u, maxY)), 0).r;
+
+  let dx = (right - left) * 0.5 * params.depthScale;
+  let dy = (down - up) * 0.5 * params.depthScale;
+
+  let normal = normalize(vec3<f32>(-dx, -dy, 1.0));
+  // Pack [-1, 1] range to [0, 1]
+  let packedColor = vec4<f32>(normal * 0.5 + 0.5, 1.0);
+  textureStore(normalTex, id.xy, packedColor);
+}
+`;
+const depthNormalsRgba8Wgsl = `
+struct DepthNormalParams {
+  width: u32,
+  height: u32,
+  depthScale: f32,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var depthTex: texture_2d<f32>;
+@group(0) @binding(1) var normalTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(2) var<uniform> params: DepthNormalParams;
+
+@compute @workgroup_size(16, 16)
+fn computeNormals(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) { return; }
+
+  let c = id.xy;
+  let maxX = params.width - 1u;
+  let maxY = params.height - 1u;
+
+  let left  = textureLoad(depthTex, vec2<u32>(max(c.x - 1u, 0u), c.y), 0).r;
+  let right = textureLoad(depthTex, vec2<u32>(min(c.x + 1u, maxX), c.y), 0).r;
+  let up    = textureLoad(depthTex, vec2<u32>(c.x, max(c.y - 1u, 0u)), 0).r;
+  let down  = textureLoad(depthTex, vec2<u32>(c.x, min(c.y + 1u, maxY)), 0).r;
+
+  let dx = (right - left) * 0.5 * params.depthScale;
+  let dy = (down - up) * 0.5 * params.depthScale;
+
+  let normal = normalize(vec3<f32>(-dx, -dy, 1.0));
+  // Pack [-1, 1] range to [0, 1]
+  let packedColor = vec4<f32>(normal * 0.5 + 0.5, 1.0);
+  textureStore(normalTex, id.xy, packedColor);
+}
+`;
+var DepthNormalsComputePipeline = class {
+	normalRgba16fPipeline;
+	normalRgba8Pipeline;
+	uniformBuffer;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const rgba16fModule = device.createShaderModule({
+			label: "depth_normals_rgba16f.wgsl",
+			code: depthNormalsRgba16fWgsl
+		});
+		this.normalRgba16fPipeline = device.createComputePipeline({
+			label: "DepthNormalsRgba16fPipeline",
+			layout: "auto",
+			compute: {
+				module: rgba16fModule,
+				entryPoint: "computeNormals"
+			}
+		});
+		const rgba8Module = device.createShaderModule({
+			label: "depth_normals_rgba8.wgsl",
+			code: depthNormalsRgba8Wgsl
+		});
+		this.normalRgba8Pipeline = device.createComputePipeline({
+			label: "DepthNormalsRgba8Pipeline",
+			layout: "auto",
+			compute: {
+				module: rgba8Module,
+				entryPoint: "computeNormals"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 16,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "depth_normals_uniform_buffer"
+		});
+	}
+	execute(depthTexture, options = {}) {
+		const width = depthTexture.width;
+		const height = depthTexture.height;
+		const depthScale = options.depthScale ?? 1;
+		const outputFormat = options.outputFormat ?? "rgba16float";
+		const uniformData = /* @__PURE__ */ new ArrayBuffer(16);
+		const u32View = new Uint32Array(uniformData);
+		const f32View = new Float32Array(uniformData);
+		u32View[0] = width;
+		u32View[1] = height;
+		f32View[2] = depthScale;
+		f32View[3] = 0;
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, uniformData);
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height || this.cachedOutputTexture.format !== outputFormat) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: `normal_output_${outputFormat}`,
+				size: [width, height],
+				format: outputFormat,
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+			});
+		}
+		const pipeline = outputFormat === "rgba8unorm" ? this.normalRgba8Pipeline : this.normalRgba16fPipeline;
+		const commandEncoder = this.device.createCommandEncoder({ label: "depth_normals_command_encoder" });
+		const bindGroup = this.device.createBindGroup({
+			layout: pipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: depthTexture.createView()
+				},
+				{
+					binding: 1,
+					resource: this.cachedOutputTexture.createView()
+				},
+				{
+					binding: 2,
+					resource: { buffer: this.uniformBuffer }
+				}
+			]
+		});
+		const pass = commandEncoder.beginComputePass({ label: "depth_normals_compute_pass" });
+		pass.setPipeline(pipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+		pass.end();
+		this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.cachedOutputTexture?.destroy();
+		this.uniformBuffer.destroy();
+	}
+};
+/**
+* @file face-landmarks.wgsl.ts
+* Native WebGPU WGSL compute shader for ControlNet Face & MediaPipe facial contour rasterization.
+* Renders antialiased facial mesh contours (lips, eyes, brows, nose, oval) directly in VRAM for SDXL ControlNet.
+*/
+const faceLandmarksWgsl = `
+struct FaceSegment {
+  start: vec2<f32>,
+  end: vec2<f32>,
+  color: vec4<f32>,
+  radius: f32,
+  enabled: f32,
+  pad: vec2<f32>,
+};
+
+struct FaceParams {
+  width: u32,
+  height: u32,
+  numSegments: u32,
+  pad: u32,
+};
+
+@group(0) @binding(0) var outputTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: FaceParams;
+@group(0) @binding(2) var<storage, read> segments: array<FaceSegment>;
+
+@compute @workgroup_size(16, 16)
+fn computeFaceLandmarks(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let p = vec2<f32>(f32(id.x) + 0.5, f32(id.y) + 0.5);
+  var outColor = vec4<f32>(0.0, 0.0, 0.0, 1.0); // Solid black background for SDXL ControlNet
+
+  let count = params.numSegments;
+  for (var i = 0u; i < count; i = i + 1u) {
+    let seg = segments[i];
+    if (seg.enabled < 0.5) {
+      continue;
+    }
+
+    let ab = seg.end - seg.start;
+    let ap = p - seg.start;
+    let l2 = dot(ab, ab);
+
+    var t: f32 = 0.0;
+    if (l2 > 0.0001) {
+      t = clamp(dot(ap, ab) / l2, 0.0, 1.0);
+    }
+
+    let closest = seg.start + t * ab;
+    let dist = length(p - closest);
+
+    if (dist <= seg.radius) {
+      let edgeAlpha = clamp(seg.radius - dist + 0.5, 0.0, 1.0);
+      outColor = vec4<f32>(mix(outColor.rgb, seg.color.rgb, edgeAlpha * seg.color.a), 1.0);
+    }
+  }
+
+  textureStore(outputTex, id.xy, outColor);
+}
+`;
+function buildLoopSegments(indices, color) {
+	const segs = [];
+	for (let i = 0; i < indices.length - 1; i++) segs.push({
+		from: indices[i],
+		to: indices[i + 1],
+		color
+	});
+	return segs;
+}
+const CANONICAL_FACE_CONTOURS = [
+	...buildLoopSegments([
+		70,
+		63,
+		105,
+		66,
+		107
+	], [
+		0,
+		1,
+		1,
+		1
+	]),
+	...buildLoopSegments([
+		300,
+		293,
+		334,
+		296,
+		336
+	], [
+		0,
+		1,
+		1,
+		1
+	]),
+	...buildLoopSegments([
+		33,
+		160,
+		158,
+		133,
+		153,
+		144,
+		33
+	], [
+		0,
+		1,
+		0,
+		1
+	]),
+	...buildLoopSegments([
+		263,
+		387,
+		385,
+		362,
+		380,
+		373,
+		263
+	], [
+		0,
+		1,
+		0,
+		1
+	]),
+	...buildLoopSegments([
+		168,
+		6,
+		197,
+		195,
+		4
+	], [
+		1,
+		1,
+		0,
+		1
+	]),
+	...buildLoopSegments([
+		98,
+		97,
+		2,
+		326,
+		327
+	], [
+		1,
+		1,
+		0,
+		1
+	]),
+	...buildLoopSegments([
+		61,
+		185,
+		40,
+		39,
+		37,
+		0,
+		267,
+		269,
+		270,
+		409,
+		291,
+		375,
+		321,
+		405,
+		314,
+		17,
+		84,
+		181,
+		91,
+		146,
+		61
+	], [
+		1,
+		.2,
+		.2,
+		1
+	]),
+	...buildLoopSegments([
+		78,
+		95,
+		88,
+		178,
+		87,
+		14,
+		317,
+		402,
+		318,
+		324,
+		308,
+		415,
+		310,
+		311,
+		312,
+		13,
+		82,
+		81,
+		80,
+		191,
+		78
+	], [
+		1,
+		0,
+		.8,
+		1
+	]),
+	...buildLoopSegments([
+		10,
+		338,
+		297,
+		332,
+		284,
+		251,
+		389,
+		356,
+		454,
+		323,
+		361,
+		288,
+		397,
+		365,
+		379,
+		378,
+		400,
+		377,
+		152,
+		148,
+		176,
+		149,
+		150,
+		136,
+		172,
+		58,
+		132,
+		93,
+		234,
+		127,
+		162,
+		21,
+		54,
+		103,
+		67,
+		109,
+		10
+	], [
+		.9,
+		.9,
+		.9,
+		1
+	])
+];
+var FaceLandmarksComputePipeline = class {
+	computePipeline;
+	uniformBuffer;
+	storageBuffer;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const shaderModule = device.createShaderModule({
+			label: "face_landmarks.wgsl",
+			code: faceLandmarksWgsl
+		});
+		this.computePipeline = device.createComputePipeline({
+			label: "FaceLandmarksComputePipeline",
+			layout: "auto",
+			compute: {
+				module: shaderModule,
+				entryPoint: "computeFaceLandmarks"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 64,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "face_landmarks_uniform_buffer"
+		});
+		const storageSize = Math.max(256, CANONICAL_FACE_CONTOURS.length * 48);
+		this.storageBuffer = device.createBuffer({
+			size: storageSize,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+			label: "face_landmarks_storage_buffer"
+		});
+	}
+	execute(landmarks, options = {}) {
+		const width = options.width ?? 1024;
+		const height = options.height ?? 1024;
+		const lineWidth = options.lineWidth ?? 4;
+		const radius = Math.max(1, lineWidth / 2);
+		const u32Uniforms = new Uint32Array(4);
+		u32Uniforms[0] = width;
+		u32Uniforms[1] = height;
+		u32Uniforms[2] = CANONICAL_FACE_CONTOURS.length;
+		u32Uniforms[3] = 0;
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, u32Uniforms);
+		const f32Segments = new Float32Array(CANONICAL_FACE_CONTOURS.length * 12);
+		for (let i = 0; i < CANONICAL_FACE_CONTOURS.length; i++) {
+			const seg = CANONICAL_FACE_CONTOURS[i];
+			const ptA = landmarks[seg.from];
+			const ptB = landmarks[seg.to];
+			const offset = i * 12;
+			if (!ptA || !ptB || (ptA.visibility ?? 1) < .2 || (ptB.visibility ?? 1) < .2) {
+				f32Segments[offset + 9] = 0;
+				continue;
+			}
+			f32Segments[offset + 0] = ptA.x * width;
+			f32Segments[offset + 1] = ptA.y * height;
+			f32Segments[offset + 2] = ptB.x * width;
+			f32Segments[offset + 3] = ptB.y * height;
+			f32Segments[offset + 4] = seg.color[0];
+			f32Segments[offset + 5] = seg.color[1];
+			f32Segments[offset + 6] = seg.color[2];
+			f32Segments[offset + 7] = seg.color[3];
+			f32Segments[offset + 8] = radius;
+			f32Segments[offset + 9] = 1;
+			f32Segments[offset + 10] = 0;
+			f32Segments[offset + 11] = 0;
+		}
+		this.device.queue.writeBuffer(this.storageBuffer, 0, f32Segments);
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				size: {
+					width,
+					height
+				},
+				format: "rgba8unorm",
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
+				label: "face_landmarks_output_texture"
+			});
+		}
+		const bindGroup = this.device.createBindGroup({
+			label: "FaceLandmarksBindGroup",
+			layout: this.computePipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: this.cachedOutputTexture.createView()
+				},
+				{
+					binding: 1,
+					resource: { buffer: this.uniformBuffer }
+				},
+				{
+					binding: 2,
+					resource: { buffer: this.storageBuffer }
+				}
+			]
+		});
+		const commandEncoder = this.device.createCommandEncoder({ label: "FaceLandmarksCommandEncoder" });
+		const pass = commandEncoder.beginComputePass({ label: "FaceLandmarksComputePass" });
+		pass.setPipeline(this.computePipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+		pass.end();
+		this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.uniformBuffer.destroy();
+		this.storageBuffer.destroy();
+		this.cachedOutputTexture?.destroy();
+	}
+};
+/**
+* @file optical-flow.wgsl.ts
+* High-Performance Native WebGPU Optical Flow Compute Shaders
+* Implements coarse-to-fine Lucas-Kanade motion vector estimation with
+* spatial structure tensor integration and Tikhonov aperture regularization.
+*/
+const opticalFlowDirectWgsl = `
+struct FlowParams {
+  width: u32,
+  height: u32,
+  windowSize: u32,       // Half-window radius W (e.g. 2 for 5x5 window)
+  regularization: f32,   // Tikhonov regularization lambda
+  maxDisplacement: f32,  // Maximum allowable flow vector length
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(0) @binding(0) var prevTex: texture_2d<f32>;
+@group(0) @binding(1) var currTex: texture_2d<f32>;
+@group(0) @binding(2) var flowTex: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(3) var<uniform> params: FlowParams;
+
+fn rgbToLuminance(rgb: vec3<f32>) -> f32 {
+  return dot(rgb, vec3<f32>(0.299, 0.587, 0.114));
+}
+
+fn sampleLuma(tex: texture_2d<f32>, coord: vec2<i32>) -> f32 {
+  let inDims = vec2<f32>(textureDimensions(tex));
+  let scaleRatio = inDims / vec2<f32>(f32(params.width), f32(params.height));
+  let actualCoord = vec2<i32>(vec2<f32>(coord) * scaleRatio);
+  let clamped = clamp(actualCoord, vec2<i32>(0, 0), vec2<i32>(inDims) - vec2<i32>(1, 1));
+  let color = textureLoad(tex, clamped, 0);
+  return rgbToLuminance(color.rgb);
+}
+
+@compute @workgroup_size(16, 16)
+fn computeFlow(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let centerCoord = vec2<i32>(i32(id.x), i32(id.y));
+  let w = i32(max(params.windowSize, 1u));
+
+  var sxx: f32 = 0.0;
+  var syy: f32 = 0.0;
+  var sxy: f32 = 0.0;
+  var sxt: f32 = 0.0;
+  var syt: f32 = 0.0;
+
+  for (var dy = -w; dy <= w; dy = dy + 1) {
+    for (var dx = -w; dx <= w; dx = dx + 1) {
+      let p = centerCoord + vec2<i32>(dx, dy);
+
+      // Central difference spatial gradients on current frame
+      let lx = sampleLuma(currTex, p - vec2<i32>(1, 0));
+      let rx = sampleLuma(currTex, p + vec2<i32>(1, 0));
+      let uy = sampleLuma(currTex, p - vec2<i32>(0, 1));
+      let dyL = sampleLuma(currTex, p + vec2<i32>(0, 1));
+
+      let ix = (rx - lx) * 0.5;
+      let iy = (dyL - uy) * 0.5;
+
+      // Temporal gradient: difference between current and previous frame
+      let cCurr = sampleLuma(currTex, p);
+      let cPrev = sampleLuma(prevTex, p);
+      let it = cCurr - cPrev;
+
+      // Gaussian spatial falloff weight
+      let distSq = f32(dx * dx + dy * dy);
+      let weight = exp(-distSq / (2.0 * f32(w * w) + 0.1));
+
+      sxx += ix * ix * weight;
+      syy += iy * iy * weight;
+      sxy += ix * iy * weight;
+      sxt += ix * it * weight;
+      syt += iy * it * weight;
+    }
+  }
+
+  // Tikhonov regularization prevents singularity in flat/homogeneous regions
+  let trace = sxx + syy;
+  let reg = max(params.regularization, 1e-4) * max(trace, 1.0);
+  let A = sxx + reg;
+  let B = sxy;
+  let C = syy + reg;
+
+  let det = A * C - B * B;
+  var u: f32 = 0.0;
+  var v: f32 = 0.0;
+
+  if (det > 1e-6) {
+    u = (-sxt * C + syt * B) / det;
+    v = (-syt * A + sxt * B) / det;
+  }
+
+  let mag = length(vec2<f32>(u, v));
+  let maxD = max(params.maxDisplacement, 1.0);
+  if (mag > maxD) {
+    let scale = maxD / mag;
+    u *= scale;
+    v *= scale;
+  }
+
+  textureStore(flowTex, id.xy, vec4<f32>(u, v, min(mag, maxD), 1.0));
+}
+`;
+const opticalFlowRefineWgsl = `
+struct FlowParams {
+  width: u32,
+  height: u32,
+  windowSize: u32,
+  regularization: f32,
+  maxDisplacement: f32,
+  coarseWidth: u32,
+  coarseHeight: u32,
+  _pad0: f32,
+};
+
+@group(0) @binding(0) var prevTex: texture_2d<f32>;
+@group(0) @binding(1) var currTex: texture_2d<f32>;
+@group(0) @binding(2) var coarseFlowTex: texture_2d<f32>;
+@group(0) @binding(3) var fineFlowTex: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(4) var<uniform> params: FlowParams;
+@group(0) @binding(5) var bilinearSamp: sampler;
+
+fn rgbToLuminance(rgb: vec3<f32>) -> f32 {
+  return dot(rgb, vec3<f32>(0.299, 0.587, 0.114));
+}
+
+fn sampleLuma(tex: texture_2d<f32>, coord: vec2<i32>) -> f32 {
+  let clamped = clamp(coord, vec2<i32>(0, 0), vec2<i32>(i32(params.width) - 1, i32(params.height) - 1));
+  let color = textureLoad(tex, clamped, 0);
+  return rgbToLuminance(color.rgb);
+}
+
+fn sampleWarpedPrevLuma(uv: vec2<f32>, priorFlow: vec2<f32>) -> f32 {
+  let invDims = vec2<f32>(1.0 / f32(params.width), 1.0 / f32(params.height));
+  let warpedUv = clamp(uv - priorFlow * invDims, vec2<f32>(0.0), vec2<f32>(1.0));
+  let sampleColor = textureSampleLevel(prevTex, bilinearSamp, warpedUv, 0.0);
+  return rgbToLuminance(sampleColor.rgb);
+}
+
+@compute @workgroup_size(16, 16)
+fn refineFlow(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let centerCoord = vec2<i32>(i32(id.x), i32(id.y));
+  let w = i32(max(params.windowSize, 1u));
+  let invDims = vec2<f32>(1.0 / f32(params.width), 1.0 / f32(params.height));
+  let centerUv = (vec2<f32>(id.xy) + 0.5) * invDims;
+
+  // Read upsampled prior flow from coarse scale (scaled by 2x)
+  let coarseCoord = vec2<i32>(centerCoord / 2);
+  let coarseSample = textureLoad(coarseFlowTex, coarseCoord, 0);
+  let priorFlow = coarseSample.xy * 2.0;
+
+  var sxx: f32 = 0.0;
+  var syy: f32 = 0.0;
+  var sxy: f32 = 0.0;
+  var sxt: f32 = 0.0;
+  var syt: f32 = 0.0;
+
+  for (var dy = -w; dy <= w; dy = dy + 1) {
+    for (var dx = -w; dx <= w; dx = dx + 1) {
+      let p = centerCoord + vec2<i32>(dx, dy);
+      let pUv = (vec2<f32>(p) + 0.5) * invDims;
+
+      let lx = sampleLuma(currTex, p - vec2<i32>(1, 0));
+      let rx = sampleLuma(currTex, p + vec2<i32>(1, 0));
+      let uy = sampleLuma(currTex, p - vec2<i32>(0, 1));
+      let dyL = sampleLuma(currTex, p + vec2<i32>(0, 1));
+
+      let ix = (rx - lx) * 0.5;
+      let iy = (dyL - uy) * 0.5;
+
+      // Temporal residual against warped previous frame
+      let cCurr = sampleLuma(currTex, p);
+      let cWarpedPrev = sampleWarpedPrevLuma(pUv, priorFlow);
+      let it = cCurr - cWarpedPrev;
+
+      let distSq = f32(dx * dx + dy * dy);
+      let weight = exp(-distSq / (2.0 * f32(w * w) + 0.1));
+
+      sxx += ix * ix * weight;
+      syy += iy * iy * weight;
+      sxy += ix * iy * weight;
+      sxt += ix * it * weight;
+      syt += iy * it * weight;
+    }
+  }
+
+  let trace = sxx + syy;
+  let reg = max(params.regularization, 1e-4) * max(trace, 1.0);
+  let A = sxx + reg;
+  let B = sxy;
+  let C = syy + reg;
+
+  let det = A * C - B * B;
+  var du: f32 = 0.0;
+  var dv: f32 = 0.0;
+
+  if (det > 1e-6) {
+    du = (-sxt * C + syt * B) / det;
+    dv = (-syt * A + sxt * B) / det;
+  }
+
+  // Combine coarse prior flow with fine residual flow
+  var totalFlow = priorFlow + vec2<f32>(du, dv);
+  let mag = length(totalFlow);
+  let maxD = max(params.maxDisplacement, 1.0);
+  if (mag > maxD) {
+    totalFlow *= (maxD / mag);
+  }
+
+  textureStore(fineFlowTex, id.xy, vec4<f32>(totalFlow.x, totalFlow.y, min(mag, maxD), 1.0));
+}
+`;
+var OpticalFlowComputePipeline = class {
+	directPipeline;
+	refinePipeline;
+	directUniformBuffer;
+	refineUniformBuffer;
+	bilinearSampler;
+	cachedCoarseTexture;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const directModule = device.createShaderModule({
+			label: "optical_flow_direct.wgsl",
+			code: opticalFlowDirectWgsl
+		});
+		this.directPipeline = device.createComputePipeline({
+			label: "OpticalFlowDirectPipeline",
+			layout: "auto",
+			compute: {
+				module: directModule,
+				entryPoint: "computeFlow"
+			}
+		});
+		const refineModule = device.createShaderModule({
+			label: "optical_flow_refine.wgsl",
+			code: opticalFlowRefineWgsl
+		});
+		this.refinePipeline = device.createComputePipeline({
+			label: "OpticalFlowRefinePipeline",
+			layout: "auto",
+			compute: {
+				module: refineModule,
+				entryPoint: "refineFlow"
+			}
+		});
+		this.directUniformBuffer = device.createBuffer({
+			size: 32,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "optical_flow_direct_uniform"
+		});
+		this.refineUniformBuffer = device.createBuffer({
+			size: 32,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "optical_flow_refine_uniform"
+		});
+		this.bilinearSampler = device.createSampler({
+			label: "optical_flow_bilinear_sampler",
+			magFilter: "linear",
+			minFilter: "linear",
+			addressModeU: "clamp-to-edge",
+			addressModeV: "clamp-to-edge"
+		});
+	}
+	execute(prevTexture, currTexture, options = {}, customEncoder) {
+		const width = currTexture.width;
+		const height = currTexture.height;
+		const windowSize = options?.windowSize ?? 3;
+		const regularization = options?.regularization ?? options?.lambda ?? .05;
+		const scale = options?.scale ?? .5;
+		const maxDisplacement = 64;
+		const outputFormat = options.outputFormat ?? "rgba16float";
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height || this.cachedOutputTexture.format !== outputFormat) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: `optical_flow_output_${outputFormat}`,
+				size: [width, height],
+				format: outputFormat,
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+			});
+		}
+		const commandEncoder = customEncoder ?? this.device.createCommandEncoder({ label: "optical_flow_command_encoder" });
+		if (scale > .1 && scale < .95 && width >= 64 && height >= 64) {
+			const coarseW = Math.max(16, Math.floor(width * scale));
+			const coarseH = Math.max(16, Math.floor(height * scale));
+			if (!this.cachedCoarseTexture || this.cachedCoarseTexture.width !== coarseW || this.cachedCoarseTexture.height !== coarseH) {
+				this.cachedCoarseTexture?.destroy();
+				this.cachedCoarseTexture = this.device.createTexture({
+					label: "optical_flow_coarse",
+					size: [coarseW, coarseH],
+					format: "rgba16float",
+					usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+				});
+			}
+			const directData = /* @__PURE__ */ new ArrayBuffer(32);
+			const directU32 = new Uint32Array(directData);
+			const directF32 = new Float32Array(directData);
+			directU32[0] = coarseW;
+			directU32[1] = coarseH;
+			directU32[2] = windowSize;
+			directF32[3] = regularization;
+			directF32[4] = maxDisplacement * scale;
+			this.device.queue.writeBuffer(this.directUniformBuffer, 0, directData);
+			const coarseBindGroup = this.device.createBindGroup({
+				layout: this.directPipeline.getBindGroupLayout(0),
+				entries: [
+					{
+						binding: 0,
+						resource: prevTexture.createView()
+					},
+					{
+						binding: 1,
+						resource: currTexture.createView()
+					},
+					{
+						binding: 2,
+						resource: this.cachedCoarseTexture.createView()
+					},
+					{
+						binding: 3,
+						resource: { buffer: this.directUniformBuffer }
+					}
+				]
+			});
+			const coarsePass = commandEncoder.beginComputePass({ label: "optical_flow_coarse_pass" });
+			coarsePass.setPipeline(this.directPipeline);
+			coarsePass.setBindGroup(0, coarseBindGroup);
+			coarsePass.dispatchWorkgroups(Math.ceil(coarseW / 16), Math.ceil(coarseH / 16));
+			coarsePass.end();
+			const refineData = /* @__PURE__ */ new ArrayBuffer(32);
+			const refineU32 = new Uint32Array(refineData);
+			const refineF32 = new Float32Array(refineData);
+			refineU32[0] = width;
+			refineU32[1] = height;
+			refineU32[2] = windowSize;
+			refineF32[3] = regularization;
+			refineF32[4] = maxDisplacement;
+			refineU32[5] = coarseW;
+			refineU32[6] = coarseH;
+			this.device.queue.writeBuffer(this.refineUniformBuffer, 0, refineData);
+			const refineBindGroup = this.device.createBindGroup({
+				layout: this.refinePipeline.getBindGroupLayout(0),
+				entries: [
+					{
+						binding: 0,
+						resource: prevTexture.createView()
+					},
+					{
+						binding: 1,
+						resource: currTexture.createView()
+					},
+					{
+						binding: 2,
+						resource: this.cachedCoarseTexture.createView()
+					},
+					{
+						binding: 3,
+						resource: this.cachedOutputTexture.createView()
+					},
+					{
+						binding: 4,
+						resource: { buffer: this.refineUniformBuffer }
+					},
+					{
+						binding: 5,
+						resource: this.bilinearSampler
+					}
+				]
+			});
+			const finePass = commandEncoder.beginComputePass({ label: "optical_flow_fine_pass" });
+			finePass.setPipeline(this.refinePipeline);
+			finePass.setBindGroup(0, refineBindGroup);
+			finePass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+			finePass.end();
+		} else {
+			const directData = /* @__PURE__ */ new ArrayBuffer(32);
+			const directU32 = new Uint32Array(directData);
+			const directF32 = new Float32Array(directData);
+			directU32[0] = width;
+			directU32[1] = height;
+			directU32[2] = windowSize;
+			directF32[3] = regularization;
+			directF32[4] = maxDisplacement;
+			this.device.queue.writeBuffer(this.directUniformBuffer, 0, directData);
+			const directBindGroup = this.device.createBindGroup({
+				layout: this.directPipeline.getBindGroupLayout(0),
+				entries: [
+					{
+						binding: 0,
+						resource: prevTexture.createView()
+					},
+					{
+						binding: 1,
+						resource: currTexture.createView()
+					},
+					{
+						binding: 2,
+						resource: this.cachedOutputTexture.createView()
+					},
+					{
+						binding: 3,
+						resource: { buffer: this.directUniformBuffer }
+					}
+				]
+			});
+			const directPass = commandEncoder.beginComputePass({ label: "optical_flow_direct_pass" });
+			directPass.setPipeline(this.directPipeline);
+			directPass.setBindGroup(0, directBindGroup);
+			directPass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+			directPass.end();
+		}
+		if (!customEncoder) this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.cachedCoarseTexture?.destroy();
+		this.cachedOutputTexture?.destroy();
+		this.directUniformBuffer.destroy();
+		this.refineUniformBuffer.destroy();
+	}
+};
+/**
+* @file pose-skeleton.wgsl.ts
+* Native WebGPU WGSL compute shader for ControlNet OpenPose skeleton rasterization.
+* Renders instanced bone cylinders/capsules directly in VRAM without CPU roundtrips.
+*/
+const poseSkeletonWgsl = `
+struct Bone {
+  start: vec2<f32>,
+  end: vec2<f32>,
+  color: vec4<f32>,
+  radius: f32,
+  enabled: f32,
+  pad: vec2<f32>,
+};
+
+struct SkeletonParams {
+  width: u32,
+  height: u32,
+  numBones: u32,
+  pad: u32,
+  bones: array<Bone, 24>,
+};
+
+@group(0) @binding(0) var outputTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: SkeletonParams;
+
+@compute @workgroup_size(16, 16)
+fn computePoseSkeleton(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let p = vec2<f32>(f32(id.x) + 0.5, f32(id.y) + 0.5);
+  var outColor = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+
+  let count = min(params.numBones, 24u);
+  for (var i = 0u; i < count; i = i + 1u) {
+    let bone = params.bones[i];
+    if (bone.enabled < 0.5) {
+      continue;
+    }
+
+    let ab = bone.end - bone.start;
+    let ap = p - bone.start;
+    let l2 = dot(ab, ab);
+
+    var t: f32 = 0.0;
+    if (l2 > 0.0001) {
+      t = clamp(dot(ap, ab) / l2, 0.0, 1.0);
+    }
+
+    let closest = bone.start + t * ab;
+    let dist = length(p - closest);
+
+    if (dist <= bone.radius) {
+      // Sub-pixel edge antialiasing
+      let edgeAlpha = clamp(bone.radius - dist + 0.5, 0.0, 1.0);
+      let a = edgeAlpha * bone.color.a;
+      outColor = vec4<f32>(mix(outColor.rgb, bone.color.rgb, a), max(outColor.a, a));
+    }
+  }
+
+  textureStore(outputTex, id.xy, outColor);
+}
+`;
+const CANONICAL_OPENPOSE_BONES = [
+	{
+		from: 0,
+		to: 11,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: 0,
+		to: 12,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: 11,
+		to: 12,
+		color: [
+			1,
+			0,
+			0,
+			1
+		]
+	},
+	{
+		from: 11,
+		to: 13,
+		color: [
+			1,
+			.333,
+			0,
+			1
+		]
+	},
+	{
+		from: 13,
+		to: 15,
+		color: [
+			1,
+			.667,
+			0,
+			1
+		]
+	},
+	{
+		from: 12,
+		to: 14,
+		color: [
+			1,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: 14,
+		to: 16,
+		color: [
+			.667,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: 11,
+		to: 23,
+		color: [
+			.333,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: 12,
+		to: 24,
+		color: [
+			0,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: 23,
+		to: 24,
+		color: [
+			0,
+			1,
+			.333,
+			1
+		]
+	},
+	{
+		from: 23,
+		to: 25,
+		color: [
+			0,
+			1,
+			.667,
+			1
+		]
+	},
+	{
+		from: 25,
+		to: 27,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: 24,
+		to: 26,
+		color: [
+			0,
+			.667,
+			1,
+			1
+		]
+	},
+	{
+		from: 26,
+		to: 28,
+		color: [
+			0,
+			.333,
+			1,
+			1
+		]
+	}
+];
+var PoseSkeletonComputePipeline = class {
+	computePipeline;
+	uniformBuffer;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const shaderModule = device.createShaderModule({
+			label: "pose_skeleton.wgsl",
+			code: poseSkeletonWgsl
+		});
+		this.computePipeline = device.createComputePipeline({
+			label: "PoseSkeletonComputePipeline",
+			layout: "auto",
+			compute: {
+				module: shaderModule,
+				entryPoint: "computePoseSkeleton"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 1280,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "pose_skeleton_uniform_buffer"
+		});
+	}
+	execute(landmarks, options = {}, bones) {
+		const boneDefs = bones ?? CANONICAL_OPENPOSE_BONES;
+		const width = options.width ?? 1024;
+		const height = options.height ?? 1024;
+		const lineWidth = options.lineWidth ?? 6;
+		const radius = Math.max(1, lineWidth / 2);
+		const arrayBuf = /* @__PURE__ */ new ArrayBuffer(1280);
+		const u32View = new Uint32Array(arrayBuf);
+		const f32View = new Float32Array(arrayBuf);
+		u32View[0] = width;
+		u32View[1] = height;
+		u32View[2] = boneDefs.length;
+		u32View[3] = 0;
+		const boneBaseFloatOffset = 4;
+		for (let i = 0; i < boneDefs.length; i++) {
+			const boneDef = boneDefs[i];
+			const ptA = landmarks[boneDef.from];
+			const ptB = landmarks[boneDef.to];
+			const offset = boneBaseFloatOffset + i * 12;
+			if (!ptA || !ptB || (ptA.visibility ?? 1) < .2 || (ptB.visibility ?? 1) < .2) {
+				f32View[offset + 9] = 0;
+				continue;
+			}
+			f32View[offset + 0] = ptA.x * width;
+			f32View[offset + 1] = ptA.y * height;
+			f32View[offset + 2] = ptB.x * width;
+			f32View[offset + 3] = ptB.y * height;
+			f32View[offset + 4] = boneDef.color[0];
+			f32View[offset + 5] = boneDef.color[1];
+			f32View[offset + 6] = boneDef.color[2];
+			f32View[offset + 7] = boneDef.color[3];
+			f32View[offset + 8] = radius;
+			f32View[offset + 9] = 1;
+		}
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, arrayBuf);
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: "openpose_skeleton_texture",
+				size: [width, height],
+				format: "rgba8unorm",
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+			});
+		}
+		const commandEncoder = this.device.createCommandEncoder({ label: "pose_skeleton_command_encoder" });
+		const bindGroup = this.device.createBindGroup({
+			label: "pose_skeleton_bind_group",
+			layout: this.computePipeline.getBindGroupLayout(0),
+			entries: [{
+				binding: 0,
+				resource: this.cachedOutputTexture.createView({ label: "pose_skeleton_output_view" })
+			}, {
+				binding: 1,
+				resource: { buffer: this.uniformBuffer }
+			}]
+		});
+		const pass = commandEncoder.beginComputePass({ label: "pose_skeleton_compute_pass" });
+		pass.setPipeline(this.computePipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16), 1);
+		pass.end();
+		this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.cachedOutputTexture?.destroy();
+		this.cachedOutputTexture = void 0;
+		this.uniformBuffer.destroy();
+	}
+};
+/**
+* @file segmentation.wgsl.ts
+* Native WebGPU WGSL compute shader for segmentation mask thresholding and edge feathering.
+* Outputs crisp alpha mattes directly in VRAM without CPU roundtrips.
+*/
+const segmentationWgsl = `
+struct SegParams {
+  threshold: f32,
+  feather: f32,
+  width: u32,
+  height: u32,
+};
+
+@group(0) @binding(0) var inputTex: texture_2d<f32>;
+@group(0) @binding(1) var outputTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(2) var<uniform> params: SegParams;
+
+@compute @workgroup_size(16, 16)
+fn computeSegmentation(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let coord = vec2<i32>(i32(id.x), i32(id.y));
+  let sample = textureLoad(inputTex, coord, 0);
+
+  // Luminance or alpha channel extraction
+  let rawAlpha = max(sample.a, dot(sample.rgb, vec3<f32>(0.299, 0.587, 0.114)));
+
+  let lower = max(0.0, params.threshold - params.feather);
+  let upper = min(1.0, params.threshold + params.feather);
+  let alpha = smoothstep(lower, upper, rawAlpha);
+
+  textureStore(outputTex, id.xy, vec4<f32>(alpha, alpha, alpha, 1.0));
+}
+`;
+var SegmentationComputePipeline = class {
+	computePipeline;
+	uniformBuffer;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		const shaderModule = device.createShaderModule({
+			label: "segmentation.wgsl",
+			code: segmentationWgsl
+		});
+		this.computePipeline = device.createComputePipeline({
+			label: "SegmentationComputePipeline",
+			layout: "auto",
+			compute: {
+				module: shaderModule,
+				entryPoint: "computeSegmentation"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 16,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "segmentation_uniform_buffer"
+		});
+	}
+	execute(inputTexture, options = {}) {
+		const width = inputTexture.width;
+		const height = inputTexture.height;
+		const threshold = options.threshold ?? .5;
+		const feather = options.feather ?? .05;
+		const arrayBuf = /* @__PURE__ */ new ArrayBuffer(16);
+		const f32View = new Float32Array(arrayBuf);
+		const u32View = new Uint32Array(arrayBuf);
+		f32View[0] = threshold;
+		f32View[1] = feather;
+		u32View[2] = width;
+		u32View[3] = height;
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, arrayBuf);
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: "segmentation_output_texture",
+				size: [width, height],
+				format: "rgba8unorm",
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+			});
+		}
+		const commandEncoder = this.device.createCommandEncoder({ label: "segmentation_command_encoder" });
+		const bindGroup = this.device.createBindGroup({
+			label: "segmentation_bind_group",
+			layout: this.computePipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: inputTexture.createView({ label: "segmentation_input_view" })
+				},
+				{
+					binding: 1,
+					resource: this.cachedOutputTexture.createView({ label: "segmentation_output_view" })
+				},
+				{
+					binding: 2,
+					resource: { buffer: this.uniformBuffer }
+				}
+			]
+		});
+		const pass = commandEncoder.beginComputePass({ label: "segmentation_compute_pass" });
+		pass.setPipeline(this.computePipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16), 1);
+		pass.end();
+		this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	destroy() {
+		this.cachedOutputTexture?.destroy();
+		this.cachedOutputTexture = void 0;
+		this.uniformBuffer.destroy();
+	}
+};
+/**
+* @file temporal-warp-blend.wgsl.ts
+* Native WebGPU Forward Warping & Adaptive Photometric Temporal Blend Compute Shaders
+* Warps previous frame forward along motion vectors and blends adaptively with current
+* frame to eliminate generative AI video flicker with zero ghosting.
+*/
+const temporalWarpBlendRgba8Wgsl = `
+struct WarpBlendParams {
+  width: u32,
+  height: u32,
+  blendWeight: f32,            // Base current frame weight alpha (e.g. 0.35)
+  disocclusionThreshold: f32,  // Photometric error cutoff for fallback to curr frame
+  maxMotionPixels: f32,        // Speed cutoff for fallback to curr frame
+  isFirstFrame: f32,           // 1.0 = pass-through first frame, 0.0 = temporal blend
+  _pad0: f32,
+  _pad1: f32,
+};
+
+@group(0) @binding(0) var prevTex: texture_2d<f32>;
+@group(0) @binding(1) var currTex: texture_2d<f32>;
+@group(0) @binding(2) var flowTex: texture_2d<f32>;
+@group(0) @binding(3) var outTex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(4) var<uniform> params: WarpBlendParams;
+@group(0) @binding(5) var bilinearSamp: sampler;
+
+@compute @workgroup_size(16, 16)
+fn warpBlend(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let coord = vec2<i32>(i32(id.x), i32(id.y));
+  let currColor = textureLoad(currTex, coord, 0);
+
+  // If first frame or scene cut reset, pass through current frame directly
+  if (params.isFirstFrame > 0.5) {
+    textureStore(outTex, id.xy, currColor);
+    return;
+  }
+
+  let dims = vec2<f32>(f32(params.width), f32(params.height));
+  let invDims = vec2<f32>(1.0 / dims.x, 1.0 / dims.y);
+  let uv = (vec2<f32>(id.xy) + 0.5) * invDims;
+
+  // Read motion vector (u, v) in pixel units
+  let flowSample = textureLoad(flowTex, coord, 0);
+  let flow = flowSample.xy;
+  let speed = length(flow);
+
+  // Motion-compensated backward warp coordinate pointing to previous frame
+  let warpedUv = clamp(uv - flow * invDims, vec2<f32>(0.0), vec2<f32>(1.0));
+  let warpedPrev = textureSampleLevel(prevTex, bilinearSamp, warpedUv, 0.0);
+
+  // Photometric consistency error normalized to [0, 1] range (1 / sqrt(3) ~= 0.57735027)
+  let colorDiff = length(currColor.rgb - warpedPrev.rgb) * 0.57735027;
+
+  // Adaptive blend weight:
+  // - Coherent motion (low diff, low speed): alpha = blendWeight (strong deflicker smoothing)
+  // - Disocclusion or extreme motion (high diff): alpha -> 1.0 (fall back to curr frame, no ghosting)
+  let tLow = params.disocclusionThreshold;
+  let tHigh = params.disocclusionThreshold * 1.5;
+  let errFactor = smoothstep(tLow, tHigh, colorDiff);
+  let speedFactor = smoothstep(params.maxMotionPixels * 0.5, params.maxMotionPixels, speed);
+
+  let fallbackFactor = max(errFactor, speedFactor);
+  let alpha = clamp(mix(params.blendWeight, 1.0, fallbackFactor), 0.0, 1.0);
+
+  let blendedRgb = mix(warpedPrev.rgb, currColor.rgb, alpha);
+  let blendedA = mix(warpedPrev.a, currColor.a, alpha);
+
+  textureStore(outTex, id.xy, vec4<f32>(blendedRgb, blendedA));
+}
+`;
+const temporalWarpBlendRgba16fWgsl = `
+struct WarpBlendParams {
+  width: u32,
+  height: u32,
+  blendWeight: f32,
+  disocclusionThreshold: f32,
+  maxMotionPixels: f32,
+  isFirstFrame: f32,
+  _pad0: f32,
+  _pad1: f32,
+};
+
+@group(0) @binding(0) var prevTex: texture_2d<f32>;
+@group(0) @binding(1) var currTex: texture_2d<f32>;
+@group(0) @binding(2) var flowTex: texture_2d<f32>;
+@group(0) @binding(3) var outTex: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(4) var<uniform> params: WarpBlendParams;
+@group(0) @binding(5) var bilinearSamp: sampler;
+
+@compute @workgroup_size(16, 16)
+fn warpBlend(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.width || id.y >= params.height) {
+    return;
+  }
+
+  let coord = vec2<i32>(i32(id.x), i32(id.y));
+  let currColor = textureLoad(currTex, coord, 0);
+
+  if (params.isFirstFrame > 0.5) {
+    textureStore(outTex, id.xy, currColor);
+    return;
+  }
+
+  let dims = vec2<f32>(f32(params.width), f32(params.height));
+  let invDims = vec2<f32>(1.0 / dims.x, 1.0 / dims.y);
+  let uv = (vec2<f32>(id.xy) + 0.5) * invDims;
+
+  let flowSample = textureLoad(flowTex, coord, 0);
+  let flow = flowSample.xy;
+  let speed = length(flow);
+
+  let warpedUv = clamp(uv - flow * invDims, vec2<f32>(0.0), vec2<f32>(1.0));
+  let warpedPrev = textureSampleLevel(prevTex, bilinearSamp, warpedUv, 0.0);
+
+  // Photometric consistency error normalized to [0, 1] range (1 / sqrt(3) ~= 0.57735027)
+  let colorDiff = length(currColor.rgb - warpedPrev.rgb) * 0.57735027;
+
+  let tLow = params.disocclusionThreshold;
+  let tHigh = params.disocclusionThreshold * 1.5;
+  let errFactor = smoothstep(tLow, tHigh, colorDiff);
+  let speedFactor = smoothstep(params.maxMotionPixels * 0.5, params.maxMotionPixels, speed);
+
+  let fallbackFactor = max(errFactor, speedFactor);
+  let alpha = clamp(mix(params.blendWeight, 1.0, fallbackFactor), 0.0, 1.0);
+
+  let blendedRgb = mix(warpedPrev.rgb, currColor.rgb, alpha);
+  let blendedA = mix(warpedPrev.a, currColor.a, alpha);
+
+  textureStore(outTex, id.xy, vec4<f32>(blendedRgb, blendedA));
+}
+`;
+var TemporalDeflickerPipeline = class {
+	flowPipeline;
+	rgba8Pipeline;
+	rgba16fPipeline;
+	uniformBuffer;
+	bilinearSampler;
+	historyTexture;
+	cachedOutputTexture;
+	constructor(device) {
+		this.device = device;
+		this.flowPipeline = new OpticalFlowComputePipeline(device);
+		const rgba8Module = device.createShaderModule({
+			label: "temporal_warp_blend_rgba8.wgsl",
+			code: temporalWarpBlendRgba8Wgsl
+		});
+		this.rgba8Pipeline = device.createComputePipeline({
+			label: "TemporalWarpBlendRgba8Pipeline",
+			layout: "auto",
+			compute: {
+				module: rgba8Module,
+				entryPoint: "warpBlend"
+			}
+		});
+		const rgba16fModule = device.createShaderModule({
+			label: "temporal_warp_blend_rgba16f.wgsl",
+			code: temporalWarpBlendRgba16fWgsl
+		});
+		this.rgba16fPipeline = device.createComputePipeline({
+			label: "TemporalWarpBlendRgba16fPipeline",
+			layout: "auto",
+			compute: {
+				module: rgba16fModule,
+				entryPoint: "warpBlend"
+			}
+		});
+		this.uniformBuffer = device.createBuffer({
+			size: 32,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			label: "temporal_deflicker_uniform"
+		});
+		this.bilinearSampler = device.createSampler({
+			label: "temporal_deflicker_sampler",
+			magFilter: "linear",
+			minFilter: "linear",
+			addressModeU: "clamp-to-edge",
+			addressModeV: "clamp-to-edge"
+		});
+	}
+	execute(currTexture, options = {}, customEncoder) {
+		const width = currTexture.width;
+		const height = currTexture.height;
+		const rawBlendWeight = options.blendWeight ?? .35;
+		const blendWeight = typeof rawBlendWeight === "number" ? rawBlendWeight : Number(rawBlendWeight);
+		const disocclusionThreshold = options.disocclusionThreshold ?? .15;
+		const maxMotionPixels = options.maxMotionPixels ?? 64;
+		const format = currTexture.format;
+		const isRgba16f = format === "rgba16float";
+		if (!this.cachedOutputTexture || this.cachedOutputTexture.width !== width || this.cachedOutputTexture.height !== height || this.cachedOutputTexture.format !== format) {
+			this.cachedOutputTexture?.destroy();
+			this.cachedOutputTexture = this.device.createTexture({
+				label: `deflickered_output_${format}`,
+				size: [width, height],
+				format,
+				usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+			});
+		}
+		if (!this.historyTexture || this.historyTexture.width !== width || this.historyTexture.height !== height) {
+			this.historyTexture?.destroy();
+			this.historyTexture = this.device.createTexture({
+				label: "deflicker_history_texture",
+				size: [width, height],
+				format,
+				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC
+			});
+			const commandEncoder$1 = customEncoder ?? this.device.createCommandEncoder({ label: "deflicker_first_frame_encoder" });
+			commandEncoder$1.copyTextureToTexture({ texture: currTexture }, { texture: this.historyTexture }, [width, height]);
+			commandEncoder$1.copyTextureToTexture({ texture: currTexture }, { texture: this.cachedOutputTexture }, [width, height]);
+			if (!customEncoder) this.device.queue.submit([commandEncoder$1.finish()]);
+			return this.cachedOutputTexture;
+		}
+		const flowTexture = this.flowPipeline.execute(this.historyTexture, currTexture, options.opticalFlow, customEncoder);
+		const uniformData = /* @__PURE__ */ new ArrayBuffer(32);
+		const u32View = new Uint32Array(uniformData);
+		const f32View = new Float32Array(uniformData);
+		u32View[0] = width;
+		u32View[1] = height;
+		f32View[2] = blendWeight;
+		f32View[3] = disocclusionThreshold;
+		f32View[4] = maxMotionPixels;
+		f32View[5] = 0;
+		this.device.queue.writeBuffer(this.uniformBuffer, 0, uniformData);
+		const pipeline = isRgba16f ? this.rgba16fPipeline : this.rgba8Pipeline;
+		const commandEncoder = customEncoder ?? this.device.createCommandEncoder({ label: "deflicker_blend_encoder" });
+		const bindGroup = this.device.createBindGroup({
+			layout: pipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: this.historyTexture.createView()
+				},
+				{
+					binding: 1,
+					resource: currTexture.createView()
+				},
+				{
+					binding: 2,
+					resource: flowTexture.createView()
+				},
+				{
+					binding: 3,
+					resource: this.cachedOutputTexture.createView()
+				},
+				{
+					binding: 4,
+					resource: { buffer: this.uniformBuffer }
+				},
+				{
+					binding: 5,
+					resource: this.bilinearSampler
+				}
+			]
+		});
+		const pass = commandEncoder.beginComputePass({ label: "deflicker_blend_pass" });
+		pass.setPipeline(pipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(height / 16));
+		pass.end();
+		commandEncoder.copyTextureToTexture({ texture: this.cachedOutputTexture }, { texture: this.historyTexture }, [width, height]);
+		if (!customEncoder) this.device.queue.submit([commandEncoder.finish()]);
+		return this.cachedOutputTexture;
+	}
+	reset() {
+		this.historyTexture?.destroy();
+		this.historyTexture = void 0;
+	}
+	destroy() {
+		this.flowPipeline.destroy();
+		this.historyTexture?.destroy();
+		this.cachedOutputTexture?.destroy();
+		this.uniformBuffer.destroy();
+	}
+};
+var TensorPipeline = class TensorPipeline$1 {
+	id;
+	cannyOptions;
+	depthNormalsOptions;
+	poseSkeletonOptions;
+	faceLandmarksOptions;
+	segmentationOptions;
+	opticalFlowOptions;
+	deflickerOptions;
+	multiplexer = new ControlNetMultiplexer();
+	cannyPipeline;
+	depthNormalsPipeline;
+	posePipeline;
+	facePipeline;
+	segmentationPipeline;
+	opticalFlowPipeline;
+	deflickerPipeline;
+	prevInputTexture;
+	constructor(source) {
+		this.source = source;
+		this.id = `tensor-${Math.random().toString(36).slice(2, 9)}`;
+	}
+	static from(source) {
+		return new TensorPipeline$1(source);
+	}
+	canny(options = {}) {
+		this.cannyOptions = options;
+		return this;
+	}
+	depthNormals(options = {}) {
+		this.depthNormalsOptions = options;
+		return this;
+	}
+	poseSkeleton(options = {}) {
+		this.poseSkeletonOptions = options;
+		return this;
+	}
+	pose(landmarks, options = {}) {
+		this.poseSkeletonOptions = {
+			...options,
+			landmarks
+		};
+		return this;
+	}
+	faceLandmarks(options = {}) {
+		this.faceLandmarksOptions = options;
+		return this;
+	}
+	face(landmarks, options = {}) {
+		this.faceLandmarksOptions = {
+			...options,
+			landmarks
+		};
+		return this;
+	}
+	segmentation(options = {}) {
+		this.segmentationOptions = options;
+		return this;
+	}
+	opticalFlow(options = {}) {
+		this.opticalFlowOptions = options;
+		return this;
+	}
+	deflicker(options = {}) {
+		this.deflickerOptions = options;
+		return this;
+	}
+	getMultiplexer() {
+		return this.multiplexer;
+	}
+	async execute(device, overrideSourceTexture) {
+		let inputTexture = overrideSourceTexture;
+		if (!inputTexture && typeof this.source?.createView === "function") inputTexture = this.source;
+		if (!inputTexture) throw new Error("[TensorPipeline.execute] No GPUTexture available for tensor compute execution. Pass a valid GPUTexture to execute() or initialize with a GPUTexture source.");
+		if (this.cannyOptions) {
+			if (!this.cannyPipeline) this.cannyPipeline = new CannyComputePipeline(device);
+			const cannyTex = this.cannyPipeline.execute(inputTexture, this.cannyOptions);
+			this.multiplexer.set("canny", cannyTex);
+		}
+		if (this.depthNormalsOptions) {
+			if (!this.depthNormalsPipeline) this.depthNormalsPipeline = new DepthNormalsComputePipeline(device);
+			const normalTex = this.depthNormalsPipeline.execute(inputTexture, this.depthNormalsOptions);
+			this.multiplexer.set("normals", normalTex);
+		}
+		if (this.poseSkeletonOptions?.landmarks) {
+			if (!this.posePipeline) this.posePipeline = new PoseSkeletonComputePipeline(device);
+			const skeletonTex = this.posePipeline.execute(this.poseSkeletonOptions.landmarks, {
+				width: this.poseSkeletonOptions.width ?? inputTexture.width,
+				height: this.poseSkeletonOptions.height ?? inputTexture.height,
+				lineWidth: this.poseSkeletonOptions.lineWidth
+			});
+			this.multiplexer.set("poseSkeleton", skeletonTex);
+		}
+		if (this.faceLandmarksOptions?.landmarks) {
+			if (!this.facePipeline) this.facePipeline = new FaceLandmarksComputePipeline(device);
+			const faceTex = this.facePipeline.execute(this.faceLandmarksOptions.landmarks, {
+				width: this.faceLandmarksOptions.width ?? inputTexture.width,
+				height: this.faceLandmarksOptions.height ?? inputTexture.height,
+				lineWidth: this.faceLandmarksOptions.lineWidth
+			});
+			this.multiplexer.set("faceLandmarks", faceTex);
+		}
+		if (this.segmentationOptions) {
+			if (!this.segmentationPipeline) this.segmentationPipeline = new SegmentationComputePipeline(device);
+			const segTex = this.segmentationPipeline.execute(inputTexture, this.segmentationOptions);
+			this.multiplexer.set("segmentationMask", segTex);
+		}
+		if (this.opticalFlowOptions) {
+			if (!this.opticalFlowPipeline) this.opticalFlowPipeline = new OpticalFlowComputePipeline(device);
+			const prevTex = this.prevInputTexture ?? inputTexture;
+			const flowTex = this.opticalFlowPipeline.execute(prevTex, inputTexture, this.opticalFlowOptions);
+			this.multiplexer.set("motionVectors", flowTex);
+		}
+		if (this.deflickerOptions) {
+			if (!this.deflickerPipeline) this.deflickerPipeline = new TemporalDeflickerPipeline(device);
+			const deflickeredTex = this.deflickerPipeline.execute(inputTexture, this.deflickerOptions);
+			this.multiplexer.set("deflickered", deflickeredTex);
+		}
+		this.prevInputTexture = inputTexture;
+		return this.multiplexer.getOutputs();
+	}
+	toConfig() {
+		return {
+			canny: this.cannyOptions,
+			depthNormals: this.depthNormalsOptions,
+			poseSkeleton: this.poseSkeletonOptions,
+			faceLandmarks: this.faceLandmarksOptions,
+			segmentation: this.segmentationOptions,
+			opticalFlow: this.opticalFlowOptions,
+			deflicker: this.deflickerOptions
+		};
+	}
+	toNode() {
+		return {
+			id: this.id,
+			kind: "tensor",
+			source: this.source,
+			config: this.toConfig()
+		};
+	}
+	destroy() {
+		this.cannyPipeline?.destroy();
+		this.depthNormalsPipeline?.destroy();
+		this.posePipeline?.destroy();
+		this.facePipeline?.destroy();
+		this.segmentationPipeline?.destroy();
+		this.opticalFlowPipeline?.destroy();
+		this.deflickerPipeline?.destroy();
+		this.multiplexer.destroy();
+	}
+};
+
+//#endregion
+export { PoseSkeletonComputePipeline as a, OpticalFlowComputePipeline as i, ControlNetMultiplexer as n, TemporalDeflickerPipeline as o, DepthNormalsComputePipeline as r, TensorPipeline as s, CannyComputePipeline as t };
+//# sourceMappingURL=dist-C_hjvkdN.mjs.map