@nodetool-ai/gpu 0.8.1

package/dist/shaders/keyer/lumaKey/v1/module.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `keyer.lumaKey@1` — clear pixels whose luma falls outside `[low, high]`.
+ *
+ * Coverage ramps smoothly across `softness` on each side of the band so the
+ * matte feathers rather than aliasing. Output alpha is multiplied by the
+ * resulting coverage (the source alpha is preserved when fully inside the
+ * band, dropped to zero outside). Fragment.
+ */
+import * as d from "typegpu/data";
+export declare const LumaKeyParams: d.WgslStruct<{
+    low: d.F32;
+    high: d.F32;
+    softness: d.F32;
+    invert: d.F32;
+}>;
+export declare const keyerLumaKeyV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    low: d.F32;
+    high: d.F32;
+    softness: d.F32;
+    invert: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/keyer/lumaKey/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/keyer/lumaKey/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAeH,eAAO,MAAM,cAAc;;;;;GA0DzB,CAAC"}

package/dist/shaders/keyer/lumaKey/v1/module.js

@@ -0,0 +1,89 @@
+/**
+ * `keyer.lumaKey@1` — clear pixels whose luma falls outside `[low, high]`.
+ *
+ * Coverage ramps smoothly across `softness` on each side of the band so the
+ * matte feathers rather than aliasing. Output alpha is multiplied by the
+ * resulting coverage (the source alpha is preserved when fully inside the
+ * band, dropped to zero outside). Fragment.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const LumaKeyParams = d.struct({
+    low: d.f32,
+    high: d.f32,
+    softness: d.f32,
+    invert: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: LumaKeyParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const keyerLumaKeyV1 = defineModule({
+    id: "keyer.lumaKey",
+    version: 1,
+    // Luminance keyer with a stable `(low, high, softness)` schema; the core op
+    // for matte-from-brightness workflows.
+    surface: "published",
+    category: "keyer",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: LumaKeyParams,
+    paramDefaults: { low: 0, high: 1, softness: 0.05, invert: 0 },
+    paramUi: {
+        low: { min: 0, max: 1, step: 0.01, label: "Low" },
+        high: { min: 0, max: 1, step: 0.01, label: "High" },
+        softness: { min: 0, max: 0.5, step: 0.01, label: "Softness" },
+        invert: { min: 0, max: 1, step: 1, label: "Invert", notes: "0 keep band / 1 cut band" }
+    },
+    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 p = layout.$.params;
+  // Input is premultiplied; compute luma on the underlying straight color so
+  // the band thresholds don't drift with a.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let luma = luma709(straight);
+  let soft = max(p.softness, 0.0001);
+  let lowEdge = smoothstep(p.low - soft, p.low + soft, luma);
+  let highEdge = 1.0 - smoothstep(p.high - soft, p.high + soft, luma);
+  var coverage = lowEdge * highEdge;
+  if (p.invert > 0.5) {
+    coverage = 1.0 - coverage;
+  }
+  // Multiply RGB by coverage too so the result stays valid premultiplied.
+  return vec4f(src.rgb * coverage, src.a * coverage);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                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/keyer/lumaKey/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/keyer/lumaKey/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;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,QAAQ,EAAE,CAAC,CAAC,GAAG;IACf,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,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,cAAc,GAAG,YAAY,CAAC;IACzC,EAAE,EAAE,eAAe;IACnB,OAAO,EAAE,CAAC;IACV,4EAA4E;IAC5E,uCAAuC;IACvC,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE;IAC7D,OAAO,EAAE;QACP,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE;QACjD,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;QACnD,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;QAC7D,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,0BAA0B,EAAE;KACxF;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,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/mask/apply/v1/module.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `mask.apply@1` — multiply mask coverage into source's alpha; RGB unchanged.
+ *
+ * Coverage comes from `mask.a` (the canonical channel). The `invert` flag
+ * inverts the mask first. Fragment; the mask input here is **required** (the
+ * op is about applying a mask, after all), unlike the optional `mask` slot
+ * on filter/color modules.
+ */
+import * as d from "typegpu/data";
+export declare const MaskApplyParams: d.WgslStruct<{
+    invert: d.F32;
+}>;
+export declare const maskApplyV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    invert: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/mask/apply/v1/module.d.ts.map

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

