@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,70 @@
+/**
+ * `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 tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const CheckerboardParams = d.struct({
+    colorA: d.vec4f,
+    colorB: d.vec4f,
+    cellSize: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CheckerboardParams }
+});
+export const sourcesCheckerboardV1 = defineModule({
+    id: "sources.checkerboard",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: CheckerboardParams,
+    paramDefaults: {
+        colorA: d.vec4f(0.8, 0.8, 0.8, 1),
+        colorB: d.vec4f(0.2, 0.2, 0.2, 1),
+        cellSize: 16
+    },
+    paramUi: {
+        colorA: { label: "Color A" },
+        colorB: { label: "Color B" },
+        cellSize: { min: 1, max: 256, step: 1, label: "Cell size", notes: "pixels" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+struct Out {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@fragment
+fn fs_main(in: Out) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let cell = max(1.0, p.cellSize);
+  let coord = vec2i(in.position.xy / cell);
+  let parity = (coord.x + coord.y) % 2;
+  // The colour params arrive premultiplied (hosts premultiply at the colour
+  // picker boundary), so return them as-is. Re-multiplying by alpha here
+  // would darken translucent cell colours to rgb*a².
+  if (parity == 0) {
+    return p.colorA;
+  }
+  return p.colorB;
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/checkerboard/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,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,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,kBAAkB,EAAE;CACxC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG,YAAY,CAAC;IAChD,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,kBAAkB;IAC1B,aAAa,EAAE;QACb,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QACjC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QACjC,QAAQ,EAAE,EAAE;KACb;IACD,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,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,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBlB;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/diamondGradient/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `sources.diamondGradient@1` — two-color diamond gradient.
+ *
+ * Uses Manhattan distance from center for a diamond-shaped ramp. Zero-input
+ * source, host-specified dimensions.
+ */
+import * as d from "typegpu/data";
+export declare const DiamondGradientParams: d.WgslStruct<{
+    colorInner: d.Vec4f;
+    colorOuter: d.Vec4f;
+    radius: d.F32;
+}>;
+export declare const sourcesDiamondGradientV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    colorInner: d.Vec4f;
+    colorOuter: d.Vec4f;
+    radius: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,61 @@
+/**
+ * `sources.diamondGradient@1` — two-color diamond gradient.
+ *
+ * Uses Manhattan distance from center for a diamond-shaped ramp. Zero-input
+ * source, host-specified dimensions.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const DiamondGradientParams = d.struct({
+    colorInner: d.vec4f,
+    colorOuter: d.vec4f,
+    radius: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: DiamondGradientParams }
+});
+export const sourcesDiamondGradientV1 = defineModule({
+    id: "sources.diamondGradient",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: DiamondGradientParams,
+    paramDefaults: {
+        colorInner: d.vec4f(0, 0, 0, 1),
+        colorOuter: d.vec4f(1, 1, 1, 1),
+        radius: 0.5
+    },
+    paramUi: {
+        colorInner: { label: "Inner color" },
+        colorOuter: { label: "Outer color" },
+        radius: { min: 0.01, max: 1.5, step: 0.01, label: "Radius" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let d = abs(uv - vec2f(0.5, 0.5));
+  let r = max(p.radius, 0.0001);
+  let t = clamp((d.x + d.y) / r, 0.0, 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.colorInner, p.colorOuter, t);
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/diamondGradient/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,UAAU,EAAE,CAAC,CAAC,KAAK;IACnB,UAAU,EAAE,CAAC,CAAC,KAAK;IACnB,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,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,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC/B,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC/B,MAAM,EAAE,GAAG;KACZ;IACD,OAAO,EAAE;QACP,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE;QACpC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE;QACpC,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;KAC7D;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/gaussianNoise/v1/module.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `sources.gaussianNoise@1` — fill the output with per-channel Gaussian noise.
+ *
+ * Zero-input source (host-specified dimensions). Each channel gets an
+ * independent sample drawn via the Box-Muller transform from a hash-based RNG
+ * keyed by pixel position + `seed`, then mapped to [0,1] as
+ * `((mean + g*stddev) * 128 + 128) / 255` (matching the legacy CPU node). Pass a
+ * fresh `seed` per run for run-to-run variation. Output is opaque.
+ */
+import * as d from "typegpu/data";
+export declare const GaussianNoiseParams: d.WgslStruct<{
+    mean: d.F32;
+    stddev: d.F32;
+    seed: d.F32;
+}>;
+export declare const sourcesGaussianNoiseV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mean: d.F32;
+    stddev: d.F32;
+    seed: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/gaussianNoise/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAMH,eAAO,MAAM,sBAAsB;;;;GAkDjC,CAAC"}

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

