@nodetool-ai/gpu 0.8.1

package/dist/shaders/filters/blur/gaussian/v1/module.js

@@ -0,0 +1,110 @@
+/**
+ * `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 tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../../module.js";
+export const BlurParams = d.struct({
+    radius: d.f32,
+    sigma: d.f32,
+    direction: d.vec2f
+});
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" },
+    params: { uniform: BlurParams }
+});
+export const blurGaussianV1 = defineModule({
+    id: "filters.blur.gaussian",
+    version: 1,
+    // Promoted in Phase 3: separable gaussian blur with a stable
+    // (radius, sigma, direction) schema; consumed by Phase 2 timeline +
+    // Phase 3 `filters.glow` recipe.
+    surface: "published",
+    category: "filters",
+    linearity: "linear-in-rgb",
+    kind: "compute",
+    params: BlurParams,
+    paramDefaults: { radius: 0, sigma: 0, direction: d.vec2f(1, 0) },
+    paramUi: {
+        radius: { min: 0, max: 256, step: 0.5, label: "Radius", notes: "pixels" },
+        sigma: { min: 0, max: 96, step: 0.1, label: "Sigma" },
+        direction: { label: "Direction", notes: "(1,0) horizontal, (0,1) vertical" }
+    },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+fn gaussianWeight(offset: f32, sigma: f32) -> f32 {
+  let s2 = sigma * sigma;
+  return exp(-(offset * offset) / (2.0 * s2)) / (sqrt(2.0 * 3.14159265) * sigma);
+}
+
+@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 blur = layout.$.params;
+
+  if (blur.radius < 0.5) {
+    textureStore(layout.$.outputTexture, coords, textureLoad(layout.$.source, coords, 0));
+    return;
+  }
+
+  let kernelRadius = i32(min(blur.radius, 20.0));
+  // Keep the 41-tap budget, but spread those taps across a wide blur's full
+  // support. Sampling only the central 20 pixels left large glows hard-edged.
+  let sampleStep = max(1.0, blur.radius / 20.0);
+  // Honor an explicit positive sigma. Only fall back to radius/3 when the
+  // caller leaves sigma unset (<= 0); the previous max(sigma, radius/3)
+  // silently raised any explicit sigma smaller than radius/3.
+  let sigma = select(blur.sigma, blur.radius / 3.0, blur.sigma <= 0.0);
+
+  var colorSum = vec4<f32>(0.0);
+  var weightSum: f32 = 0.0;
+  for (var i = -kernelRadius; i <= kernelRadius; i = i + 1) {
+    let distance = f32(i) * sampleStep;
+    let offset = vec2<i32>(
+      i32(round(blur.direction.x * distance)),
+      i32(round(blur.direction.y * distance))
+    );
+    let s = vec2<i32>(
+      clamp(coords.x + offset.x, 0, i32(dims.x) - 1),
+      clamp(coords.y + offset.y, 0, i32(dims.y) - 1)
+    );
+    let w = gaussianWeight(distance, sigma);
+    colorSum = colorSum + textureLoad(layout.$.source, s, 0) * w;
+    weightSum = weightSum + w;
+  }
+  textureStore(layout.$.outputTexture, coords, colorSum / weightSum);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                // Aligned with the `filters.blur.gaussianSeparable` and `filters.glow`
+                // recipes that route through this module; the blur math itself is
+                // colour-space agnostic (a normalized weighted sum).
+                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/filters/blur/gaussian/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../src/shaders/filters/blur/gaussian/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,0BAA0B,CAAC;AAExD,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,SAAS,EAAE,CAAC,CAAC,KAAK;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,aAAa,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;IAC/C,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;CAChC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,EAAE,EAAE,uBAAuB;IAC3B,OAAO,EAAE,CAAC;IACV,6DAA6D;IAC7D,oEAAoE;IACpE,iCAAiC;IACjC,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,UAAU;IAClB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;IAChE,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;QACzE,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE;QACrD,SAAS,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,kCAAkC,EAAE;KAC7E;IACD,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ClB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,uEAAuE;gBACvE,kEAAkE;gBAClE,qDAAqD;gBACrD,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/filters/blur/separable/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `filters.blur.gaussianSeparable@1` — two-pass separable gaussian blur.
+ *
+ * `filters.blur.gaussian` (H) → `filters.blur.gaussian` (V). The single-pass
+ * `filters.blur.gaussian@1` module blurs along one axis only; this recipe
+ * makes the standard separable kernel available as a single op so workflow
+ * nodes don't have to wire two passes by hand.
+ */
+import * as d from "typegpu/data";
+export declare const BlurSeparableParams: d.WgslStruct<{
+    radius: d.F32;
+    sigma: d.F32;
+}>;
+export declare const filtersBlurSeparableV1: import("../../../../../recipe.js").RecipeModule<{
+    radius: number;
+    sigma: number;
+}>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../../src/shaders/filters/blur/separable/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAMH,eAAO,MAAM,sBAAsB;;;EA6CjC,CAAC"}

