@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,28 @@
+/**
+ * `mixer.dropShadow@1` — drop-shadow layer effect as a four-pass recipe.
+ *
+ * `mask.fromImage` (alpha) → `filters.blur.gaussian` H → `filters.blur.gaussian` V
+ * → `mixer.shadowCompose` over source.
+ *
+ * Mirrors the `filters.glow@1` recipe structure: the alpha is the only
+ * channel that drives shadow shape, so a single-channel mask intermediate is
+ * cheaper than blurring the full source. Offsets are normalized UV units —
+ * the host translates pixel-space drag handles into UV before pushing
+ * params.
+ */
+import * as d from "typegpu/data";
+export declare const DropShadowParams: d.WgslStruct<{
+    color: d.Vec4f;
+    offsetX: d.F32;
+    offsetY: d.F32;
+    radius: d.F32;
+    intensity: d.F32;
+}>;
+export declare const mixerDropShadowV1: import("../../../../recipe.js").RecipeModule<{
+    color: d.v4f;
+    offsetX: number;
+    offsetY: number;
+    radius: number;
+    intensity: number;
+}>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/mixer/dropShadow/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAC;AAQH,eAAO,MAAM,iBAAiB;;;;;;EA4E5B,CAAC"}

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

@@ -0,0 +1,104 @@
+/**
+ * `mixer.dropShadow@1` — drop-shadow layer effect as a four-pass recipe.
+ *
+ * `mask.fromImage` (alpha) → `filters.blur.gaussian` H → `filters.blur.gaussian` V
+ * → `mixer.shadowCompose` over source.
+ *
+ * Mirrors the `filters.glow@1` recipe structure: the alpha is the only
+ * channel that drives shadow shape, so a single-channel mask intermediate is
+ * cheaper than blurring the full source. Offsets are normalized UV units —
+ * the host translates pixel-space drag handles into UV before pushing
+ * params.
+ */
+import * as d from "typegpu/data";
+import { defineRecipe } from "../../../../recipe.js";
+export const DropShadowParams = d.struct({
+    color: d.vec4f,
+    offsetX: d.f32,
+    offsetY: d.f32,
+    radius: d.f32,
+    intensity: d.f32
+});
+// Inlined GPUTextureUsage flags (see filters.glow for the rationale):
+//   COPY_SRC = 0x01, TEXTURE_BINDING = 0x04, STORAGE_BINDING = 0x08,
+//   RENDER_ATTACHMENT = 0x10
+const INTERMEDIATE_MASK_USAGE = 0x10 | 0x04 | 0x01;
+const INTERMEDIATE_BLUR_USAGE = 0x08 | 0x04 | 0x01;
+export const mixerDropShadowV1 = defineRecipe({
+    id: "mixer.dropShadow",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    paramDefaults: {
+        color: d.vec4f(0, 0, 0, 1),
+        offsetX: 0.02,
+        offsetY: 0.02,
+        radius: 8,
+        intensity: 0.6
+    },
+    paramUi: {
+        color: { label: "Shadow color", notes: "RGBA, straight alpha" },
+        offsetX: { min: -0.5, max: 0.5, step: 0.005, label: "Offset X" },
+        offsetY: { min: -0.5, max: 0.5, step: 0.005, label: "Offset Y" },
+        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: {
+            mask: { format: "rgba8unorm", usage: INTERMEDIATE_MASK_USAGE },
+            blurH: { format: "rgba8unorm", usage: INTERMEDIATE_BLUR_USAGE },
+            blurV: { format: "rgba8unorm", usage: INTERMEDIATE_BLUR_USAGE }
+        },
+        passes: [
+            {
+                op: { id: "mask.fromImage", version: 1 },
+                in: { source: "source" },
+                out: { kind: "intermediate", name: "mask" },
+                params: { mode: 0, invert: 0 }
+            },
+            {
+                op: { id: "filters.blur.gaussian", version: 1 },
+                in: { source: { kind: "intermediate", name: "mask" } },
+                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.shadowCompose", version: 1 },
+                in: {
+                    source: "source",
+                    shadowMask: { kind: "intermediate", name: "blurV" }
+                },
+                out: "output",
+                params: {
+                    color: "$.color",
+                    offsetX: "$.offsetX",
+                    offsetY: "$.offsetY",
+                    intensity: "$.intensity"
+                }
+            }
+        ]
+    }
+});
+//# sourceMappingURL=module.js.map

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * `mixer.outline@1` — flat outline / stroke around the source silhouette.
+ *
+ * Samples eight ring positions at radius `widthPx` (pixels, converted to UV
+ * via `textureDimensions(source)`). Pixels outside the silhouette
+ * (`source.a ≤ threshold`) that find any ring neighbour above threshold are
+ * filled with the outline color; pixels inside the silhouette pass through.
+ * The eight-tap ring is approximate but cheap and visually fine at small
+ * widths — for wide, soft outlines, the recipe form (extract → blur →
+ * composite) is the right tool.
+ *
+ * Output dimensions stay `same-as:source` — the outline lives inside the
+ * source canvas. Sources that need outline room outside the original
+ * silhouette should `transform.pad` first.
+ */
+import * as d from "typegpu/data";
+export declare const OutlineParams: d.WgslStruct<{
+    color: d.Vec4f;
+    widthPx: d.F32;
+    threshold: d.F32;
+}>;
+export declare const mixerOutlineV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    color: d.Vec4f;
+    widthPx: d.F32;
+    threshold: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/mixer/outline/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,aAAa;;;;EAIxB,CAAC;AAeH,eAAO,MAAM,cAAc;;;;GAqEzB,CAAC"}

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