@@ -0,0 +1,72 @@
+/**
+ * `sources.gaussianNoise@1` — fill the output with per-channel Gaussian noise.
+ *
+ * Zero-input source (host-specified dimensions). Each channel gets an
+ * independent sample drawn via the Box-Muller transform from a hash-based RNG
+ * keyed by pixel position + `seed`, then mapped to [0,1] as
+ * `((mean + g*stddev) * 128 + 128) / 255` (matching the legacy CPU node). Pass a
+ * fresh `seed` per run for run-to-run variation. Output is opaque.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const GaussianNoiseParams = d.struct({
+    mean: d.f32,
+    stddev: d.f32,
+    seed: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: GaussianNoiseParams }
+});
+export const sourcesGaussianNoiseV1 = defineModule({
+    id: "sources.gaussianNoise",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: GaussianNoiseParams,
+    paramDefaults: { mean: 0, stddev: 1, seed: 0 },
+    paramUi: {
+        mean: { min: -1, max: 1, step: 0.01, label: "Mean" },
+        stddev: { min: 0, max: 4, step: 0.01, label: "Std Dev" },
+        seed: { label: "Seed" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+fn hash21(p: vec2f) -> f32 {
+  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
+  p3 = p3 + dot(p3, vec3f(p3.y, p3.z, p3.x) + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+fn gauss(p: vec2f, seed: f32) -> f32 {
+  let u1 = max(1e-6, hash21(p + vec2f(seed, 0.0)));
+  let u2 = hash21(p + vec2f(0.0, seed));
+  return sqrt(-2.0 * log(u1)) * cos(6.28318530718 * u2);
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = uv * 4096.0;
+  let m = layout.$.params.mean;
+  let s = layout.$.params.stddev;
+  let base = layout.$.params.seed;
+  let r = clamp(((m + gauss(p, base + 1.0) * s) * 128.0 + 128.0) / 255.0, 0.0, 1.0);
+  let g = clamp(((m + gauss(p, base + 2.0) * s) * 128.0 + 128.0) / 255.0, 0.0, 1.0);
+  let b = clamp(((m + gauss(p, base + 3.0) * s) * 128.0 + 128.0) / 255.0, 0.0, 1.0);
+  return vec4f(r, g, b, 1.0);
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/gaussianNoise/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,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,mBAAmB,EAAE;CACzC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,YAAY,CAAC;IACjD,EAAE,EAAE,uBAAuB;IAC3B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,mBAAmB;IAC3B,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;IAC9C,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;QACpD,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE;QACxD,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;KACxB;IACD,MAAM;IACN,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB;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/linearGradient/v1/module.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `sources.linearGradient@1` — two-color linear gradient at an angle.
+ *
+ * `angle` in radians (0 = horizontal, left→right); `midpoint` shifts the 50%
+ * mark along the gradient axis (0..1). Zero-input source, host-specified
+ * dimensions.
+ */
+import * as d from "typegpu/data";
+export declare const LinearGradientParams: d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    angle: d.F32;
+    midpoint: d.F32;
+}>;
+export declare const sourcesLinearGradientV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    colorA: d.Vec4f;
+    colorB: d.Vec4f;
+    angle: d.F32;
+    midpoint: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/linearGradient/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,oBAAoB;;;;;EAK/B,CAAC;AAMH,eAAO,MAAM,uBAAuB;;;;;GAmDlC,CAAC"}

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

