@nodetool-ai/gpu 0.8.1

package/dist/shaders/alpha/premulToStraight/v1/module.js

@@ -0,0 +1,62 @@
+/**
+ * `alpha.premulToStraight@1` — convert premultiplied-alpha RGB to straight.
+ *
+ * Per-pixel `vec4(rgb, a) → vec4(rgb / a, a)` (transparent pixels collapse to
+ * `vec4(0)`). The inverse of
+ * {@link ./../straightToPremul/v1/module alphaStraightToPremulV1}; the two
+ * exist so hosts can bridge straight↔premultiplied boundaries explicitly
+ * instead of letting metadata drift.
+ *
+ * Output color space matches input — this module touches association only.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+const ConvertParams = d.struct({ _unused: d.f32 });
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" }
+});
+export const alphaPremulToStraightV1 = defineModule({
+    id: "alpha.premulToStraight",
+    version: 1,
+    surface: "internal",
+    category: "alpha",
+    linearity: "nonlinear-in-rgb",
+    kind: "compute",
+    params: ConvertParams,
+    paramDefaults: { _unused: 0 },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+@compute @workgroup_size(16, 16, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let dims = textureDimensions(layout.$.source);
+  if (gid.x >= dims.x || gid.y >= dims.y) { return; }
+  let coords = vec2<i32>(i32(gid.x), i32(gid.y));
+  let c = textureLoad(layout.$.source, coords, 0);
+  if (c.a <= 0.0) {
+    textureStore(layout.$.outputTexture, coords, vec4<f32>(0.0));
+    return;
+  }
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(c.rgb / c.a, c.a));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "straight",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/alpha/premulToStraight/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/alpha/premulToStraight/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AAEnD,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,aAAa,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;CAChD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CAAC;IAClD,EAAE,EAAE,wBAAwB;IAC5B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE;IAC7B,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;CAalB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,UAAU;YACjB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/alpha/straightToPremul/v1/module.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `alpha.straightToPremul@1` — convert straight-alpha RGB to premultiplied.
+ *
+ * Per-pixel `vec4(rgb, a) → vec4(rgb * a, a)`. Pairs with
+ * {@link ./../premulToStraight/v1/module premulToStraightV1} as the two
+ * canonical alpha boundary modules. The Executor's strict input validation
+ * (Phase 3) catches alpha-association mismatches between modules; hosts insert
+ * one of these passes explicitly to bridge a straight ingress (e.g. video
+ * `copyExternalImageToTexture` with `premultipliedAlpha: false`) into a chain
+ * of premultiplied modules.
+ *
+ * Output color space matches input — this module touches association only, not
+ * the encoding curve.
+ */
+import * as d from "typegpu/data";
+export declare const alphaStraightToPremulV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    _unused: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/alpha/straightToPremul/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/alpha/straightToPremul/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAUlC,eAAO,MAAM,uBAAuB;;GAqClC,CAAC"}

package/dist/shaders/alpha/straightToPremul/v1/module.js

