@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,110 @@
+/**
+ * `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 tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const GrainParams = d.struct({
+    /** 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
+});
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" },
+    params: { uniform: GrainParams }
+});
+export const filtersGrainV1 = defineModule({
+    id: "filters.grain",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    // A per-channel scale of premultiplied RGB, saturated against alpha — the
+    // same shape `filters.vignette@1` is tagged for.
+    linearity: "linear-in-rgb",
+    kind: "compute",
+    params: GrainParams,
+    paramDefaults: { amount: 0, size: 1, colorAmount: 0, seed: 0 },
+    paramUi: {
+        amount: { min: 0, max: 1, step: 0.01, label: "Amount" },
+        size: { min: 1, max: 16, step: 0.5, label: "Size" },
+        colorAmount: { min: 0, max: 1, step: 0.01, label: "Colour" },
+        seed: { label: "Seed" }
+    },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+fn hash31(p: vec3f) -> f32 {
+  var p3 = fract(p * 0.1031);
+  p3 = p3 + dot(p3, vec3f(p3.y, p3.z, p3.x) + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+/** Signed noise in [-1, 1] for one grain cell and channel. */
+fn grainAt(cell: vec2f, seed: f32, channel: f32) -> f32 {
+  return hash31(vec3f(cell.x, cell.y, seed + channel * 19.19)) * 2.0 - 1.0;
+}
+
+@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 v = layout.$.params;
+  let color = textureLoad(layout.$.source, coords, 0);
+
+  // Quantize to grain cells so size coarsens the stock instead of just
+  // reseeding it. Sub-pixel sizes collapse back to per-pixel.
+  let cell = floor(vec2f(f32(gid.x), f32(gid.y)) / max(v.size, 1.0));
+
+  let mono = grainAt(cell, v.seed, 0.0);
+  let perChannel = vec3f(
+    grainAt(cell, v.seed, 1.0),
+    grainAt(cell, v.seed, 2.0),
+    grainAt(cell, v.seed, 3.0)
+  );
+  let n = mix(vec3f(mono), perChannel, clamp(v.colorAmount, 0.0, 1.0));
+
+  let gain = vec3f(1.0) + n * clamp(v.amount, 0.0, 1.0);
+  // Saturating against alpha rather than 1.0 is what keeps rgb <= a when the
+  // gain runs above 1 on an already-bright premultiplied pixel.
+  let rgb = clamp(color.rgb * gain, vec3f(0.0), vec3f(color.a)); // premul: ok
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(rgb, color.a));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/filters/grain/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,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,yDAAyD;IACzD,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,wDAAwD;IACxD,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,6EAA6E;IAC7E,WAAW,EAAE,CAAC,CAAC,GAAG;IAClB,gDAAgD;IAChD,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,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,WAAW,EAAE;CACjC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,EAAE,EAAE,eAAe;IACnB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,0EAA0E;IAC1E,iDAAiD;IACjD,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,WAAW;IACnB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;IAC9D,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;QACvD,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE;QACnD,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;QAC5D,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;KACxB;IACD,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,14 @@
+/**
+ * `filters.pixelate@1` — snap UVs to a coarse grid before sampling.
+ *
+ * `cellSize` is in source pixels; effective output resolution is `dims / cellSize`.
+ * `cellSize ≤ 1` is treated as passthrough. Fragment, with the canonical mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const PixelateParams: d.WgslStruct<{
+    cellSize: d.F32;
+}>;
+export declare const filtersPixelateV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    cellSize: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,76 @@
+/**
+ * `filters.pixelate@1` — snap UVs to a coarse grid before sampling.
+ *
+ * `cellSize` is in source pixels; effective output resolution is `dims / cellSize`.
+ * `cellSize ≤ 1` is treated as passthrough. Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const PixelateParams = d.struct({
+    cellSize: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: PixelateParams },
+    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 filtersPixelateV1 = defineModule({
+    id: "filters.pixelate",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: PixelateParams,
+    paramDefaults: { cellSize: 8 },
+    paramUi: {
+        cellSize: { min: 1, max: 128, step: 1, label: "Cell size", notes: "pixels" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let dims = vec2f(textureDimensions(layout.$.source));
+  let cell = max(1.0, layout.$.params.cellSize);
+  let snapped = (floor(uv * dims / cell) + vec2f(0.5)) * cell / dims;
+  let processed = textureSample(layout.$.source, layout.$.samp, snapped);
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let mixed = mix(src.rgb, processed.rgb, coverage);
+  let mixedA = mix(src.a, processed.a, coverage);
+  return vec4f(mixed, mixedA);
+}
+`,
+    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/pixelate/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/filters/pixelate/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;AAErD,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,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,iBAAiB,GAAG,YAAY,CAAC;IAC5C,EAAE,EAAE,kBAAkB;IACtB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE;IAC9B,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE;KAC7E;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;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/sharpen/unsharpMask/v1/module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `filters.sharpen.unsharpMask@1` — unsharp-mask sharpen.
+ *
+ * Migrated verbatim from the timeline preview's `sharpenComputeShader`. A 3×3
+ * box average is the low-pass; `sharpened = center + amount * (center - blur)`,
+ * gated by a luminance threshold. Hand-packed uniform → TypeGPU `SharpenParams`.
+ */
+import * as d from "typegpu/data";
+export declare const SharpenParams: d.WgslStruct<{
+    amount: d.F32;
+    threshold: d.F32;
+}>;
+export declare const sharpenUnsharpMaskV1: import("../../../../../module.js").ShaderModule<d.WgslStruct<{
+    amount: d.F32;
+    threshold: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/filters/sharpen/unsharpMask/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../../src/shaders/filters/sharpen/unsharpMask/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,aAAa;;;EAGxB,CAAC;AAQH,eAAO,MAAM,oBAAoB;;;GAwE/B,CAAC"}

package/dist/shaders/filters/sharpen/unsharpMask/v1/module.js

@@ -0,0 +1,93 @@
+/**
+ * `filters.sharpen.unsharpMask@1` — unsharp-mask sharpen.
+ *
+ * Migrated verbatim from the timeline preview's `sharpenComputeShader`. A 3×3
+ * box average is the low-pass; `sharpened = center + amount * (center - blur)`,
+ * gated by a luminance threshold. Hand-packed uniform → TypeGPU `SharpenParams`.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../../module.js";
+export const SharpenParams = d.struct({
+    amount: d.f32,
+    threshold: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" },
+    params: { uniform: SharpenParams }
+});
+export const sharpenUnsharpMaskV1 = defineModule({
+    id: "filters.sharpen.unsharpMask",
+    version: 1,
+    // Promoted in Phase 3 alongside the rest of the Phase 2 timeline-effect
+    // batch (params stable since Phase 2).
+    surface: "published",
+    category: "filters",
+    linearity: "nonlinear-in-rgb",
+    kind: "compute",
+    params: SharpenParams,
+    paramDefaults: { amount: 0, threshold: 0 },
+    paramUi: {
+        amount: { min: 0, max: 2, step: 0.01, label: "Amount" },
+        threshold: { min: 0, max: 1, step: 0.01, label: "Threshold" }
+    },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+fn loadClamped(coords: vec2<i32>) -> vec4<f32> {
+  let dims = textureDimensions(layout.$.source);
+  let c = vec2<i32>(
+    clamp(coords.x, 0, i32(dims.x) - 1),
+    clamp(coords.y, 0, i32(dims.y) - 1)
+  );
+  return textureLoad(layout.$.source, c, 0);
+}
+
+@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 sharpen = layout.$.params;
+  let center = textureLoad(layout.$.source, coords, 0);
+
+  // 3x3 box average as the low-pass; sharpen = center + amount * (center - blur).
+  var sum = vec4<f32>(0.0);
+  for (var j = -1; j <= 1; j = j + 1) {
+    for (var i = -1; i <= 1; i = i + 1) {
+      sum = sum + loadClamped(vec2<i32>(coords.x + i, coords.y + j));
+    }
+  }
+  let blurAvg = sum / 9.0;
+  // Un-premultiply before differencing: the unsharp diff and overshoot must be
+  // computed on straight colour, otherwise the result is scaled by alpha and a
+  // sharpened highlight can exceed the (preserved) centre alpha — rgb > a. The
+  // sharpened straight colour is re-premultiplied by the centre alpha at the end.
+  let centerStraight = center.rgb / max(center.a, 1.0 / 255.0);
+  let blurStraight = blurAvg.rgb / max(blurAvg.a, 1.0 / 255.0);
+  let diff = centerStraight - blurStraight;
+  let lum = abs(dot(diff, vec3<f32>(0.299, 0.587, 0.114)));
+  let mask = step(sharpen.threshold, lum);
+  let sharpened = clamp(centerStraight + diff * sharpen.amount * mask, vec3<f32>(0.0), vec3<f32>(1.0));
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(sharpened * center.a, center.a));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/filters/sharpen/unsharpMask/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../src/shaders/filters/sharpen/unsharpMask/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,0BAA0B,CAAC;AAExD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,SAAS,EAAE,CAAC,CAAC,GAAG;CACjB,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,aAAa,EAAE;CACnC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,YAAY,CAAC;IAC/C,EAAE,EAAE,6BAA6B;IACjC,OAAO,EAAE,CAAC;IACV,wEAAwE;IACxE,uCAAuC;IACvC,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE;IAC1C,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;QACvD,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;KAC9D;IACD,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * `filters.threshold@1` — keep pixels whose luma is above `threshold`,
+ * black out the rest. `softness` widens the cutoff into a smooth ramp.
+ *
+ * Used as the bright-extraction stage of the `filters.glow` recipe and as a
+ * general-purpose bright-pass filter.
+ */
+import * as d from "typegpu/data";
+export declare const ThresholdParams: d.WgslStruct<{
+    threshold: d.F32;
+    softness: d.F32;
+}>;
+export declare const filtersThresholdV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    threshold: d.F32;
+    softness: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/filters/threshold/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,eAAe;;;EAG1B,CAAC;AAeH,eAAO,MAAM,kBAAkB;;;GA4C7B,CAAC"}

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

@@ -0,0 +1,71 @@
+/**
+ * `filters.threshold@1` — keep pixels whose luma is above `threshold`,
+ * black out the rest. `softness` widens the cutoff into a smooth ramp.
+ *
+ * Used as the bright-extraction stage of the `filters.glow` recipe and as a
+ * general-purpose bright-pass filter.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ThresholdParams = d.struct({
+    threshold: d.f32,
+    softness: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ThresholdParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const filtersThresholdV1 = defineModule({
+    id: "filters.threshold",
+    version: 1,
+    surface: "internal",
+    category: "filters",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: ThresholdParams,
+    paramDefaults: { threshold: 0.7, softness: 0.1 },
+    paramUi: {
+        threshold: { min: 0, max: 1, step: 0.01, label: "Threshold" },
+        softness: { min: 0, max: 0.5, step: 0.01, label: "Softness" }
+    },
+    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;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let luma = dot(straight, vec3f(0.299, 0.587, 0.114));
+  let soft = max(p.softness, 0.0001);
+  let t = smoothstep(p.threshold - soft, p.threshold + soft, luma);
+  return vec4f(src.rgb * t, src.a * t);
+}
+`,
+    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/filters/threshold/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/filters/threshold/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,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,SAAS,EAAE,CAAC,CAAC,GAAG;IAChB,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,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,SAAS;IACnB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,eAAe;IACvB,aAAa,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE;IAChD,OAAO,EAAE;QACP,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;QAC7D,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;KAC9D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;CAYlB;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/filters/vignette/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `filters.vignette@1` — radial darken from frame center.
+ *
+ * Migrated verbatim from the timeline preview's `vignetteComputeShader`.
+ * Hand-packed uniform → TypeGPU `VignetteParams`; the falloff math is unchanged.
+ */
+import * as d from "typegpu/data";
+export declare const VignetteParams: d.WgslStruct<{
+    intensity: d.F32;
+    radius: d.F32;
+    softness: d.F32;
+}>;
+export declare const vignetteV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    intensity: d.F32;
+    radius: d.F32;
+    softness: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,78 @@
+/**
+ * `filters.vignette@1` — radial darken from frame center.
+ *
+ * Migrated verbatim from the timeline preview's `vignetteComputeShader`.
+ * Hand-packed uniform → TypeGPU `VignetteParams`; the falloff math is unchanged.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const VignetteParams = d.struct({
+    intensity: d.f32,
+    radius: d.f32,
+    softness: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" },
+    params: { uniform: VignetteParams }
+});
+export const vignetteV1 = defineModule({
+    id: "filters.vignette",
+    version: 1,
+    // Promoted in Phase 3: (intensity, radius, softness) schema has been stable
+    // since Phase 2 and the falloff math is unchanged.
+    surface: "published",
+    category: "filters",
+    linearity: "linear-in-rgb",
+    kind: "compute",
+    params: VignetteParams,
+    paramDefaults: { intensity: 0, radius: 0.9, softness: 0.5 },
+    paramUi: {
+        intensity: { min: 0, max: 1, step: 0.01, label: "Intensity" },
+        radius: { min: 0.1, max: 1.5, step: 0.01, label: "Radius" },
+        softness: { min: 0, max: 1, step: 0.01, label: "Softness" }
+    },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+@compute @workgroup_size(16, 16, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let dims = textureDimensions(layout.$.source);
+  if (gid.x >= dims.x || gid.y >= dims.y) { return; }
+  let coords = vec2<i32>(i32(gid.x), i32(gid.y));
+  let v = layout.$.params;
+  let color = textureLoad(layout.$.source, coords, 0);
+
+  // Normalize to [-1, 1] coordinates centered on the frame.
+  let uv = vec2<f32>(
+    (f32(gid.x) + 0.5) / f32(dims.x) * 2.0 - 1.0,
+    (f32(gid.y) + 0.5) / f32(dims.y) * 2.0 - 1.0
+  );
+  let dist = length(uv);
+  let inner = max(0.0, v.radius - v.softness);
+  let outer = max(inner + 0.001, v.radius);
+  let t = clamp((dist - inner) / (outer - inner), 0.0, 1.0);
+  let fade = t * t * (3.0 - 2.0 * t);
+  let dim = 1.0 - v.intensity * fade;
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(color.rgb * dim, color.a)); // premul: ok — scalar '* dim' preserves rgb <= a
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/filters/vignette/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;AAErD,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,SAAS,EAAE,CAAC,CAAC,GAAG;IAChB,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,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,cAAc,EAAE;CACpC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,YAAY,CAAC;IACrC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EAAE,CAAC;IACV,4EAA4E;IAC5E,mDAAmD;IACnD,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE;IAC3D,OAAO,EAAE;QACP,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;QAC7D,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;QAC3D,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;KAC5D;IACD,MAAM;IACN,aAAa,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,24 @@
+import * as d from "typegpu/data";
+export declare const VisualFxParams: d.WgslStruct<{
+    mode: d.F32;
+    amount: d.F32;
+    scale: d.F32;
+    angle: d.F32;
+    time: d.F32;
+    seed: d.F32;
+    softness: d.F32;
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+}>;
+export declare const filtersVisualFxV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mode: d.F32;
+    amount: d.F32;
+    scale: d.F32;
+    angle: d.F32;
+    time: d.F32;
+    seed: d.F32;
+    softness: d.F32;
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/filters/visualFx/v1/module.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,cAAc;;;;;;;;;;EAUzB,CAAC;AASH,eAAO,MAAM,iBAAiB;;;;;;;;;;GA4L5B,CAAC"}