package/dist/shaders/mask/apply/v1/module.js

@@ -0,0 +1,79 @@
+/**
+ * `mask.apply@1` — multiply mask coverage into source's alpha; RGB unchanged.
+ *
+ * Coverage comes from `mask.a` (the canonical channel). The `invert` flag
+ * inverts the mask first. Fragment; the mask input here is **required** (the
+ * op is about applying a mask, after all), unlike the optional `mask` slot
+ * on filter/color modules.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const MaskApplyParams = d.struct({
+    invert: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: MaskApplyParams },
+    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 maskApplyV1 = defineModule({
+    id: "mask.apply",
+    version: 1,
+    // Promoted in Phase 3 Batch 1: the canonical "apply a mask" op; pairs with
+    // every mask-producing module (`mask.fromImage`, `keyer.*`, recipes).
+    surface: "published",
+    category: "mask",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: MaskApplyParams,
+    paramDefaults: { invert: 0 },
+    paramUi: {
+        invert: { min: 0, max: 1, step: 1, label: "Invert mask" }
+    },
+    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);
+  var coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  if (layout.$.params.invert > 0.5) {
+    coverage = 1.0 - coverage;
+  }
+  // Source is premultiplied (rgb = a*C). Scaling alpha by coverage requires
+  // scaling RGB by the same factor so the output stays valid premultiplied
+  // (rgb <= a). Without this, a 50% mask on opaque white produced rgb=1, a=0.5.
+  return vec4f(src.rgb * coverage, src.a * coverage);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                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/mask/apply/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mask/apply/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,WAAW,GAAG,YAAY,CAAC;IACtC,EAAE,EAAE,YAAY;IAChB,OAAO,EAAE,CAAC;IACV,2EAA2E;IAC3E,sEAAsE;IACtE,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,MAAM;IAChB,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,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE;KAC1D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;CAalB;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;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/mask/fromImage/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `mask.fromImage@1` — derive a mask from an image's channels.
+ *
+ * `mode` selects the source channel(s): `0` alpha, `1` luminance,
+ * `2` red, `3` green, `4` blue, `5` max-channel. Output writes the derived
+ * coverage into the alpha channel and zeroes RGB — downstream `mask.apply`
+ * (or any module reading `mask.a`) consumes it directly.
+ */
+import * as d from "typegpu/data";
+export declare const MaskFromImageParams: d.WgslStruct<{
+    mode: d.F32;
+    invert: d.F32;
+}>;
+export declare const maskFromImageV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mode: d.F32;
+    invert: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/mask/fromImage/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/mask/fromImage/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAeH,eAAO,MAAM,eAAe;;;GAsE1B,CAAC"}

package/dist/shaders/mask/fromImage/v1/module.js