@@ -0,0 +1,61 @@
+/**
+ * `alpha.straightToPremul@1` — convert straight-alpha RGB to premultiplied.
+ *
+ * Per-pixel `vec4(rgb, a) → vec4(rgb * a, a)`. Pairs with
+ * {@link ./../premulToStraight/v1/module premulToStraightV1} as the two
+ * canonical alpha boundary modules. The Executor's strict input validation
+ * (Phase 3) catches alpha-association mismatches between modules; hosts insert
+ * one of these passes explicitly to bridge a straight ingress (e.g. video
+ * `copyExternalImageToTexture` with `premultipliedAlpha: false`) into a chain
+ * of premultiplied modules.
+ *
+ * Output color space matches input — this module touches association only, not
+ * the encoding curve.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+const ConvertParams = d.struct({ _unused: d.f32 });
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" }
+});
+export const alphaStraightToPremulV1 = defineModule({
+    id: "alpha.straightToPremul",
+    version: 1,
+    surface: "internal",
+    category: "alpha",
+    linearity: "linear-in-rgb",
+    kind: "compute",
+    params: ConvertParams,
+    paramDefaults: { _unused: 0 },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+@compute @workgroup_size(16, 16, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let dims = textureDimensions(layout.$.source);
+  if (gid.x >= dims.x || gid.y >= dims.y) { return; }
+  let coords = vec2<i32>(i32(gid.x), i32(gid.y));
+  let c = textureLoad(layout.$.source, coords, 0);
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(c.rgb * c.a, c.a));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "straight",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/alpha/straightToPremul/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/alpha/straightToPremul/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AAEnD,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,aAAa,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;CAChD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CAAC;IAClD,EAAE,EAAE,wBAAwB;IAC5B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE;IAC7B,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;CASlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,UAAU;gBACjB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/brightnessContrast/v1/module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `color.brightnessContrast@1` — additive brightness, multiplicative contrast.
+ *
+ * Math matches the timeline preview's color-correction stage (also used by
+ * `color.grade@1`): `rgb = (rgb - 0.5) * contrast + 0.5 + brightness`, clamped
+ * to `[0, 1]`. Fragment, with the canonical mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const BrightnessContrastParams: d.WgslStruct<{
+    brightness: d.F32;
+    contrast: d.F32;
+}>;
+export declare const colorBrightnessContrastV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    brightness: d.F32;
+    contrast: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/brightnessContrast/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/brightnessContrast/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,wBAAwB;;;EAGnC,CAAC;AAgBH,eAAO,MAAM,yBAAyB;;;GAwDpC,CAAC"}

package/dist/shaders/color/brightnessContrast/v1/module.js

@@ -0,0 +1,84 @@
+/**
+ * `color.brightnessContrast@1` — additive brightness, multiplicative contrast.
+ *
+ * Math matches the timeline preview's color-correction stage (also used by
+ * `color.grade@1`): `rgb = (rgb - 0.5) * contrast + 0.5 + brightness`, clamped
+ * to `[0, 1]`. Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const BrightnessContrastParams = d.struct({
+    brightness: d.f32,
+    contrast: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: BrightnessContrastParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorBrightnessContrastV1 = defineModule({
+    id: "color.brightnessContrast",
+    version: 1,
+    // Same math as `color.grade`'s sub-stage, exposed as its own op for workflow
+    // nodes that only need brightness/contrast.
+    surface: "published",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: BrightnessContrastParams,
+    paramDefaults: { brightness: 0, contrast: 1 },
+    paramUi: {
+        brightness: { min: -1, max: 1, step: 0.01, label: "Brightness" },
+        contrast: { min: 0, max: 4, step: 0.01, label: "Contrast" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  // Brightness/contrast is a straight-color formula; un-premultiply first so
+  // the operation acts on the underlying color, then re-premultiply on store.
+  // Applying the formula to premultiplied RGB silently scales each adjustment
+  // by a and breaks the rgb <= a invariant for transparent regions.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let adjusted = clamp((straight - vec3f(0.5)) * p.contrast + vec3f(0.5) + vec3f(p.brightness), vec3f(0.0), vec3f(1.0));
+  let mixedStraight = mix(straight, adjusted, coverage);
+  return vec4f(mixedStraight * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/brightnessContrast/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/brightnessContrast/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,wBAAwB,EAAE;IAC7C,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,YAAY,CAAC;IACpD,EAAE,EAAE,0BAA0B;IAC9B,OAAO,EAAE,CAAC;IACV,6EAA6E;IAC7E,4CAA4C;IAC5C,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,wBAAwB;IAChC,aAAa,EAAE,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE;IAC7C,OAAO,EAAE;QACP,UAAU,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;QAChE,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;KAC5D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/cdl/v1/module.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `color.cdl@1` — ASC CDL (Color Decision List) primary correction.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.CDL` loop:
+ * `out = clamp(in * slope + offset, 0, 1) ^ power`, followed by a luminance-
+ * preserving saturation adjustment. The industry-standard exchange formula for
+ * trading colour grades between tools. Fragment, with the canonical optional
+ * mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const CdlParams: d.WgslStruct<{
+    slopeR: d.F32;
+    slopeG: d.F32;
+    slopeB: d.F32;
+    offsetR: d.F32;
+    offsetG: d.F32;
+    offsetB: d.F32;
+    powerR: d.F32;
+    powerG: d.F32;
+    powerB: d.F32;
+    saturation: d.F32;
+}>;
+export declare const colorCdlV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    slopeR: d.F32;
+    slopeG: d.F32;
+    slopeB: d.F32;
+    offsetR: d.F32;
+    offsetG: d.F32;
+    offsetB: d.F32;
+    powerR: d.F32;
+    powerG: d.F32;
+    powerB: d.F32;
+    saturation: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/cdl/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/cdl/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,SAAS;;;;;;;;;;;EAWpB,CAAC;AAgBH,eAAO,MAAM,UAAU;;;;;;;;;;;GAmErB,CAAC"}

package/dist/shaders/color/cdl/v1/module.js

@@ -0,0 +1,106 @@
+/**
+ * `color.cdl@1` — ASC CDL (Color Decision List) primary correction.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.CDL` loop:
+ * `out = clamp(in * slope + offset, 0, 1) ^ power`, followed by a luminance-
+ * preserving saturation adjustment. The industry-standard exchange formula for
+ * trading colour grades between tools. Fragment, with the canonical optional
+ * mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const CdlParams = d.struct({
+    slopeR: d.f32,
+    slopeG: d.f32,
+    slopeB: d.f32,
+    offsetR: d.f32,
+    offsetG: d.f32,
+    offsetB: d.f32,
+    powerR: d.f32,
+    powerG: d.f32,
+    powerB: d.f32,
+    saturation: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CdlParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorCdlV1 = defineModule({
+    id: "color.cdl",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: CdlParams,
+    paramDefaults: {
+        slopeR: 1,
+        slopeG: 1,
+        slopeB: 1,
+        offsetR: 0,
+        offsetG: 0,
+        offsetB: 0,
+        powerR: 1,
+        powerG: 1,
+        powerB: 1,
+        saturation: 1
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+${WGSL_LUMA709}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let slope = vec3f(p.slopeR, p.slopeG, p.slopeB);
+  let offset = vec3f(p.offsetR, p.offsetG, p.offsetB);
+  let power = vec3f(p.powerR, p.powerG, p.powerB);
+  // Clamp after slope/offset (matches the CPU loop) so pow() sees [0,1] and
+  // never takes a negative base.
+  var rgb = clamp(straight * slope + offset, vec3f(0.0), vec3f(1.0));
+  rgb = pow(rgb, power);
+  let lum = luma709(rgb);
+  rgb = vec3f(lum) + (rgb - vec3f(lum)) * p.saturation;
+  let mixed = mix(straight, rgb, coverage);
+  return vec4f(clamp(mixed, vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/cdl/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/cdl/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,UAAU,EAAE,CAAC,CAAC,GAAG;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE;IAC9B,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG,YAAY,CAAC;IACrC,EAAE,EAAE,WAAW;IACf,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,SAAS;IACjB,aAAa,EAAE;QACb,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;QACV,OAAO,EAAE,CAAC;QACV,OAAO,EAAE,CAAC;QACV,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,UAAU,EAAE,CAAC;KACd;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,YAAY;;;;;;;;;;;;;;;;;;;;;CAqBb;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/channelMerge/v1/module.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `color.channelMerge@1` — merge RGB from `source` with a single-channel alpha
+ * lifted from a second texture.
+ *
+ * `alphaChannel` selects which channel of the `alpha` input drives output
+ * alpha (`0` R, `1` G, `2` B, `3` A, `4` luma). The RGB of `source` is
+ * carried straight through; the result is then re-premultiplied with the new
+ * alpha so downstream consumers see the pool's canonical premultiplied form.
+ *
+ * Pairs with `color.channelSplit` (extract a channel as grayscale) and
+ * `mask.fromImage` (extract a coverage mask) — together they form the
+ * minimum-viable "swap an image's alpha for another image's channel"
+ * pipeline.
+ */
+import * as d from "typegpu/data";
+export declare const ChannelMergeParams: d.WgslStruct<{
+    alphaChannel: d.F32;
+}>;
+export declare const colorChannelMergeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    alphaChannel: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/channelMerge/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/channelMerge/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,kBAAkB;;EAE7B,CAAC;AAgBH,eAAO,MAAM,mBAAmB;;GAmE9B,CAAC"}

