@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,79 @@
+/**
+ * `color.grayscale@1` — collapse RGB to luminance.
+ *
+ * `output.rgb = vec3(luma709(rgb))`. Alpha preserved. Honours the canonical
+ * mask slot so workflows can grayscale a region while the rest stays colored.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const GrayscaleParams = d.struct({
+    amount: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: GrayscaleParams },
+    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 colorGrayscaleV1 = defineModule({
+    id: "color.grayscale",
+    version: 1,
+    // Internal for now — promoted to `published` once a workflow node ships
+    // against it and the surface-promotion review is recorded. See
+    // `tests/surfacePromotion.test.ts` for the published-set contract.
+    surface: "internal",
+    category: "color",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: GrayscaleParams,
+    paramDefaults: { amount: 1 },
+    paramUi: {
+        amount: { min: 0, max: 1, step: 0.01, label: "Amount" }
+    },
+    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 luma = luma709(src.rgb);
+  let gray = vec3f(luma);
+  let mixed = mix(src.rgb, gray, coverage * layout.$.params.amount);
+  return vec4f(mixed, 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/grayscale/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/grayscale/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;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,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,wEAAwE;IACxE,+DAA+D;IAC/D,mEAAmE;IACnE,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,eAAe;IAC1B,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,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;KACxD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,YAAY;;;;;;;;;;;CAWb;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/hsb/v1/module.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `color.hsb@1` — hue / saturation / brightness shift.
+ *
+ * Hue is in degrees (-180..180); saturation is multiplicative (0=grayscale,
+ * 1=passthrough, >1=oversaturate); brightness is multiplicative on the value
+ * channel. Math is the standard `rgb ↔ hsv` round-trip used by `color.grade`.
+ * Fragment, with the canonical mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const HsbParams: d.WgslStruct<{
+    hue: d.F32;
+    saturation: d.F32;
+    brightness: d.F32;
+}>;
+export declare const colorHsbV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    hue: d.F32;
+    saturation: d.F32;
+    brightness: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,131 @@
+/**
+ * `color.hsb@1` — hue / saturation / brightness shift.
+ *
+ * Hue is in degrees (-180..180); saturation is multiplicative (0=grayscale,
+ * 1=passthrough, >1=oversaturate); brightness is multiplicative on the value
+ * channel. Math is the standard `rgb ↔ hsv` round-trip used by `color.grade`.
+ * Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const HsbParams = d.struct({
+    hue: d.f32,
+    saturation: d.f32,
+    brightness: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: HsbParams },
+    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 colorHsbV1 = defineModule({
+    id: "color.hsb",
+    version: 1,
+    // HSB shift is the workflow user's mental model for color adjustment; the
+    // schema matches that vocabulary exactly.
+    surface: "published",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: HsbParams,
+    paramDefaults: { hue: 0, saturation: 1, brightness: 1 },
+    paramUi: {
+        hue: { min: -180, max: 180, step: 1, label: "Hue", notes: "degrees" },
+        saturation: { min: 0, max: 4, step: 0.01, label: "Saturation" },
+        brightness: { min: 0, max: 4, step: 0.01, label: "Brightness" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn rgb2hsv(rgb: vec3f) -> vec3f {
+  let maxC = max(max(rgb.r, rgb.g), rgb.b);
+  let minC = min(min(rgb.r, rgb.g), rgb.b);
+  let delta = maxC - minC;
+  var h: f32 = 0.0;
+  var s: f32 = 0.0;
+  let v: f32 = maxC;
+  if (delta > 0.00001) {
+    s = delta / maxC;
+    if (maxC == rgb.r) {
+      h = (rgb.g - rgb.b) / delta;
+      if (rgb.g < rgb.b) { h = h + 6.0; }
+    } else if (maxC == rgb.g) {
+      h = 2.0 + (rgb.b - rgb.r) / delta;
+    } else {
+      h = 4.0 + (rgb.r - rgb.g) / delta;
+    }
+    h = h / 6.0;
+  }
+  return vec3f(h, s, v);
+}
+
+fn hsv2rgb(hsv: vec3f) -> vec3f {
+  let h = hsv.x * 6.0;
+  let s = hsv.y;
+  let v = hsv.z;
+  let i = floor(h);
+  let f = h - i;
+  let p = v * (1.0 - s);
+  let q = v * (1.0 - s * f);
+  let t = v * (1.0 - s * (1.0 - f));
+  let idx = i32(i) % 6;
+  if (idx == 0) { return vec3f(v, t, p); }
+  if (idx == 1) { return vec3f(q, v, p); }
+  if (idx == 2) { return vec3f(p, v, t); }
+  if (idx == 3) { return vec3f(p, q, v); }
+  if (idx == 4) { return vec3f(t, p, v); }
+  return vec3f(v, p, q);
+}
+
+@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;
+  // Operate on the straight color: rgb2hsv's V channel is max(r,g,b), so a
+  // premultiplied input reports a*V_true and the saturation/brightness
+  // multipliers act against the wrong magnitude. Re-premultiply on store so
+  // the output stays valid premul.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  var hsv = rgb2hsv(clamp(straight, vec3f(0.0), vec3f(1.0)));
+  hsv.x = fract(hsv.x + p.hue / 360.0);
+  hsv.y = clamp(hsv.y * p.saturation, 0.0, 1.0);
+  hsv.z = clamp(hsv.z * p.brightness, 0.0, 1.0);
+  let processed = clamp(hsv2rgb(hsv), vec3f(0.0), vec3f(1.0));
+  let mixedStraight = mix(straight, processed, 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/hsb/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/hsb/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,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,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,0EAA0E;IAC1E,0CAA0C;IAC1C,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,SAAS;IACjB,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE;IACvD,OAAO,EAAE;QACP,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE;QACrE,UAAU,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;QAC/D,UAAU,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;KAChE;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DlB;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/hslAdjust/v1/module.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `color.hslAdjust@1` — selective hue / saturation / luminance adjustment over
+ * an optional hue range.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.HSLAdjust` loop. When
+ * `useRange = 0` the adjustment applies to every pixel (the "ALL" path: hue
+ * shift, saturation and luminance multipliers). When `useRange = 1` the host
+ * passes a normalized `[rangeLo, rangeHi]` hue window (wrapping when
+ * `rangeLo > rangeHi`, as for reds) and the per-pixel `blend` weight gates the
+ * adjustment by hue proximity to that window's centre, skipping near-grey
+ * pixels (`s < 0.1`). Fragment, with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const HslAdjustParams: d.WgslStruct<{
+    hueShift: d.F32;
+    satAdj: d.F32;
+    lumAdj: d.F32;
+    rangeLo: d.F32;
+    rangeHi: d.F32;
+    useRange: d.F32;
+}>;
+export declare const colorHslAdjustV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    hueShift: d.F32;
+    satAdj: d.F32;
+    lumAdj: d.F32;
+    rangeLo: d.F32;
+    rangeHi: d.F32;
+    useRange: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,170 @@
+/**
+ * `color.hslAdjust@1` — selective hue / saturation / luminance adjustment over
+ * an optional hue range.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.HSLAdjust` loop. When
+ * `useRange = 0` the adjustment applies to every pixel (the "ALL" path: hue
+ * shift, saturation and luminance multipliers). When `useRange = 1` the host
+ * passes a normalized `[rangeLo, rangeHi]` hue window (wrapping when
+ * `rangeLo > rangeHi`, as for reds) and the per-pixel `blend` weight gates the
+ * adjustment by hue proximity to that window's centre, skipping near-grey
+ * pixels (`s < 0.1`). Fragment, with the canonical optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const HslAdjustParams = d.struct({
+    hueShift: d.f32,
+    satAdj: d.f32,
+    lumAdj: d.f32,
+    rangeLo: d.f32,
+    rangeHi: d.f32,
+    useRange: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: HslAdjustParams },
+    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 colorHslAdjustV1 = defineModule({
+    id: "color.hslAdjust",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: HslAdjustParams,
+    paramDefaults: {
+        hueShift: 0,
+        satAdj: 0,
+        lumAdj: 0,
+        rangeLo: 0,
+        rangeHi: 1,
+        useRange: 0
+    },
+    paramUi: {
+        hueShift: { min: -1, max: 1, step: 0.01, label: "Hue shift" },
+        satAdj: { min: -1, max: 1, step: 0.01, label: "Saturation" },
+        lumAdj: { min: -1, max: 1, step: 0.01, label: "Luminance" },
+        rangeLo: { min: 0, max: 1, step: 0.01, label: "Range low" },
+        rangeHi: { min: 0, max: 1, step: 0.01, label: "Range high" },
+        useRange: { min: 0, max: 1, step: 1, label: "Use range" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn rgb2hsv(rgb: vec3f) -> vec3f {
+  let maxC = max(max(rgb.r, rgb.g), rgb.b);
+  let minC = min(min(rgb.r, rgb.g), rgb.b);
+  let delta = maxC - minC;
+  var h: f32 = 0.0;
+  var s: f32 = 0.0;
+  let v: f32 = maxC;
+  if (delta > 0.00001) {
+    s = delta / maxC;
+    if (maxC == rgb.r) {
+      h = (rgb.g - rgb.b) / delta;
+      if (rgb.g < rgb.b) { h = h + 6.0; }
+    } else if (maxC == rgb.g) {
+      h = 2.0 + (rgb.b - rgb.r) / delta;
+    } else {
+      h = 4.0 + (rgb.r - rgb.g) / delta;
+    }
+    h = h / 6.0;
+  }
+  return vec3f(h, s, v);
+}
+
+fn hsv2rgb(hsv: vec3f) -> vec3f {
+  let h = hsv.x * 6.0;
+  let s = hsv.y;
+  let v = hsv.z;
+  let i = floor(h);
+  let f = h - i;
+  let p = v * (1.0 - s);
+  let q = v * (1.0 - s * f);
+  let t = v * (1.0 - s * (1.0 - f));
+  let idx = i32(i) % 6;
+  if (idx == 0) { return vec3f(v, t, p); }
+  if (idx == 1) { return vec3f(q, v, p); }
+  if (idx == 2) { return vec3f(p, v, t); }
+  if (idx == 3) { return vec3f(p, q, v); }
+  if (idx == 4) { return vec3f(t, p, v); }
+  return vec3f(v, p, q);
+}
+
+@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 = clamp(src.rgb / safeA, vec3f(0.0), vec3f(1.0));
+  var hsv = rgb2hsv(straight);
+  var blend: f32 = 1.0;
+  if (p.useRange > 0.5) {
+    if (hsv.y < 0.1) {
+      blend = 0.0;
+    } else {
+      let lo = p.rangeLo;
+      let hi = p.rangeHi;
+      if (lo > hi) {
+        // Wrapping window (e.g. reds): in-range when above lo OR below hi.
+        if (hsv.x >= lo || hsv.x <= hi) {
+          let halfWidth = (1.0 - lo + hi) * 0.5;
+          let center = fract(lo + halfWidth);
+          var dist = abs(hsv.x - center);
+          if (dist > 0.5) { dist = 1.0 - dist; }
+          blend = clamp(1.0 - dist / halfWidth, 0.0, 1.0);
+        } else {
+          blend = 0.0;
+        }
+      } else {
+        let center = (lo + hi) * 0.5;
+        let halfWidth = (hi - lo) * 0.5;
+        let dist = abs(hsv.x - center);
+        blend = clamp(1.0 - dist / halfWidth, 0.0, 1.0);
+      }
+    }
+  }
+  if (blend > 0.0) {
+    hsv.x = fract(hsv.x + p.hueShift * 0.5 * blend);
+    hsv.y = clamp(hsv.y * (1.0 + p.satAdj * blend), 0.0, 1.0);
+    hsv.z = clamp(hsv.z * (1.0 + p.lumAdj * blend), 0.0, 1.0);
+  }
+  let processed = hsv2rgb(hsv);
+  let mixed = mix(straight, processed, 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/hslAdjust/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/hslAdjust/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;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,QAAQ,EAAE,CAAC,CAAC,GAAG;IACf,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,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;QACb,QAAQ,EAAE,CAAC;QACX,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;QACV,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,CAAC;KACZ;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;QAC7D,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;QAC5D,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;QAC3D,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;QAC3D,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;QAC5D,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE;KAC1D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFlB;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/invert/v1/module.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `color.invert@1` — invert RGB (1 - rgb), preserve alpha.
+ *
+ * Fragment, mask slot honored (`output = mix(source, processed, coverage * amount)`).
+ * The `amount` param lets the inversion fade smoothly between 0 (passthrough) and
+ * 1 (full invert) — useful for animated transitions.
+ */
+import * as d from "typegpu/data";
+export declare const InvertParams: d.WgslStruct<{
+    amount: d.F32;
+}>;
+export declare const colorInvertV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    amount: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/invert/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,YAAY;;EAEvB,CAAC;AAgBH,eAAO,MAAM,aAAa;;GAyDxB,CAAC"}

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