@@ -0,0 +1,99 @@
+/**
+ * `mask.fromImage@1` — derive a mask from an image's channels.
+ *
+ * `mode` selects the source channel(s): `0` alpha, `1` luminance,
+ * `2` red, `3` green, `4` blue, `5` max-channel. Output writes the derived
+ * coverage into the alpha channel and zeroes RGB — downstream `mask.apply`
+ * (or any module reading `mask.a`) consumes it directly.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const MaskFromImageParams = d.struct({
+    mode: d.f32,
+    invert: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: MaskFromImageParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const maskFromImageV1 = defineModule({
+    id: "mask.fromImage",
+    version: 1,
+    surface: "internal",
+    category: "mask",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: MaskFromImageParams,
+    paramDefaults: { mode: 1, invert: 0 },
+    paramUi: {
+        mode: {
+            min: 0,
+            max: 5,
+            step: 1,
+            label: "Mode",
+            notes: "0 alpha / 1 luma / 2 R / 3 G / 4 B / 5 max"
+        },
+        invert: { min: 0, max: 1, step: 1, label: "Invert" }
+    },
+    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 p = layout.$.params;
+  let mode = i32(round(p.mode));
+  // Source is premultiplied (rgb = a*C); divide back out so the derived mask
+  // reflects the underlying color, not the alpha-dimmed display value. Modes
+  // that already pick the alpha channel (mode 0) read src.a directly.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  var value: f32 = 0.0;
+  if (mode == 0) {
+    value = src.a;
+  } else if (mode == 1) {
+    value = luma709(straight);
+  } else if (mode == 2) {
+    value = straight.r;
+  } else if (mode == 3) {
+    value = straight.g;
+  } else if (mode == 4) {
+    value = straight.b;
+  } else {
+    value = max(max(straight.r, straight.g), straight.b);
+  }
+  if (p.invert > 0.5) {
+    value = 1.0 - value;
+  }
+  return vec4f(0.0, 0.0, 0.0, clamp(value, 0.0, 1.0));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                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/mask/fromImage/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mask/fromImage/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;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,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,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,MAAM;IAChB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,mBAAmB;IAC3B,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;IACrC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,MAAM;YACb,KAAK,EAAE,4CAA4C;SACpD;QACD,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE;KACrD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Bb;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,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/mask/invert/v1/module.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `mask.invert@1` — `output.a = 1 - mask.a`, RGB zeroed.
+ *
+ * The pool's masks are alpha-coverage textures. Invert is its own module
+ * (rather than a flag on every consumer) because chaining mask ops cleanly is
+ * a frequent enough pattern. Fragment.
+ */
+import * as d from "typegpu/data";
+export declare const maskInvertV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    unused: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+/**
+ * `mask.invert@1` — `output.a = 1 - mask.a`, RGB zeroed.
+ *
+ * The pool's masks are alpha-coverage textures. Invert is its own module
+ * (rather than a flag on every consumer) because chaining mask ops cleanly is
+ * a frequent enough pattern. Fragment.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+const NoParams = d.struct({ unused: d.f32 });
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const maskInvertV1 = defineModule({
+    id: "mask.invert",
+    version: 1,
+    surface: "internal",
+    category: "mask",
+    linearity: "alpha-only",
+    kind: "fragment",
+    params: NoParams,
+    paramDefaults: { unused: 0 },
+    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);
+  return vec4f(0.0, 0.0, 0.0, clamp(1.0 - src.a, 0.0, 1.0));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                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/mask/invert/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mask/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;AAErD,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AAE7C,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,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,YAAY,GAAG,YAAY,CAAC;IACvC,EAAE,EAAE,aAAa;IACjB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,MAAM;IAChB,SAAS,EAAE,YAAY;IACvB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,QAAQ;IAChB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;IAC5B,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;CAMlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,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/mixer/add/v1/module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `mixer.add@1` — additive composite of two textures, `out = source + over * gain`.
+ *
+ * Premultiplied alpha throughout; alpha follows the same additive rule. Used
+ * by the `filters.glow` recipe to fold a blurred bright pass back into the
+ * original, and as a general-purpose add layer. Real multi-mode composite
+ * (over/multiply/screen/…) is `mixer.composite` (Phase 4 Batch 4 — wraps
+ * `WebGPULayerCompositor`).
+ */
+import * as d from "typegpu/data";
+export declare const AddParams: d.WgslStruct<{
+    gain: d.F32;
+}>;
+export declare const mixerAddV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    gain: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/mixer/add/v1/module.d.ts.map

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

package/dist/shaders/mixer/add/v1/module.js

