@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,116 @@
+/**
+ * `color.levels@1` — per-channel input black point, gamma, and white point.
+ *
+ * For each of R/G/B independently: remap `[black, white]` onto `[0, 1]` then
+ * apply gamma — `out = pow(clamp((in - black) / (white - black), 0, 1), 1/gamma)`.
+ * `black`/`white` are normalized to `[0, 1]` (the host divides 0–255 inputs by
+ * 255); `gamma` is the channel gamma. The identity is `black=0, gamma=1,
+ * white=1`. Alpha is untouched. Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const LevelsParams = d.struct({
+    rBlack: d.f32,
+    rGamma: d.f32,
+    rWhite: d.f32,
+    gBlack: d.f32,
+    gGamma: d.f32,
+    gWhite: d.f32,
+    bBlack: d.f32,
+    bGamma: d.f32,
+    bWhite: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: LevelsParams },
+    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 colorLevelsV1 = defineModule({
+    id: "color.levels",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: LevelsParams,
+    paramDefaults: {
+        rBlack: 0,
+        rGamma: 1,
+        rWhite: 1,
+        gBlack: 0,
+        gGamma: 1,
+        gWhite: 1,
+        bBlack: 0,
+        bGamma: 1,
+        bWhite: 1
+    },
+    paramUi: {
+        rBlack: { min: 0, max: 1, step: 0.01, label: "Red black" },
+        rGamma: { min: 0.01, max: 10, step: 0.01, label: "Red gamma" },
+        rWhite: { min: 0, max: 1, step: 0.01, label: "Red white" },
+        gBlack: { min: 0, max: 1, step: 0.01, label: "Green black" },
+        gGamma: { min: 0.01, max: 10, step: 0.01, label: "Green gamma" },
+        gWhite: { min: 0, max: 1, step: 0.01, label: "Green white" },
+        bBlack: { min: 0, max: 1, step: 0.01, label: "Blue black" },
+        bGamma: { min: 0.01, max: 10, step: 0.01, label: "Blue gamma" },
+        bWhite: { min: 0, max: 1, step: 0.01, label: "Blue white" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn levelChannel(x: f32, black: f32, gamma: f32, white: f32) -> f32 {
+  let denom = max(1.0 / 255.0, white - black);
+  let t = clamp((x - black) / denom, 0.0, 1.0);
+  return pow(t, 1.0 / max(0.01, gamma));
+}
+
+@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;
+  // Operate on straight (un-premultiplied) color so the per-channel remap is
+  // correct on partial-alpha pixels, then re-premultiply on output.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let p = layout.$.params;
+  let leveled = vec3f(
+    levelChannel(straight.r, p.rBlack, p.rGamma, p.rWhite),
+    levelChannel(straight.g, p.gBlack, p.gGamma, p.gWhite),
+    levelChannel(straight.b, p.bBlack, p.bGamma, p.bWhite)
+  );
+  let mixedStraight = mix(straight, clamp(leveled, vec3f(0.0), vec3f(1.0)), 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/levels/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/levels/v1/module.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,40 @@
+/**
+ * `color.liftGammaGain@1` — three-way (shadows / midtones / highlights) color
+ * corrector.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.LiftGammaGain` loop:
+ * `out = ((in + lift) * gain) ^ (1 / gamma)` per channel, with master
+ * multipliers folded into each per-channel knob. Lift shifts shadows, gain
+ * scales highlights, gamma bends midtones. Fragment, with the canonical
+ * optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const LiftGammaGainParams: d.WgslStruct<{
+    liftR: d.F32;
+    liftG: d.F32;
+    liftB: d.F32;
+    liftMaster: d.F32;
+    gammaR: d.F32;
+    gammaG: d.F32;
+    gammaB: d.F32;
+    gammaMaster: d.F32;
+    gainR: d.F32;
+    gainG: d.F32;
+    gainB: d.F32;
+    gainMaster: d.F32;
+}>;
+export declare const colorLiftGammaGainV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    liftR: d.F32;
+    liftG: d.F32;
+    liftB: d.F32;
+    liftMaster: d.F32;
+    gammaR: d.F32;
+    gammaG: d.F32;
+    gammaB: d.F32;
+    gammaMaster: d.F32;
+    gainR: d.F32;
+    gainG: d.F32;
+    gainB: d.F32;
+    gainMaster: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/liftGammaGain/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;EAa9B,CAAC;AAgBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;GAyE/B,CAAC"}

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

@@ -0,0 +1,114 @@
+/**
+ * `color.liftGammaGain@1` — three-way (shadows / midtones / highlights) color
+ * corrector.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.LiftGammaGain` loop:
+ * `out = ((in + lift) * gain) ^ (1 / gamma)` per channel, with master
+ * multipliers folded into each per-channel knob. Lift shifts shadows, gain
+ * scales highlights, gamma bends midtones. Fragment, with the canonical
+ * optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const LiftGammaGainParams = d.struct({
+    liftR: d.f32,
+    liftG: d.f32,
+    liftB: d.f32,
+    liftMaster: d.f32,
+    gammaR: d.f32,
+    gammaG: d.f32,
+    gammaB: d.f32,
+    gammaMaster: d.f32,
+    gainR: d.f32,
+    gainG: d.f32,
+    gainB: d.f32,
+    gainMaster: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: LiftGammaGainParams },
+    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 colorLiftGammaGainV1 = defineModule({
+    id: "color.liftGammaGain",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: LiftGammaGainParams,
+    paramDefaults: {
+        liftR: 0,
+        liftG: 0,
+        liftB: 0,
+        liftMaster: 0,
+        gammaR: 1,
+        gammaG: 1,
+        gammaB: 1,
+        gammaMaster: 1,
+        gainR: 1,
+        gainG: 1,
+        gainB: 1,
+        gainMaster: 1
+    },
+    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;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let lift = vec3f(p.liftR + p.liftMaster, p.liftG + p.liftMaster, p.liftB + p.liftMaster);
+  let gain = vec3f(p.gainR * p.gainMaster, p.gainG * p.gainMaster, p.gainB * p.gainMaster);
+  let r = (straight + lift) * gain;
+  let gammaInv = vec3f(
+    1.0 / max(0.01, p.gammaR * p.gammaMaster),
+    1.0 / max(0.01, p.gammaG * p.gammaMaster),
+    1.0 / max(0.01, p.gammaB * p.gammaMaster)
+  );
+  // pow(negative, x) is undefined; the CPU path returns 0 for r <= 0, so
+  // guard with max() and select the 0 branch to match exactly.
+  var rgb = vec3f(
+    select(0.0, pow(max(r.r, 0.0), gammaInv.r), r.r > 0.0),
+    select(0.0, pow(max(r.g, 0.0), gammaInv.g), r.g > 0.0),
+    select(0.0, pow(max(r.b, 0.0), gammaInv.b), r.b > 0.0)
+  );
+  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/liftGammaGain/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/liftGammaGain/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;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,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,WAAW,EAAE,CAAC,CAAC,GAAG;IAClB,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,UAAU,EAAE,CAAC,CAAC,GAAG;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,mBAAmB,EAAE;IACxC,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,oBAAoB,GAAG,YAAY,CAAC;IAC/C,EAAE,EAAE,qBAAqB;IACzB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,mBAAmB;IAC3B,aAAa,EAAE;QACb,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,CAAC;QACR,UAAU,EAAE,CAAC;QACb,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,WAAW,EAAE,CAAC;QACd,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,CAAC;QACR,UAAU,EAAE,CAAC;KACd;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BlB;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/posterize/v1/module.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `color.posterize@1` — quantize each channel to N levels.
+ *
+ * `levels` clamps to `[2, 256]`. At `levels = 2` the output is binary
+ * per channel (eight discrete colors); at `levels = 256` it's the full
+ * 8-bit range (effectively passthrough — covers PIL `bits=8` semantics).
+ * Fragment, with the canonical mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const PosterizeParams: d.WgslStruct<{
+    levels: d.F32;
+}>;
+export declare const colorPosterizeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    levels: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/posterize/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,eAAe;;EAE1B,CAAC;AAgBH,eAAO,MAAM,gBAAgB;;GAoD3B,CAAC"}

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

@@ -0,0 +1,80 @@
+/**
+ * `color.posterize@1` — quantize each channel to N levels.
+ *
+ * `levels` clamps to `[2, 256]`. At `levels = 2` the output is binary
+ * per channel (eight discrete colors); at `levels = 256` it's the full
+ * 8-bit range (effectively passthrough — covers PIL `bits=8` semantics).
+ * Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const PosterizeParams = d.struct({
+    levels: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: PosterizeParams },
+    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 colorPosterizeV1 = defineModule({
+    id: "color.posterize",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: PosterizeParams,
+    paramDefaults: { levels: 4 },
+    paramUi: {
+        levels: { min: 2, max: 256, step: 1, label: "Levels" }
+    },
+    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 n = max(2.0, min(256.0, layout.$.params.levels));
+  // Quantize the underlying straight color, not the premultiplied RGB; on
+  // partial-alpha pixels the premultiplied form has rgb <= a, so quantizing
+  // before un-premultiplying snaps to the wrong bin and can push rgb > a.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let quantized = floor(clamp(straight, vec3f(0.0), vec3f(1.0)) * n) / (n - 1.0);
+  let mixedStraight = mix(straight, clamp(quantized, vec3f(0.0), vec3f(1.0)), 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/posterize/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/posterize/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;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,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;IACpC,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,gBAAgB,GAAG,YAAY,CAAC;IAC3C,EAAE,EAAE,iBAAiB;IACrB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,eAAe;IACvB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;IAC5B,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE;KACvD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;CAelB;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/solarize/v1/module.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `color.solarize@1` — invert RGB channels whose value exceeds `threshold`.
+ *
+ * Classic PIL `ImageOps.solarize`. Each channel independently: if its value
+ * is greater than `threshold` (0..1), output `1 - v`; otherwise pass through.
+ * Alpha preserved.
+ */
+import * as d from "typegpu/data";
+export declare const SolarizeParams: d.WgslStruct<{
+    threshold: d.F32;
+}>;
+export declare const colorSolarizeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    threshold: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,83 @@
+/**
+ * `color.solarize@1` — invert RGB channels whose value exceeds `threshold`.
+ *
+ * Classic PIL `ImageOps.solarize`. Each channel independently: if its value
+ * is greater than `threshold` (0..1), output `1 - v`; otherwise pass through.
+ * Alpha preserved.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const SolarizeParams = d.struct({
+    threshold: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: SolarizeParams },
+    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 colorSolarizeV1 = defineModule({
+    id: "color.solarize",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: SolarizeParams,
+    paramDefaults: { threshold: 0.5 },
+    paramUi: {
+        threshold: { min: 0, max: 1, step: 0.01, label: "Threshold" }
+    },
+    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 t = layout.$.params.threshold;
+  // Threshold the underlying straight color so the comparison against t is
+  // alpha-independent; otherwise transparent pixels (premultiplied near 0)
+  // are below threshold even when their underlying color is bright.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let inverted = vec3f(
+    select(straight.r, 1.0 - straight.r, straight.r > t),
+    select(straight.g, 1.0 - straight.g, straight.g > t),
+    select(straight.b, 1.0 - straight.b, straight.b > t)
+  );
+  let mixedStraight = mix(straight, inverted, 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/solarize/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/solarize/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,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,SAAS,EAAE,CAAC,CAAC,GAAG;CACjB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE;IACnC,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,eAAe,GAAG,YAAY,CAAC;IAC1C,EAAE,EAAE,gBAAgB;IACpB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE;IACjC,OAAO,EAAE;QACP,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;KAC9D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBlB;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/splitToning/v1/module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `color.splitToning@1` — tint shadows and highlights toward two different
+ * colours.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.SplitToning` loop. The
+ * host resolves the shadow/highlight hues to normalized RGB tint colours
+ * (`hsv→rgb` at full saturation/value) and passes them as `vec3f`s; the shader
+ * weights each toward shadows/highlights by a balance-shifted luminance mask.
+ * Fragment, with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const SplitToningParams: d.WgslStruct<{
+    shadowColor: d.Vec3f;
+    shadowSat: d.F32;
+    highlightColor: d.Vec3f;
+    highlightSat: d.F32;
+    balance: d.F32;
+}>;
+export declare const colorSplitToningV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    shadowColor: d.Vec3f;
+    shadowSat: d.F32;
+    highlightColor: d.Vec3f;
+    highlightSat: d.F32;
+    balance: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/splitToning/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,iBAAiB;;;;;;EAM5B,CAAC;AAgBH,eAAO,MAAM,kBAAkB;;;;;;GA4D7B,CAAC"}

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

@@ -0,0 +1,95 @@
+/**
+ * `color.splitToning@1` — tint shadows and highlights toward two different
+ * colours.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.SplitToning` loop. The
+ * host resolves the shadow/highlight hues to normalized RGB tint colours
+ * (`hsv→rgb` at full saturation/value) and passes them as `vec3f`s; the shader
+ * weights each toward shadows/highlights by a balance-shifted luminance mask.
+ * 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 SplitToningParams = d.struct({
+    shadowColor: d.vec3f,
+    shadowSat: d.f32,
+    highlightColor: d.vec3f,
+    highlightSat: d.f32,
+    balance: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: SplitToningParams },
+    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 colorSplitToningV1 = defineModule({
+    id: "color.splitToning",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: SplitToningParams,
+    paramDefaults: {
+        shadowColor: d.vec3f(0.5, 0.5, 0.5),
+        shadowSat: 0,
+        highlightColor: d.vec3f(0.5, 0.5, 0.5),
+        highlightSat: 0,
+        balance: 0
+    },
+    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 lum = luma709(straight);
+  let balOff = p.balance * 0.25;
+  let shMask = clamp((0.5 + balOff - lum) * 2.0, 0.0, 1.0);
+  let hlMask = clamp((lum - 0.5 + balOff) * 2.0, 0.0, 1.0);
+  let rgb = straight
+    + shMask * (p.shadowColor - vec3f(0.5)) * p.shadowSat
+    + hlMask * (p.highlightColor - vec3f(0.5)) * p.highlightSat;
+  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/splitToning/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/splitToning/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;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,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,WAAW,EAAE,CAAC,CAAC,KAAK;IACpB,SAAS,EAAE,CAAC,CAAC,GAAG;IAChB,cAAc,EAAE,CAAC,CAAC,KAAK;IACvB,YAAY,EAAE,CAAC,CAAC,GAAG;IACnB,OAAO,EAAE,CAAC,CAAC,GAAG;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE;IACtC,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,kBAAkB,GAAG,YAAY,CAAC;IAC7C,EAAE,EAAE,mBAAmB;IACvB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,iBAAiB;IACzB,aAAa,EAAE;QACb,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;QACnC,SAAS,EAAE,CAAC;QACZ,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;QACtC,YAAY,EAAE,CAAC;QACf,OAAO,EAAE,CAAC;KACX;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,YAAY;;;;;;;;;;;;;;;;;;;CAmBb;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/filters/blur/gaussian/v1/module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `filters.blur.gaussian@1` — separable Gaussian blur (one axis per dispatch).
+ *
+ * Migrated verbatim from the timeline preview's `blurComputeShader`. The host
+ * runs it twice — horizontal (`direction = (1,0)`) then vertical
+ * (`direction = (0,1)`) — sharing the same module. The hand-packed uniform is
+ * replaced by the TypeGPU `BlurParams` schema; the kernel math is unchanged.
+ *
+ * RoD is `same-as:source` for now; a real expand-by-radius declaration lands
+ * when a consumer needs region propagation (Phase 3+).
+ */
+import * as d from "typegpu/data";
+export declare const BlurParams: d.WgslStruct<{
+    radius: d.F32;
+    sigma: d.F32;
+    direction: d.Vec2f;
+}>;
+export declare const blurGaussianV1: import("../../../../../module.js").ShaderModule<d.WgslStruct<{
+    radius: d.F32;
+    sigma: d.F32;
+    direction: d.Vec2f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/filters/blur/gaussian/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../../src/shaders/filters/blur/gaussian/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AAQH,eAAO,MAAM,cAAc;;;;GAoFzB,CAAC"}