@@ -0,0 +1,105 @@
+/**
+ * `mixer.outline@1` — flat outline / stroke around the source silhouette.
+ *
+ * Samples eight ring positions at radius `widthPx` (pixels, converted to UV
+ * via `textureDimensions(source)`). Pixels outside the silhouette
+ * (`source.a ≤ threshold`) that find any ring neighbour above threshold are
+ * filled with the outline color; pixels inside the silhouette pass through.
+ * The eight-tap ring is approximate but cheap and visually fine at small
+ * widths — for wide, soft outlines, the recipe form (extract → blur →
+ * composite) is the right tool.
+ *
+ * Output dimensions stay `same-as:source` — the outline lives inside the
+ * source canvas. Sources that need outline room outside the original
+ * silhouette should `transform.pad` first.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const OutlineParams = d.struct({
+    color: d.vec4f,
+    widthPx: d.f32,
+    threshold: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: OutlineParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const mixerOutlineV1 = defineModule({
+    id: "mixer.outline",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: OutlineParams,
+    paramDefaults: { color: d.vec4f(0, 0, 0, 1), widthPx: 2, threshold: 0.5 },
+    paramUi: {
+        color: { label: "Color", notes: "RGBA, straight alpha" },
+        widthPx: { min: 0, max: 32, step: 0.5, label: "Width", notes: "pixels" },
+        threshold: { min: 0, max: 1, step: 0.01, label: "Alpha threshold" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let p = layout.$.params;
+  let dims = vec2f(textureDimensions(layout.$.source));
+  let step = p.widthPx / dims;
+  // Eight ring samples, π/4 apart, at radius = widthPx. The loop runs
+  // unconditionally so the ring textureSample stays in uniform control flow;
+  // the result is gated by select() below rather than early returns.
+  let dirs = array<vec2f, 8>(
+    vec2f(1.0, 0.0),
+    vec2f(0.70710678, 0.70710678),
+    vec2f(0.0, 1.0),
+    vec2f(-0.70710678, 0.70710678),
+    vec2f(-1.0, 0.0),
+    vec2f(-0.70710678, -0.70710678),
+    vec2f(0.0, -1.0),
+    vec2f(0.70710678, -0.70710678)
+  );
+  var maxA: f32 = 0.0;
+  for (var i = 0; i < 8; i = i + 1) {
+    let s = textureSample(layout.$.source, layout.$.samp, uv + dirs[i] * step);
+    maxA = max(maxA, s.a);
+  }
+  let cov = p.color.a;
+  let outline = vec4f(p.color.rgb * cov, cov);
+  // Outside the silhouette with a ring neighbour above threshold → outline;
+  // outside with no neighbour → transparent black.
+  let edge = select(vec4f(0.0), outline, maxA > p.threshold);
+  // widthPx <= 0 ("no outline") or inside the silhouette → pass source through.
+  // widthPx is a uniform, but the source-alpha test is per-pixel, so both
+  // collapse into a single uniform-control-flow select.
+  let passthrough = p.widthPx <= 0.0 || src.a > p.threshold;
+  return select(edge, src, passthrough);
+}
+`,
+    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/outline/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mixer/outline/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;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,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,KAAK,EAAE,CAAC,CAAC,KAAK;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,SAAS,EAAE,CAAC,CAAC,GAAG;CACjB,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,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE;IACzE,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACxD,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE;QACxE,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,iBAAiB,EAAE;KACpE;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoClB;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/over/v1/module.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `mixer.over@1` — Porter-Duff source-over composite of `over` onto `source`.
+ *
+ * Premultiplied alpha throughout: `out = over*opacity + source*(1 - over.a*opacity)`.
+ * `opacity` scales the overlay (default 1). Both inputs are sampled at the same
+ * UV, so callers place/resize the overlay onto the source's canvas first (e.g.
+ * `transform.pad`). Output is `same-as:source`.
+ */
+import * as d from "typegpu/data";
+export declare const OverParams: d.WgslStruct<{
+    opacity: d.F32;
+}>;
+export declare const mixerOverV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    opacity: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * `mixer.over@1` — Porter-Duff source-over composite of `over` onto `source`.
+ *
+ * Premultiplied alpha throughout: `out = over*opacity + source*(1 - over.a*opacity)`.
+ * `opacity` scales the overlay (default 1). Both inputs are sampled at the same
+ * UV, so callers place/resize the overlay onto the source's canvas first (e.g.
+ * `transform.pad`). Output is `same-as:source`.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const OverParams = d.struct({
+    opacity: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: OverParams },
+    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 mixerOverV1 = defineModule({
+    id: "mixer.over",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: OverParams,
+    paramDefaults: { opacity: 1 },
+    paramUi: {
+        opacity: { min: 0, max: 1, step: 0.01, label: "Opacity" }
+    },
+    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) * layout.$.params.opacity;
+  return o + s * (1.0 - o.a);
+}
+`,
+    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: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mixer/over/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,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,OAAO,EAAE,CAAC,CAAC,GAAG;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;IAC/B,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,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,UAAU;IAClB,aAAa,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE;IAC7B,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE;KAC1D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;CAOlB;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/mixer/shadowCompose/v1/module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `mixer.shadowCompose@1` — composite `source` over a coloured, offset
+ * shadow read from a precomputed mask.
+ *
+ * Internal helper for the `mixer.dropShadow@1` recipe. Samples `shadowMask`
+ * at `uv - offset`, multiplies its alpha by the shadow `color` and
+ * `intensity` to produce a shadow contribution, then alpha-composites
+ * `source` over the shadow.
+ *
+ * Stays `surface: "internal"` — published consumers should use the recipe,
+ * not this primitive directly.
+ */
+import * as d from "typegpu/data";
+export declare const ShadowComposeParams: d.WgslStruct<{
+    color: d.Vec4f;
+    offsetX: d.F32;
+    offsetY: d.F32;
+    intensity: d.F32;
+}>;
+export declare const mixerShadowComposeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    color: d.Vec4f;
+    offsetX: d.F32;
+    offsetY: d.F32;
+    intensity: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,95 @@
+/**
+ * `mixer.shadowCompose@1` — composite `source` over a coloured, offset
+ * shadow read from a precomputed mask.
+ *
+ * Internal helper for the `mixer.dropShadow@1` recipe. Samples `shadowMask`
+ * at `uv - offset`, multiplies its alpha by the shadow `color` and
+ * `intensity` to produce a shadow contribution, then alpha-composites
+ * `source` over the shadow.
+ *
+ * Stays `surface: "internal"` — published consumers should use the recipe,
+ * not this primitive directly.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ShadowComposeParams = d.struct({
+    color: d.vec4f,
+    offsetX: d.f32,
+    offsetY: d.f32,
+    intensity: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ShadowComposeParams },
+    source: { texture: "float" },
+    shadowMask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const mixerShadowComposeV1 = defineModule({
+    id: "mixer.shadowCompose",
+    version: 1,
+    surface: "internal",
+    category: "mixer",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: ShadowComposeParams,
+    paramDefaults: {
+        color: d.vec4f(0, 0, 0, 1),
+        offsetX: 0.02,
+        offsetY: 0.02,
+        intensity: 0.6
+    },
+    paramUi: {
+        color: { label: "Shadow color", notes: "RGBA, straight alpha" },
+        offsetX: { min: -0.5, max: 0.5, step: 0.005, label: "Offset X" },
+        offsetY: { min: -0.5, max: 0.5, step: 0.005, label: "Offset Y" },
+        intensity: { min: 0, max: 4, step: 0.01, label: "Intensity" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let shadowUv = uv - vec2f(p.offsetX, p.offsetY);
+  // Sample the mask unconditionally (textureSample must run in uniform control
+  // flow) and zero its contribution outside the offset mask's bounds.
+  let inBounds = shadowUv.x >= 0.0 && shadowUv.x <= 1.0 && shadowUv.y >= 0.0 && shadowUv.y <= 1.0;
+  let shadowSample = textureSample(layout.$.shadowMask, layout.$.samp, shadowUv);
+  let shadowA = select(0.0, shadowSample.a, inBounds);
+  let cov = clamp(shadowA * p.color.a * p.intensity, 0.0, 1.0);
+  let shadow = vec4f(p.color.rgb * cov, cov);
+  // source over shadow: out = src + shadow * (1 - src.a). Both premultiplied.
+  return src + shadow * (1.0 - src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            shadowMask: {
+                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/shadowCompose/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/mixer/shadowCompose/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,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,KAAK;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,SAAS,EAAE,CAAC,CAAC,GAAG;CACjB,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,UAAU,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAChC,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,YAAY,CAAC;IAC/C,EAAE,EAAE,qBAAqB;IACzB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,mBAAmB;IAC3B,aAAa,EAAE;QACb,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC1B,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI;QACb,SAAS,EAAE,GAAG;KACf;IACD,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,sBAAsB,EAAE;QAC/D,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE;QAChE,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE;QAChE,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;KAC9D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBlB;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,UAAU,EAAE;gBACV,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/sources/angularGradient/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `sources.angularGradient@1` — two-color angular gradient around center.
+ *
+ * `rotation` offsets the seam angle in radians. Zero-input source,
+ * host-specified dimensions.
+ */
+import * as d from "typegpu/data";
+export declare const AngularGradientParams: d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    rotation: d.F32;
+}>;
+export declare const sourcesAngularGradientV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    rotation: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/sources/angularGradient/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/angularGradient/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,qBAAqB;;;;EAIhC,CAAC;AAMH,eAAO,MAAM,wBAAwB;;;;GAgDnC,CAAC"}

package/dist/shaders/sources/angularGradient/v1/module.js

@@ -0,0 +1,67 @@
+/**
+ * `sources.angularGradient@1` — two-color angular gradient around center.
+ *
+ * `rotation` offsets the seam angle in radians. Zero-input source,
+ * host-specified dimensions.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const AngularGradientParams = d.struct({
+    colorA: d.vec4f,
+    colorB: d.vec4f,
+    rotation: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: AngularGradientParams }
+});
+export const sourcesAngularGradientV1 = defineModule({
+    id: "sources.angularGradient",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: AngularGradientParams,
+    paramDefaults: {
+        colorA: d.vec4f(0, 0, 0, 1),
+        colorB: d.vec4f(1, 1, 1, 1),
+        rotation: 0
+    },
+    paramUi: {
+        colorA: { label: "Color A" },
+        colorB: { label: "Color B" },
+        rotation: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+            label: "Rotation",
+            notes: "radians"
+        }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let delta = uv - vec2f(0.5, 0.5);
+  let theta = atan2(delta.y, delta.x) - p.rotation;
+  let t = fract(theta / (2.0 * 3.14159265359) + 1.0);
+  // The colour params arrive premultiplied (hosts premultiply at the colour
+  // picker boundary); a mix of premultiplied endpoints stays premultiplied.
+  // Re-multiplying by alpha here would darken translucent colours to rgb*a².
+  return mix(p.colorA, p.colorB, t);
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/sources/angularGradient/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/angularGradient/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,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,MAAM,EAAE,CAAC,CAAC,KAAK;IACf,MAAM,EAAE,CAAC,CAAC,KAAK;IACf,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,qBAAqB,EAAE;CAC3C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,YAAY,CAAC;IACnD,EAAE,EAAE,yBAAyB;IAC7B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,qBAAqB;IAC7B,aAAa,EAAE;QACb,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC3B,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC3B,QAAQ,EAAE,CAAC;KACZ;IACD,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,QAAQ,EAAE;YACR,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE;YACb,GAAG,EAAE,IAAI,CAAC,EAAE;YACZ,IAAI,EAAE,IAAI;YACV,KAAK,EAAE,UAAU;YACjB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,MAAM;IACN,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;CAYlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE,EAAE;QACV,MAAM,EAAE;YACN,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,UAAU;KAChB;CACF,CAAC,CAAC"}

package/dist/shaders/sources/checkerboard/v1/module.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `sources.checkerboard@1` — two-color checkerboard pattern.
+ *
+ * `cellSize` is in output pixels. Zero-input source, host-specified
+ * dimensions — the host picks the output resolution; cell count follows
+ * directly from that and `cellSize`.
+ */
+import * as d from "typegpu/data";
+export declare const CheckerboardParams: d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    cellSize: d.F32;
+}>;
+export declare const sourcesCheckerboardV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    cellSize: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/sources/checkerboard/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/checkerboard/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,kBAAkB;;;;EAI7B,CAAC;AAMH,eAAO,MAAM,qBAAqB;;;;GAkDhC,CAAC"}