@@ -0,0 +1,72 @@
+/**
+ * `sources.linearGradient@1` — two-color linear gradient at an angle.
+ *
+ * `angle` in radians (0 = horizontal, left→right); `midpoint` shifts the 50%
+ * mark along the gradient axis (0..1). Zero-input source, host-specified
+ * dimensions.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const LinearGradientParams = d.struct({
+    colorA: d.vec4f,
+    colorB: d.vec4f,
+    angle: d.f32,
+    midpoint: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: LinearGradientParams }
+});
+export const sourcesLinearGradientV1 = defineModule({
+    id: "sources.linearGradient",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: LinearGradientParams,
+    paramDefaults: {
+        colorA: d.vec4f(0, 0, 0, 1),
+        colorB: d.vec4f(1, 1, 1, 1),
+        angle: 0,
+        midpoint: 0.5
+    },
+    paramUi: {
+        colorA: { label: "Color A" },
+        colorB: { label: "Color B" },
+        angle: { min: -Math.PI, max: Math.PI, step: 0.01, label: "Angle", notes: "radians" },
+        midpoint: { min: 0.01, max: 0.99, step: 0.01, label: "Midpoint" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let c = vec2f(cos(p.angle), sin(p.angle));
+  let t01 = clamp(dot(uv - vec2f(0.5), c) + 0.5, 0.0, 1.0);
+  let mid = clamp(p.midpoint, 0.01, 0.99);
+  var t: f32 = 0.0;
+  if (t01 < mid) {
+    t = (t01 / mid) * 0.5;
+  } else {
+    t = 0.5 + ((t01 - mid) / (1.0 - mid)) * 0.5;
+  }
+  // The colour params arrive premultiplied (hosts premultiply at the colour
+  // picker boundary, matching the pool's between-modules invariant), and a mix
+  // of premultiplied endpoints is itself premultiplied. Re-multiplying by
+  // alpha here would darken translucent stops 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/linearGradient/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/linearGradient/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,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,MAAM,EAAE,CAAC,CAAC,KAAK;IACf,MAAM,EAAE,CAAC,CAAC,KAAK;IACf,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,QAAQ,EAAE,CAAC,CAAC,GAAG;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,oBAAoB,EAAE;CAC1C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CAAC;IAClD,EAAE,EAAE,wBAAwB;IAC5B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,oBAAoB;IAC5B,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,KAAK,EAAE,CAAC;QACR,QAAQ,EAAE,GAAG;KACd;IACD,OAAO,EAAE;QACP,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAC5B,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE;QACpF,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;KAClE;IACD,MAAM;IACN,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBlB;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/radialGradient/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `sources.radialGradient@1` — two-color radial gradient.
+ *
+ * `radius` controls where the outer color is fully reached (in normalized UV
+ * units from center). Zero-input source, host-specified dimensions.
+ */
+import * as d from "typegpu/data";
+export declare const RadialGradientParams: d.WgslStruct<{
+    colorInner: d.Vec4f;
+    colorOuter: d.Vec4f;
+    radius: d.F32;
+}>;
+export declare const sourcesRadialGradientV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    colorInner: d.Vec4f;
+    colorOuter: d.Vec4f;
+    radius: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/radialGradient/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AAMH,eAAO,MAAM,uBAAuB;;;;GAyClC,CAAC"}

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

@@ -0,0 +1,60 @@
+/**
+ * `sources.radialGradient@1` — two-color radial gradient.
+ *
+ * `radius` controls where the outer color is fully reached (in normalized UV
+ * units from center). Zero-input source, host-specified dimensions.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const RadialGradientParams = d.struct({
+    colorInner: d.vec4f,
+    colorOuter: d.vec4f,
+    radius: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: RadialGradientParams }
+});
+export const sourcesRadialGradientV1 = defineModule({
+    id: "sources.radialGradient",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: RadialGradientParams,
+    paramDefaults: {
+        colorInner: d.vec4f(0, 0, 0, 1),
+        colorOuter: d.vec4f(1, 1, 1, 1),
+        radius: 0.5
+    },
+    paramUi: {
+        colorInner: { label: "Inner color" },
+        colorOuter: { label: "Outer color" },
+        radius: { min: 0.01, max: 1.5, step: 0.01, label: "Radius" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let r = max(p.radius, 0.0001);
+  let t = clamp(distance(uv, vec2f(0.5, 0.5)) / r, 0.0, 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.colorInner, p.colorOuter, t);
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/radialGradient/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,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,UAAU,EAAE,CAAC,CAAC,KAAK;IACnB,UAAU,EAAE,CAAC,CAAC,KAAK;IACnB,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,oBAAoB,EAAE;CAC1C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CAAC;IAClD,EAAE,EAAE,wBAAwB;IAC5B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,oBAAoB;IAC5B,aAAa,EAAE;QACb,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC/B,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC/B,MAAM,EAAE,GAAG;KACZ;IACD,OAAO,EAAE;QACP,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE;QACpC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE;QACpC,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;KAC7D;IACD,MAAM;IACN,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;CAWlB;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/solid/v1/module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `sources.solid@1` — fill the entire output with a single color.
+ *
+ * Zero-input source. Output dimensions are `host-specified` — the host
+ * allocates the target texture at the resolution it wants, the module just
+ * writes the same RGBA into every pixel. Alpha is premultiplied per the
+ * pool's convention (callers passing a straight-alpha color must
+ * pre-multiply before assigning to the param).
+ */
+import * as d from "typegpu/data";
+export declare const SolidParams: d.WgslStruct<{
+    color: d.Vec4f;
+}>;
+export declare const sourcesSolidV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    color: d.Vec4f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/sources/solid/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,WAAW;;EAEtB,CAAC;AAMH,eAAO,MAAM,cAAc;;GA6BzB,CAAC"}

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