package/dist/shaders/color/channelMerge/v1/module.js

@@ -0,0 +1,101 @@
+/**
+ * `color.channelMerge@1` — merge RGB from `source` with a single-channel alpha
+ * lifted from a second texture.
+ *
+ * `alphaChannel` selects which channel of the `alpha` input drives output
+ * alpha (`0` R, `1` G, `2` B, `3` A, `4` luma). The RGB of `source` is
+ * carried straight through; the result is then re-premultiplied with the new
+ * alpha so downstream consumers see the pool's canonical premultiplied form.
+ *
+ * Pairs with `color.channelSplit` (extract a channel as grayscale) and
+ * `mask.fromImage` (extract a coverage mask) — together they form the
+ * minimum-viable "swap an image's alpha for another image's channel"
+ * pipeline.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ChannelMergeParams = d.struct({
+    alphaChannel: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ChannelMergeParams },
+    source: { texture: "float" },
+    alpha: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorChannelMergeV1 = defineModule({
+    id: "color.channelMerge",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ChannelMergeParams,
+    paramDefaults: { alphaChannel: 3 },
+    paramUi: {
+        alphaChannel: {
+            min: 0,
+            max: 4,
+            step: 1,
+            label: "Alpha source",
+            notes: "0 R / 1 G / 2 B / 3 A / 4 luma"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let alphaSrc = textureSample(layout.$.alpha, layout.$.samp, uv);
+  let mode = i32(round(layout.$.params.alphaChannel));
+  var newA: f32 = 0.0;
+  if (mode == 0) {
+    newA = alphaSrc.r;
+  } else if (mode == 1) {
+    newA = alphaSrc.g;
+  } else if (mode == 2) {
+    newA = alphaSrc.b;
+  } else if (mode == 3) {
+    newA = alphaSrc.a;
+  } else {
+    newA = dot(alphaSrc.rgb, vec3f(0.299, 0.587, 0.114));
+  }
+  newA = clamp(newA, 0.0, 1.0);
+  // Un-premultiply source RGB by its own alpha, then re-premultiply with the
+  // new alpha so downstream consumers see canonical premultiplied output.
+  let safeA = max(src.a, 0.0001);
+  let straightRgb = src.rgb / safeA;
+  return vec4f(straightRgb * newA, newA);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            alpha: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/channelMerge/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/channelMerge/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,YAAY,EAAE,CAAC,CAAC,GAAG;CACpB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,kBAAkB,EAAE;IACvC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC3B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC;IAC9C,EAAE,EAAE,oBAAoB;IACxB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,kBAAkB;IAC1B,aAAa,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE;IAClC,OAAO,EAAE;QACP,YAAY,EAAE;YACZ,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,cAAc;YACrB,KAAK,EAAE,gCAAgC;SACxC;KACF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,KAAK,EAAE;gBACL,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/channelShuffle/v1/module.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `color.channelShuffle@1` — permute / rebroadcast source channels onto the
+ * output.
+ *
+ * Four integer indices (`rFrom`, `gFrom`, `bFrom`, `aFrom`) pick which input
+ * channel feeds each output channel: `0` R, `1` G, `2` B, `3` A. The
+ * identity permutation `(0, 1, 2, 3)` is passthrough; common swaps include
+ * RGB↔BGR (`2, 1, 0, 3`) and "alpha to grayscale" (`3, 3, 3, 3`).
+ *
+ * Premultiplication: the pool's contract is that alpha is premultiplied
+ * between modules, so the shader un-premultiplies the source's RGB by its
+ * original alpha before picking, then re-premultiplies the result by the
+ * shuffled output alpha. That keeps the canonical premultiplied invariant
+ * intact regardless of which input channel `aFrom` points at.
+ */
+import * as d from "typegpu/data";
+export declare const ChannelShuffleParams: d.WgslStruct<{
+    rFrom: d.F32;
+    gFrom: d.F32;
+    bFrom: d.F32;
+    aFrom: d.F32;
+}>;
+export declare const colorChannelShuffleV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    rFrom: d.F32;
+    gFrom: d.F32;
+    bFrom: d.F32;
+    aFrom: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/channelShuffle/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/channelShuffle/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,oBAAoB;;;;;EAK/B,CAAC;AAeH,eAAO,MAAM,qBAAqB;;;;;GAyDhC,CAAC"}