@@ -0,0 +1,85 @@
+/**
+ * `color.invert@1` — invert RGB (1 - rgb), preserve alpha.
+ *
+ * Fragment, mask slot honored (`output = mix(source, processed, coverage * amount)`).
+ * The `amount` param lets the inversion fade smoothly between 0 (passthrough) and
+ * 1 (full invert) — useful for animated transitions.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_PREMUL_HELPERS } from "../../../../shared/premulWgsl.js";
+export const InvertParams = d.struct({
+    amount: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: InvertParams },
+    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 colorInvertV1 = defineModule({
+    id: "color.invert",
+    version: 1,
+    // Trivial schema (single `amount` param) and canonical mask slot; no
+    // near-term split or rename in sight, so the API is safe to publish.
+    surface: "published",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: InvertParams,
+    paramDefaults: { amount: 1 },
+    paramUi: {
+        amount: { min: 0, max: 1, step: 0.01, label: "Amount" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+${WGSL_PREMUL_HELPERS}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  // Input is premultiplied. The typed helpers force us through unpremul()
+  // before touching channels — the prior hand-rolled "safeA = max(a, 1/255);
+  // straight = rgb/safeA; invert; re-premultiply" dance is now expressed as
+  // unpremul/premul calls that can't be skipped accidentally.
+  let p = samplePremul(layout.$.source, layout.$.samp, uv);
+  let s = unpremul(p);
+  let inverted = Straight(vec4f(vec3f(1.0) - s.v.rgb, s.v.a));
+  let invPremul = premul(inverted);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  // Linear mix between two premul values is itself a premul-safe linear op,
+  // so it's correct to lerp src.v ↔ invPremul.v directly.
+  return mix(p.v, invPremul.v, coverage * layout.$.params.amount);
+}
+`,
+    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/invert/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/invert/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;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAEvE,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;IACjC,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,aAAa,GAAG,YAAY,CAAC;IACxC,EAAE,EAAE,cAAc;IAClB,OAAO,EAAE,CAAC;IACV,qEAAqE;IACrE,qEAAqE;IACrE,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,YAAY;IACpB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;IAC5B,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;KACxD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,mBAAmB;;;;;;;;;;;;;;;;;CAiBpB;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/levels/v1/module.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `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 * as d from "typegpu/data";
+export declare const LevelsParams: d.WgslStruct<{
+    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;
+}>;
+export declare const colorLevelsV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    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;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/levels/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,YAAY;;;;;;;;;;EAUvB,CAAC;AAgBH,eAAO,MAAM,aAAa;;;;;;;;;;GA+ExB,CAAC"}