@@ -0,0 +1,49 @@
+/**
+ * `sources.solid@1` — fill the entire output with a single color.
+ *
+ * Zero-input source. Output dimensions are `host-specified` — the host
+ * allocates the target texture at the resolution it wants, the module just
+ * writes the same RGBA into every pixel. Alpha is premultiplied per the
+ * pool's convention (callers passing a straight-alpha color must
+ * pre-multiply before assigning to the param).
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const SolidParams = d.struct({
+    color: d.vec4f
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: SolidParams }
+});
+export const sourcesSolidV1 = defineModule({
+    id: "sources.solid",
+    version: 1,
+    surface: "internal",
+    category: "sources",
+    linearity: "source",
+    kind: "fragment",
+    params: SolidParams,
+    paramDefaults: { color: d.vec4f(0, 0, 0, 1) },
+    paramUi: {
+        color: { label: "Color", notes: "RGBA, premultiplied" }
+    },
+    layout,
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  return layout.$.params.color;
+}
+`,
+    io: {
+        inputs: {},
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/sources/solid/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,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,KAAK,EAAE,CAAC,CAAC,KAAK;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,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,SAAS,EAAE,QAAQ;IACnB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,WAAW;IACnB,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE;IAC7C,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,qBAAqB,EAAE;KACxD;IACD,MAAM;IACN,IAAI,EAAE,UAAU,CAAC;;;;;CAKlB;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/transform/affine/v1/module.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `transform.affine@1` — apply an inverse 2D affine matrix to remap UV space.
+ *
+ * The params spell out a 2×3 inverse matrix: each output UV `(u, v)` maps to
+ * the source UV `(m00*u + m01*v + tx, m10*u + m11*v + ty)`. Authoring the
+ * **inverse** keeps the WGSL a single matrix-vector multiply — exactly the
+ * same pattern `compositor/transform.ts` uses for layer placement.
+ *
+ * Output dimensions are `host-specified`. Out-of-bounds samples
+ * (`u < 0 || u > 1 || v < 0 || v > 1`) return transparent black so a rotated
+ * or scaled source leaves cleanly transparent corners rather than smearing
+ * the edge color.
+ *
+ * For arbitrary rotation around the source center with scale, the host
+ * composes the inverse matrix on the CPU (`compositor/transform.ts`
+ * `layerTransformToInverseAffine` is the canonical helper); this module
+ * just consumes it.
+ */
+import * as d from "typegpu/data";
+export declare const AffineParams: d.WgslStruct<{
+    m00: d.F32;
+    m01: d.F32;
+    tx: d.F32;
+    m10: d.F32;
+    m11: d.F32;
+    ty: d.F32;
+}>;
+export declare const transformAffineV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    m00: d.F32;
+    m01: d.F32;
+    tx: d.F32;
+    m10: d.F32;
+    m11: d.F32;
+    ty: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/transform/affine/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/affine/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,YAAY;;;;;;;EAOvB,CAAC;AAeH,eAAO,MAAM,iBAAiB;;;;;;;GAoD5B,CAAC"}