@@ -0,0 +1,73 @@
+/**
+ * `mixer.add@1` — additive composite of two textures, `out = source + over * gain`.
+ *
+ * Premultiplied alpha throughout; alpha follows the same additive rule. Used
+ * by the `filters.glow` recipe to fold a blurred bright pass back into the
+ * original, and as a general-purpose add layer. Real multi-mode composite
+ * (over/multiply/screen/…) is `mixer.composite` (Phase 4 Batch 4 — wraps
+ * `WebGPULayerCompositor`).
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const AddParams = d.struct({
+    gain: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: AddParams },
+    source: { texture: "float" },
+    over: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const mixerAddV1 = defineModule({
+    id: "mixer.add",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: AddParams,
+    paramDefaults: { gain: 1 },
+    paramUi: {
+        gain: { min: 0, max: 4, step: 0.01, label: "Gain" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let s = textureSample(layout.$.source, layout.$.samp, uv);
+  let o = textureSample(layout.$.over, layout.$.samp, uv);
+  let g = layout.$.params.gain;
+  return clamp(s + o * g, vec4f(0.0), vec4f(1.0));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            over: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "union-of-inputs"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/mixer/add/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mixer/add/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;AAErD,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,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,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,SAAS;IACjB,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;IAC1B,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;KACpD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;CAQlB;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;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,iBAAiB;KACvB;CACF,CAAC,CAAC"}

package/dist/shaders/mixer/colorOverlay/v1/module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `mixer.colorOverlay@1` — flat colour applied across the source, masked by
+ * source coverage.
+ *
+ * The "Color Overlay" layer-effect from sketch / image-editor vocabulary: a
+ * constant RGB fill is mixed into the source's colours but the output
+ * **silhouette (alpha) is preserved** — the overlay never spills outside
+ * the source, and never erodes its coverage either. `amount` controls the
+ * RGB mix strength (`0` passthrough, `1` full overlay) and is scaled by the
+ * picker's `color.a`, so a half-opacity colour applied at full amount
+ * behaves like a fully-opaque colour at half amount.
+ *
+ * `color` is supplied straight (R, G, B, opacity) — the shader handles
+ * un/re-premultiplication so the output stays premultiplied per the pool
+ * convention.
+ */
+import * as d from "typegpu/data";
+export declare const ColorOverlayParams: d.WgslStruct<{
+    color: d.Vec4f;
+    amount: d.F32;
+}>;
+export declare const mixerColorOverlayV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    color: d.Vec4f;
+    amount: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/mixer/colorOverlay/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/mixer/colorOverlay/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC;AAeH,eAAO,MAAM,mBAAmB;;;GA6C9B,CAAC"}

package/dist/shaders/mixer/colorOverlay/v1/module.js

@@ -0,0 +1,81 @@
+/**
+ * `mixer.colorOverlay@1` — flat colour applied across the source, masked by
+ * source coverage.
+ *
+ * The "Color Overlay" layer-effect from sketch / image-editor vocabulary: a
+ * constant RGB fill is mixed into the source's colours but the output
+ * **silhouette (alpha) is preserved** — the overlay never spills outside
+ * the source, and never erodes its coverage either. `amount` controls the
+ * RGB mix strength (`0` passthrough, `1` full overlay) and is scaled by the
+ * picker's `color.a`, so a half-opacity colour applied at full amount
+ * behaves like a fully-opaque colour at half amount.
+ *
+ * `color` is supplied straight (R, G, B, opacity) — the shader handles
+ * un/re-premultiplication so the output stays premultiplied per the pool
+ * convention.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ColorOverlayParams = d.struct({
+    color: d.vec4f,
+    amount: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ColorOverlayParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const mixerColorOverlayV1 = defineModule({
+    id: "mixer.colorOverlay",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ColorOverlayParams,
+    paramDefaults: { color: d.vec4f(1, 0, 0, 1), amount: 0.5 },
+    paramUi: {
+        color: { label: "Color", notes: "RGBA, straight alpha" },
+        amount: { min: 0, max: 1, step: 0.01, label: "Amount" }
+    },
+    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 p = layout.$.params;
+  // Blend RGB in straight space, then re-premultiply against the source's
+  // own coverage. The output silhouette stays = src.a regardless of color.a
+  // or amount — overlay opacity affects colour, not coverage.
+  let safeA = max(src.a, 0.0001);
+  let straightRgb = src.rgb / safeA;
+  let mixedStraight = mix(straightRgb, p.color.rgb, clamp(p.amount * p.color.a, 0.0, 1.0));
+  return vec4f(mixedStraight * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                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/mixer/colorOverlay/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mixer/colorOverlay/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;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,KAAK,EAAE,CAAC,CAAC,KAAK;IACd,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,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,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,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE;IAC1D,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACxD,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;;;;;;;;;;;;;CAalB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,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"}