package/dist/shaders/filters/blur/separable/v1/module.js

@@ -0,0 +1,64 @@
+/**
+ * `filters.blur.gaussianSeparable@1` — two-pass separable gaussian blur.
+ *
+ * `filters.blur.gaussian` (H) → `filters.blur.gaussian` (V). The single-pass
+ * `filters.blur.gaussian@1` module blurs along one axis only; this recipe
+ * makes the standard separable kernel available as a single op so workflow
+ * nodes don't have to wire two passes by hand.
+ */
+import * as d from "typegpu/data";
+import { defineRecipe } from "../../../../../recipe.js";
+export const BlurSeparableParams = d.struct({
+    radius: d.f32,
+    sigma: d.f32
+});
+// Inlined GPUTextureUsage flags (see filters.glow for the rationale):
+//   COPY_SRC = 0x01, TEXTURE_BINDING = 0x04, STORAGE_BINDING = 0x08
+const INTERMEDIATE_BLUR_USAGE = 0x08 | 0x04 | 0x01;
+export const filtersBlurSeparableV1 = defineRecipe({
+    id: "filters.blur.gaussianSeparable",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    paramDefaults: { radius: 4, sigma: 0 },
+    paramUi: {
+        radius: { min: 0, max: 256, step: 0.5, label: "Radius", notes: "blur radius, px" },
+        sigma: { min: 0, max: 96, step: 0.1, label: "Sigma", notes: "0 = derived from radius" }
+    },
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "expand:radius"
+    },
+    recipe: {
+        intermediates: {
+            blurH: { format: "rgba8unorm", usage: INTERMEDIATE_BLUR_USAGE }
+        },
+        passes: [
+            {
+                op: { id: "filters.blur.gaussian", version: 1 },
+                in: { source: "source" },
+                out: { kind: "intermediate", name: "blurH" },
+                params: { radius: "$.radius", sigma: "$.sigma", direction: d.vec2f(1, 0) }
+            },
+            {
+                op: { id: "filters.blur.gaussian", version: 1 },
+                in: { source: { kind: "intermediate", name: "blurH" } },
+                out: "output",
+                params: { radius: "$.radius", sigma: "$.sigma", direction: d.vec2f(0, 1) }
+            }
+        ]
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/filters/blur/separable/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../src/shaders/filters/blur/separable/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,KAAK,EAAE,CAAC,CAAC,GAAG;CACb,CAAC,CAAC;AAEH,sEAAsE;AACtE,oEAAoE;AACpE,MAAM,uBAAuB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAEnD,MAAM,CAAC,MAAM,sBAAsB,GAAG,YAAY,CAAC;IACjD,EAAE,EAAE,gCAAgC;IACpC,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;IACtC,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,iBAAiB,EAAE;QAClF,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,yBAAyB,EAAE;KACxF;IACD,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,eAAe;KACrB;IACD,MAAM,EAAE;QACN,aAAa,EAAE;YACb,KAAK,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,uBAAuB,EAAE;SAChE;QACD,MAAM,EAAE;YACN;gBACE,EAAE,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE,OAAO,EAAE,CAAC,EAAE;gBAC/C,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE;gBACxB,GAAG,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE;gBAC5C,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;aAC3E;YACD;gBACE,EAAE,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE,OAAO,EAAE,CAAC,EAAE;gBAC/C,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE;gBACvD,GAAG,EAAE,QAAQ;gBACb,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;aAC3E;SACF;KACF;CACF,CAAC,CAAC"}

package/dist/shaders/filters/convolve3x3/v1/module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `filters.convolve3x3@1` — generic 3×3 convolution.
+ *
+ * Nine weights laid out row-major (top-left, top, top-right, …), an explicit
+ * `divisor` (auto-derived when set to 0 from the sum of weights), and a
+ * channel offset added after division. Covers PIL's edge/sharpen/smooth/
+ * emboss family without a bespoke shader per kernel.
+ *
+ * Fragment, mask-slot honoured. Alpha is preserved (the kernel applies to
+ * RGB only) so the same shader works for both opaque and translucent inputs.
+ */
+import * as d from "typegpu/data";
+export declare const Convolve3x3Params: d.WgslStruct<{
+    row0: d.Vec4f;
+    row1: d.Vec4f;
+    row2: d.Vec4f;
+}>;
+export declare const filtersConvolve3x3V1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    row0: d.Vec4f;
+    row1: d.Vec4f;
+    row2: d.Vec4f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/filters/convolve3x3/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/filters/convolve3x3/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,iBAAiB;;;;EAW5B,CAAC;AAgBH,eAAO,MAAM,oBAAoB;;;;GAwF/B,CAAC"}

package/dist/shaders/filters/convolve3x3/v1/module.js

@@ -0,0 +1,128 @@
+/**
+ * `filters.convolve3x3@1` — generic 3×3 convolution.
+ *
+ * Nine weights laid out row-major (top-left, top, top-right, …), an explicit
+ * `divisor` (auto-derived when set to 0 from the sum of weights), and a
+ * channel offset added after division. Covers PIL's edge/sharpen/smooth/
+ * emboss family without a bespoke shader per kernel.
+ *
+ * Fragment, mask-slot honoured. Alpha is preserved (the kernel applies to
+ * RGB only) so the same shader works for both opaque and translucent inputs.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const Convolve3x3Params = d.struct({
+    // Weights in row-major order: w00 w01 w02 / w10 w11 w12 / w20 w21 w22.
+    // Packed into three vec4f's for std140-friendly alignment. The kernel
+    // weights live in the first three components of each row (`xyz`); the
+    // trailing `w` of `row0` carries `offset`, `row1.w` is unused, and
+    // `row2.w` carries `divisor` (set to 0 to auto-derive from the kernel
+    // sum). Keeping the schema tight (3 × vec4f) avoids a vec4f array of
+    // length 3 plus its stride padding worries.
+    row0: d.vec4f, // [w00, w01, w02, offset]
+    row1: d.vec4f, // [w10, w11, w12, _unused]
+    row2: d.vec4f // [w20, w21, w22, divisor]
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: Convolve3x3Params },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "nearest",
+    minFilter: "nearest",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const filtersConvolve3x3V1 = defineModule({
+    id: "filters.convolve3x3",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: Convolve3x3Params,
+    paramDefaults: {
+        // Identity kernel by default.
+        row0: d.vec4f(0, 0, 0, 0),
+        row1: d.vec4f(0, 1, 0, 0),
+        row2: d.vec4f(0, 0, 0, 1)
+    },
+    paramUi: {},
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let dims = textureDimensions(layout.$.source);
+  let px = 1.0 / vec2f(f32(dims.x), f32(dims.y));
+  let p = layout.$.params;
+
+  // Un-premultiply every tap so the kernel runs on straight colour. Convolving
+  // premultiplied rgb skews the weights against per-pixel alpha and can drive
+  // the result above the (preserved) centre alpha, breaking rgb <= a. The
+  // result is re-premultiplied by the centre alpha before output.
+  let c00 = textureSample(layout.$.source, layout.$.samp, uv + vec2f(-px.x, -px.y));
+  let c01 = textureSample(layout.$.source, layout.$.samp, uv + vec2f(   0.0, -px.y));
+  let c02 = textureSample(layout.$.source, layout.$.samp, uv + vec2f( px.x, -px.y));
+  let c10 = textureSample(layout.$.source, layout.$.samp, uv + vec2f(-px.x,    0.0));
+  let centerS = textureSample(layout.$.source, layout.$.samp, uv);
+  let c12 = textureSample(layout.$.source, layout.$.samp, uv + vec2f( px.x,    0.0));
+  let c20 = textureSample(layout.$.source, layout.$.samp, uv + vec2f(-px.x,  px.y));
+  let c21 = textureSample(layout.$.source, layout.$.samp, uv + vec2f(   0.0,  px.y));
+  let c22 = textureSample(layout.$.source, layout.$.samp, uv + vec2f( px.x,  px.y));
+
+  let s00 = c00.rgb / max(c00.a, 1.0 / 255.0);
+  let s01 = c01.rgb / max(c01.a, 1.0 / 255.0);
+  let s02 = c02.rgb / max(c02.a, 1.0 / 255.0);
+  let s10 = c10.rgb / max(c10.a, 1.0 / 255.0);
+  let s11 = centerS.rgb / max(centerS.a, 1.0 / 255.0);
+  let s12 = c12.rgb / max(c12.a, 1.0 / 255.0);
+  let s20 = c20.rgb / max(c20.a, 1.0 / 255.0);
+  let s21 = c21.rgb / max(c21.a, 1.0 / 255.0);
+  let s22 = c22.rgb / max(c22.a, 1.0 / 255.0);
+
+  var acc = s00 * p.row0.x + s01 * p.row0.y + s02 * p.row0.z
+          + s10 * p.row1.x + s11 * p.row1.y + s12 * p.row1.z
+          + s20 * p.row2.x + s21 * p.row2.y + s22 * p.row2.z;
+
+  let declared = p.row2.w;
+  let kSum = p.row0.x + p.row0.y + p.row0.z
+           + p.row1.x + p.row1.y + p.row1.z
+           + p.row2.x + p.row2.y + p.row2.z;
+  let divisor = select(declared, select(1.0, kSum, kSum != 0.0), declared == 0.0);
+
+  acc = acc / divisor + vec3f(p.row0.w);
+  let outStraight = clamp(acc, vec3f(0.0), vec3f(1.0));
+
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let mixedStraight = mix(s11, outStraight, coverage);
+  return vec4f(mixedStraight * centerS.a, centerS.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/filters/convolve3x3/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/filters/convolve3x3/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,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,uEAAuE;IACvE,sEAAsE;IACtE,sEAAsE;IACtE,mEAAmE;IACnE,sEAAsE;IACtE,qEAAqE;IACrE,4CAA4C;IAC5C,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,0BAA0B;IACzC,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,2BAA2B;IAC1C,IAAI,EAAE,CAAC,CAAC,KAAK,CAAE,2BAA2B;CAC3C,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,SAAS;IACpB,SAAS,EAAE,SAAS;IACpB,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,SAAS;IACnB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,iBAAiB;IACzB,aAAa,EAAE;QACb,8BAA8B;QAC9B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KAC1B;IACD,OAAO,EAAE,EAAE;IACX,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDlB;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/filters/glow/v1/module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `filters.glow@1` — multi-pass glow recipe.
+ *
+ * `extract` (`filters.threshold@1`) → `blurH` (`filters.blur.gaussian@1`) →
+ * `blurV` (`filters.blur.gaussian@1`) → `add` (`mixer.add@1`) over source.
+ *
+ * Intermediate formats are declared in the recipe, not chosen by the host —
+ * that's how a recipe like this produces the same output everywhere. The
+ * `bright` intermediate is a fragment write (render attachment); the blur
+ * intermediates are compute writes (storage textures). All three are read
+ * back as `texture_2d<f32>` by the next pass.
+ */
+import * as d from "typegpu/data";
+export declare const GlowParams: d.WgslStruct<{
+    threshold: d.F32;
+    softness: d.F32;
+    radius: d.F32;
+    intensity: d.F32;
+}>;
+export declare const filtersGlowV1: import("../../../../recipe.js").RecipeModule<{
+    threshold: number;
+    softness: number;
+    radius: number;
+    intensity: number;
+}>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/filters/glow/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/filters/glow/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,UAAU;;;;;EAKrB,CAAC;AAWH,eAAO,MAAM,aAAa;;;;;EAwExB,CAAC"}

package/dist/shaders/filters/glow/v1/module.js

@@ -0,0 +1,102 @@
+/**
+ * `filters.glow@1` — multi-pass glow recipe.
+ *
+ * `extract` (`filters.threshold@1`) → `blurH` (`filters.blur.gaussian@1`) →
+ * `blurV` (`filters.blur.gaussian@1`) → `add` (`mixer.add@1`) over source.
+ *
+ * Intermediate formats are declared in the recipe, not chosen by the host —
+ * that's how a recipe like this produces the same output everywhere. The
+ * `bright` intermediate is a fragment write (render attachment); the blur
+ * intermediates are compute writes (storage textures). All three are read
+ * back as `texture_2d<f32>` by the next pass.
+ */
+import * as d from "typegpu/data";
+import { defineRecipe } from "../../../../recipe.js";
+export const GlowParams = d.struct({
+    threshold: d.f32,
+    softness: d.f32,
+    radius: d.f32,
+    intensity: d.f32
+});
+// Inlined WebGPU `GPUTextureUsage` flags. The named constants are runtime
+// globals installed by the host adapter (browser ambient / Dawn `installGlobals`),
+// so they're undefined when this module is imported before the adapter runs —
+// using the literal bits keeps the recipe load-order-independent.
+//   COPY_SRC = 0x01, TEXTURE_BINDING = 0x04, STORAGE_BINDING = 0x08,
+//   RENDER_ATTACHMENT = 0x10
+const INTERMEDIATE_BRIGHT_USAGE = 0x10 | 0x04 | 0x01;
+const INTERMEDIATE_BLUR_USAGE = 0x08 | 0x04 | 0x01;
+export const filtersGlowV1 = defineRecipe({
+    id: "filters.glow",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    paramDefaults: { threshold: 0.7, softness: 0.1, radius: 8, intensity: 1 },
+    paramUi: {
+        threshold: { min: 0, max: 1, step: 0.01, label: "Threshold" },
+        softness: { min: 0, max: 0.5, step: 0.01, label: "Softness" },
+        radius: { min: 0, max: 256, step: 0.5, label: "Radius", notes: "blur radius, px" },
+        intensity: { min: 0, max: 4, step: 0.01, label: "Intensity" }
+    },
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "expand:radius"
+    },
+    recipe: {
+        intermediates: {
+            bright: { format: "rgba8unorm", usage: INTERMEDIATE_BRIGHT_USAGE },
+            blurH: { format: "rgba8unorm", usage: INTERMEDIATE_BLUR_USAGE },
+            blurV: { format: "rgba8unorm", usage: INTERMEDIATE_BLUR_USAGE }
+        },
+        passes: [
+            {
+                op: { id: "filters.threshold", version: 1 },
+                in: { source: "source" },
+                out: { kind: "intermediate", name: "bright" },
+                params: { threshold: "$.threshold", softness: "$.softness" }
+            },
+            {
+                op: { id: "filters.blur.gaussian", version: 1 },
+                in: { source: { kind: "intermediate", name: "bright" } },
+                out: { kind: "intermediate", name: "blurH" },
+                params: {
+                    radius: "$.radius",
+                    sigma: 0,
+                    direction: d.vec2f(1, 0)
+                }
+            },
+            {
+                op: { id: "filters.blur.gaussian", version: 1 },
+                in: { source: { kind: "intermediate", name: "blurH" } },
+                out: { kind: "intermediate", name: "blurV" },
+                params: {
+                    radius: "$.radius",
+                    sigma: 0,
+                    direction: d.vec2f(0, 1)
+                }
+            },
+            {
+                op: { id: "mixer.add", version: 1 },
+                in: {
+                    source: "source",
+                    over: { kind: "intermediate", name: "blurV" }
+                },
+                out: "output",
+                params: { gain: "$.intensity" }
+            }
+        ]
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/filters/glow/v1/module.js.map

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

package/dist/shaders/filters/grain/v1/module.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `filters.grain@1` — film grain as a multiplicative gain wobble.
+ *
+ * **Multiplied, not added.** The input is premultiplied, so `rgb <= a` holds on
+ * every pixel and adding noise would break it: a translucent layer would come
+ * back with channels brighter than its own alpha, which reads as a bright
+ * fringe once it composites. A scalar gain preserves the invariant (the same
+ * reason `filters.vignette@1` may scale), and it is also closer to how exposed
+ * stock behaves — grain bites in the midtones and leaves black black, because
+ * there is nothing there to modulate.
+ *
+ * **Reproducible.** The pattern is a hash of the grain cell and `seed`, with no
+ * clock and no RNG state, so two renders of the same frame are byte-identical
+ * and a cached render can be handed back. A host that wants the pattern to roll
+ * passes the frame's own time as the seed.
+ */
+import * as d from "typegpu/data";
+export declare const GrainParams: d.WgslStruct<{
+    /** Gain wobble, 0..1. 0 leaves the picture untouched. */
+    amount: d.F32;
+    /** Grain cell size in source pixels. 1 is per-pixel. */
+    size: d.F32;
+    /** 0 = one gain for the pixel (monochrome), 1 = per-channel colour noise. */
+    colorAmount: d.F32;
+    /** Rolls the pattern. Same seed, same grain. */
+    seed: d.F32;
+}>;
+export declare const filtersGrainV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    /** Gain wobble, 0..1. 0 leaves the picture untouched. */
+    amount: d.F32;
+    /** Grain cell size in source pixels. 1 is per-pixel. */
+    size: d.F32;
+    /** 0 = one gain for the pixel (monochrome), 1 = per-channel colour noise. */
+    colorAmount: d.F32;
+    /** Rolls the pattern. Same seed, same grain. */
+    seed: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/filters/grain/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/filters/grain/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,WAAW;IACtB,yDAAyD;;IAEzD,wDAAwD;;IAExD,6EAA6E;;IAE7E,gDAAgD;;EAEhD,CAAC;AAQH,eAAO,MAAM,cAAc;IAhBzB,yDAAyD;;IAEzD,wDAAwD;;IAExD,6EAA6E;;IAE7E,gDAAgD;;GAoFhD,CAAC"}