@nodetool-ai/gpu 0.8.1

package/dist/shaders/transform/offset/v1/module.js

@@ -0,0 +1,88 @@
+/**
+ * `transform.offset@1` — translate the source by a normalized UV offset,
+ * with the address mode controlled by `wrap` (`0` clamp-to-edge,
+ * `1` repeat, `2` mirror-repeat).
+ *
+ * `dx`/`dy` are in normalized UV units (`0..1`). Output dimensions are
+ * `same-as:source`; for `wrap = 0`, regions outside the original sample
+ * area return the edge color (so they don't introduce transparent pixels).
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const OffsetParams = d.struct({
+    dx: d.f32,
+    dy: d.f32,
+    wrap: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: OffsetParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    // We pick the address mode in the shader so a single sampler binding
+    // covers all three wrap behaviors; the sampler stays clamp-to-edge.
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformOffsetV1 = defineModule({
+    id: "transform.offset",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: OffsetParams,
+    paramDefaults: { dx: 0, dy: 0, wrap: 0 },
+    paramUi: {
+        dx: { min: -1, max: 1, step: 0.01, label: "Offset X" },
+        dy: { min: -1, max: 1, step: 0.01, label: "Offset Y" },
+        wrap: { min: 0, max: 2, step: 1, label: "Wrap", notes: "0 clamp / 1 repeat / 2 mirror" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn applyWrap(u: vec2f, mode: i32) -> vec2f {
+  if (mode == 1) {
+    return fract(u);
+  }
+  if (mode == 2) {
+    let q = fract(u * 0.5) * 2.0;
+    return vec2f(
+      select(q.x, 2.0 - q.x, q.x > 1.0),
+      select(q.y, 2.0 - q.y, q.y > 1.0)
+    );
+  }
+  return clamp(u, vec2f(0.0), vec2f(1.0));
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let mode = i32(round(p.wrap));
+  let shifted = uv - vec2f(p.dx, p.dy);
+  let u = applyWrap(shifted, mode);
+  return textureSample(layout.$.source, layout.$.samp, u);
+}
+`,
+    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/transform/offset/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/offset/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,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,EAAE,EAAE,CAAC,CAAC,GAAG;IACT,EAAE,EAAE,CAAC,CAAC,GAAG;IACT,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;IACjC,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,qEAAqE;IACrE,oEAAoE;IACpE,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,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,YAAY;IACpB,aAAa,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;IACxC,OAAO,EAAE;QACP,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;QACtD,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;QACtD,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,+BAA+B,EAAE;KACzF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBlB;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/transform/pad/v1/module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `transform.pad@1` — pad the source with empty space on each side.
+ *
+ * `left`/`top`/`right`/`bottom` are in normalized UV units relative to the
+ * source: `left = 0.25` adds a quarter-source-width of empty space on the
+ * left. Output dimensions are `derived` — the host allocates a target sized
+ * `(source.w * (1 + left + right), source.h * (1 + top + bottom))`. The
+ * padded region samples as `color` (premultiplied); the source occupies the
+ * interior rectangle.
+ */
+import * as d from "typegpu/data";
+export declare const PadParams: d.WgslStruct<{
+    left: d.F32;
+    top: d.F32;
+    right: d.F32;
+    bottom: d.F32;
+    color: d.Vec4f;
+}>;
+export declare const transformPadV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    left: d.F32;
+    top: d.F32;
+    right: d.F32;
+    bottom: d.F32;
+    color: d.Vec4f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/pad/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,SAAS;;;;;;EAMpB,CAAC;AAeH,eAAO,MAAM,cAAc;;;;;;GA8DzB,CAAC"}

package/dist/shaders/transform/pad/v1/module.js

@@ -0,0 +1,95 @@
+/**
+ * `transform.pad@1` — pad the source with empty space on each side.
+ *
+ * `left`/`top`/`right`/`bottom` are in normalized UV units relative to the
+ * source: `left = 0.25` adds a quarter-source-width of empty space on the
+ * left. Output dimensions are `derived` — the host allocates a target sized
+ * `(source.w * (1 + left + right), source.h * (1 + top + bottom))`. The
+ * padded region samples as `color` (premultiplied); the source occupies the
+ * interior rectangle.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const PadParams = d.struct({
+    left: d.f32,
+    top: d.f32,
+    right: d.f32,
+    bottom: d.f32,
+    color: d.vec4f
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: PadParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformPadV1 = defineModule({
+    id: "transform.pad",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: PadParams,
+    paramDefaults: {
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        color: d.vec4f(0, 0, 0, 0)
+    },
+    paramUi: {
+        left: { min: 0, max: 4, step: 0.01, label: "Left", notes: "× source width" },
+        top: { min: 0, max: 4, step: 0.01, label: "Top", notes: "× source height" },
+        right: { min: 0, max: 4, step: 0.01, label: "Right", notes: "× source width" },
+        bottom: { min: 0, max: 4, step: 0.01, label: "Bottom", notes: "× source height" },
+        color: { label: "Fill color", notes: "RGBA, premultiplied" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let totalW = 1.0 + p.left + p.right;
+  let totalH = 1.0 + p.top + p.bottom;
+  let uMin = p.left / totalW;
+  let uMax = (p.left + 1.0) / totalW;
+  let vMin = p.top / totalH;
+  let vMax = (p.top + 1.0) / totalH;
+  let inPad = uv.x < uMin || uv.x > uMax || uv.y < vMin || uv.y > vMax;
+  let sampleUv = vec2f(
+    (uv.x - uMin) / (uMax - uMin),
+    (uv.y - vMin) / (vMax - vMin)
+  );
+  // Sample unconditionally (textureSample must run in uniform control flow);
+  // select the fill colour for the padded border. uMax-uMin = 1/totalW > 0 so
+  // the normalization never divides by zero.
+  let col = textureSample(layout.$.source, layout.$.samp, sampleUv);
+  return select(col, p.color, inPad);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "derived"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/transform/pad/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/pad/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,MAAM,EAAE,CAAC,CAAC,GAAG;IACb,KAAK,EAAE,CAAC,CAAC,KAAK;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE;IAC9B,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,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,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,SAAS;IACjB,aAAa,EAAE;QACb,IAAI,EAAE,CAAC;QACP,GAAG,EAAE,CAAC;QACN,KAAK,EAAE,CAAC;QACR,MAAM,EAAE,CAAC;QACT,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KAC3B;IACD,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE;QAC5E,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE;QAC3E,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE;QAC9E,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,iBAAiB,EAAE;QACjF,KAAK,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,qBAAqB,EAAE;KAC7D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBlB;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,SAAS;SACtB;QACD,GAAG,EAAE,UAAU;KAChB;CACF,CAAC,CAAC"}

package/dist/shaders/transform/polarRemap/v1/module.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `transform.polarRemap@1` — convert between rectangular and polar UV space.
+ *
+ * `mode = 0` rect→polar: the output `x` axis is angle (`[0, 2π)`) and the
+ * output `y` axis is radius (`[0, 1]`). `mode = 1` polar→rect: treat the
+ * source as `(angle, radius)` and unwrap it into a centered disc.
+ *
+ * Used for "polar coordinates" filters, kaleidoscopes, and as the building
+ * block for fisheye fronts. Output dimensions stay `same-as:source` —
+ * sampling is symmetrical between the two modes, so the host doesn't have to
+ * resize.
+ */
+import * as d from "typegpu/data";
+export declare const PolarRemapParams: d.WgslStruct<{
+    mode: d.F32;
+}>;
+export declare const transformPolarRemapV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mode: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/polarRemap/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,gBAAgB;;EAE3B,CAAC;AAeH,eAAO,MAAM,qBAAqB;;GAgEhC,CAAC"}

package/dist/shaders/transform/polarRemap/v1/module.js

@@ -0,0 +1,95 @@
+/**
+ * `transform.polarRemap@1` — convert between rectangular and polar UV space.
+ *
+ * `mode = 0` rect→polar: the output `x` axis is angle (`[0, 2π)`) and the
+ * output `y` axis is radius (`[0, 1]`). `mode = 1` polar→rect: treat the
+ * source as `(angle, radius)` and unwrap it into a centered disc.
+ *
+ * Used for "polar coordinates" filters, kaleidoscopes, and as the building
+ * block for fisheye fronts. Output dimensions stay `same-as:source` —
+ * sampling is symmetrical between the two modes, so the host doesn't have to
+ * resize.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const PolarRemapParams = d.struct({
+    mode: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: PolarRemapParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformPolarRemapV1 = defineModule({
+    id: "transform.polarRemap",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: PolarRemapParams,
+    paramDefaults: { mode: 0 },
+    paramUi: {
+        mode: {
+            min: 0,
+            max: 1,
+            step: 1,
+            label: "Mode",
+            notes: "0 rect→polar / 1 polar→rect"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let mode = i32(round(layout.$.params.mode));
+  let pi = 3.14159265358979;
+  if (mode == 0) {
+    // rect → polar: output (x, y) lives in (angle, radius) space.
+    // Sample the source at the cartesian position that maps to (angle, r).
+    let angle = uv.x * (2.0 * pi);
+    let r = uv.y;
+    let s = vec2f(0.5 + r * 0.5 * cos(angle), 0.5 + r * 0.5 * sin(angle));
+    return textureSample(layout.$.source, layout.$.samp, s);
+  }
+  // polar → rect: treat the source's u-axis as angle and v-axis as radius.
+  // Output is a centered disc; convert this output's cartesian (uv) to (r,θ)
+  // and sample the source there.
+  let centered = uv - vec2f(0.5);
+  let r = length(centered) * 2.0;
+  var angle = atan2(centered.y, centered.x);
+  if (angle < 0.0) {
+    angle = angle + 2.0 * pi;
+  }
+  // Sample unconditionally (textureSample must run in uniform control flow);
+  // select transparent black outside the inscribed disc.
+  let col = textureSample(layout.$.source, layout.$.samp, vec2f(angle / (2.0 * pi), r));
+  return select(col, vec4f(0.0), r > 1.0);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/transform/polarRemap/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/polarRemap/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,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,gBAAgB,EAAE;IACrC,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,qBAAqB,GAAG,YAAY,CAAC;IAChD,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,gBAAgB;IACxB,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;IAC1B,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,MAAM;YACb,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB;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/transform/resize/v1/module.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `transform.resize@1` — resample the source onto a host-specified target.
+ *
+ * `mode` picks the algorithm: `0` nearest-neighbour (point sample, pixel-art
+ * safe), `1` bilinear (default), `2` bicubic (Catmull–Rom). Output dimensions
+ * are `host-specified` — the host allocates whatever target size it wants;
+ * the shader maps each output pixel back to source UV space and samples.
+ *
+ * Bilinear uses the bound `filtering` sampler. Nearest snaps UVs to source
+ * texel centers with the same sampler (one binding rather than two). Bicubic
+ * implements a 4×4 Catmull–Rom kernel in WGSL.
+ */
+import * as d from "typegpu/data";
+export declare const ResizeParams: d.WgslStruct<{
+    mode: d.F32;
+}>;
+export declare const transformResizeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mode: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

package/dist/shaders/transform/resize/v1/module.js

@@ -0,0 +1,116 @@
+/**
+ * `transform.resize@1` — resample the source onto a host-specified target.
+ *
+ * `mode` picks the algorithm: `0` nearest-neighbour (point sample, pixel-art
+ * safe), `1` bilinear (default), `2` bicubic (Catmull–Rom). Output dimensions
+ * are `host-specified` — the host allocates whatever target size it wants;
+ * the shader maps each output pixel back to source UV space and samples.
+ *
+ * Bilinear uses the bound `filtering` sampler. Nearest snaps UVs to source
+ * texel centers with the same sampler (one binding rather than two). Bicubic
+ * implements a 4×4 Catmull–Rom kernel in WGSL.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ResizeParams = d.struct({
+    mode: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ResizeParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformResizeV1 = defineModule({
+    id: "transform.resize",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: ResizeParams,
+    paramDefaults: { mode: 1 },
+    paramUi: {
+        mode: {
+            min: 0,
+            max: 2,
+            step: 1,
+            label: "Mode",
+            notes: "0 nearest / 1 bilinear / 2 bicubic"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn cubicWeight(x: f32) -> f32 {
+  // Catmull–Rom (a = -0.5). Symmetric in x.
+  let ax = abs(x);
+  if (ax < 1.0) {
+    return ((1.5 * ax - 2.5) * ax * ax) + 1.0;
+  }
+  if (ax < 2.0) {
+    return (((-0.5 * ax + 2.5) * ax - 4.0) * ax) + 2.0;
+  }
+  return 0.0;
+}
+
+fn sampleBicubic(uv: vec2f, dims: vec2f) -> vec4f {
+  // Map UV → texel-center coords, take floor as the kernel anchor, sweep the
+  // surrounding 4×4 neighborhood and accumulate weighted samples.
+  let center = uv * dims - vec2f(0.5);
+  let baseI = floor(center);
+  let frac = center - baseI;
+  var color = vec4f(0.0);
+  var weight: f32 = 0.0;
+  for (var j = -1; j <= 2; j = j + 1) {
+    let wy = cubicWeight(f32(j) - frac.y);
+    for (var i = -1; i <= 2; i = i + 1) {
+      let wx = cubicWeight(f32(i) - frac.x);
+      let w = wx * wy;
+      let texel = baseI + vec2f(f32(i), f32(j)) + vec2f(0.5);
+      let u = clamp(texel / dims, vec2f(0.0), vec2f(1.0));
+      color = color + textureSample(layout.$.source, layout.$.samp, u) * w;
+      weight = weight + w;
+    }
+  }
+  return color / weight;
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let mode = i32(round(layout.$.params.mode));
+  let dims = vec2f(textureDimensions(layout.$.source));
+  if (mode == 0) {
+    let snapped = (floor(uv * dims) + vec2f(0.5)) / dims;
+    return textureSample(layout.$.source, layout.$.samp, snapped);
+  }
+  if (mode == 2) {
+    return sampleBicubic(uv, dims);
+  }
+  return textureSample(layout.$.source, layout.$.samp, uv);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "host-specified"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/transform/resize/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/resize/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,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;IACjC,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,iBAAiB,GAAG,YAAY,CAAC;IAC5C,EAAE,EAAE,kBAAkB;IACtB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,YAAY;IACpB,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;IAC1B,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,MAAM;YACb,KAAK,EAAE,oCAAoC;SAC5C;KACF;IACD,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;SACF;QACD,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/rotate90/v1/module.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `transform.rotate90@1` — rotate by 90°, 180°, or 270° in nearest-friendly
+ * steps.
+ *
+ * `turns` packs the quarter-turn count: `0` identity, `1` 90° CW, `2` 180°,
+ * `3` 270° CW (= 90° CCW). Output dimensions are `derived`: the host swaps
+ * width/height for odd quarter-turns (90/270) and keeps them for even ones
+ * (0/180). The shader maps each output UV back to the corresponding source
+ * UV using only normalized-UV arithmetic — quarter-turn rotation around the
+ * canvas center is `(u, v) → (1-v, u)` for 90° CW, so the sampler never
+ * needs `textureDimensions`.
+ *
+ * For arbitrary rotations (and translation/scale combined), use
+ * `transform.affine@1`. This module exists specifically because quarter-turns
+ * have no resampling loss and are extremely common (sensor orientation,
+ * EXIF auto-rotate, pixel-art layouts).
+ */
+import * as d from "typegpu/data";
+export declare const Rotate90Params: d.WgslStruct<{
+    turns: d.F32;
+}>;
+export declare const transformRotate90V1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    turns: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/rotate90/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,cAAc;;EAEzB,CAAC;AAeH,eAAO,MAAM,mBAAmB;;GAsD9B,CAAC"}

package/dist/shaders/transform/rotate90/v1/module.js

@@ -0,0 +1,90 @@
+/**
+ * `transform.rotate90@1` — rotate by 90°, 180°, or 270° in nearest-friendly
+ * steps.
+ *
+ * `turns` packs the quarter-turn count: `0` identity, `1` 90° CW, `2` 180°,
+ * `3` 270° CW (= 90° CCW). Output dimensions are `derived`: the host swaps
+ * width/height for odd quarter-turns (90/270) and keeps them for even ones
+ * (0/180). The shader maps each output UV back to the corresponding source
+ * UV using only normalized-UV arithmetic — quarter-turn rotation around the
+ * canvas center is `(u, v) → (1-v, u)` for 90° CW, so the sampler never
+ * needs `textureDimensions`.
+ *
+ * For arbitrary rotations (and translation/scale combined), use
+ * `transform.affine@1`. This module exists specifically because quarter-turns
+ * have no resampling loss and are extremely common (sensor orientation,
+ * EXIF auto-rotate, pixel-art layouts).
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const Rotate90Params = d.struct({
+    turns: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: Rotate90Params },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "nearest",
+    minFilter: "nearest",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformRotate90V1 = defineModule({
+    id: "transform.rotate90",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: Rotate90Params,
+    paramDefaults: { turns: 1 },
+    paramUi: {
+        turns: {
+            min: 0,
+            max: 3,
+            step: 1,
+            label: "Turns (CW)",
+            notes: "0 / 1=90° / 2=180° / 3=270°"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let t = i32(round(layout.$.params.turns)) & 3;
+  // Map output UV (in the rotated canvas) back to source UV by applying the
+  // inverse rotation. Quarter-turn rotation around the canvas center is
+  // (u, v) → (1-v, u) for 90° CW; the inverse for sampling is (u, v) → (v, 1-u).
+  var s = uv;
+  if (t == 1) {
+    s = vec2f(uv.y, 1.0 - uv.x);
+  } else if (t == 2) {
+    s = vec2f(1.0 - uv.x, 1.0 - uv.y);
+  } else if (t == 3) {
+    s = vec2f(1.0 - uv.y, uv.x);
+  }
+  return textureSample(layout.$.source, layout.$.samp, s);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "derived"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/transform/rotate90/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/rotate90/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;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,KAAK,EAAE,CAAC,CAAC,GAAG;CACb,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,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,mBAAmB,GAAG,YAAY,CAAC;IAC9C,EAAE,EAAE,oBAAoB;IACxB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;IAC3B,OAAO,EAAE;QACP,KAAK,EAAE;YACL,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,YAAY;YACnB,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiBlB;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,SAAS;SACtB;QACD,GAAG,EAAE,UAAU;KAChB;CACF,CAAC,CAAC"}

package/dist/shaders/transform/spherize/v1/module.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `transform.spherize@1` — spherical/fisheye lens distortion centered on the
+ * source.
+ *
+ * `amount > 0` bulges the centre outward (fisheye, magnifying-glass);
+ * `amount < 0` pinches it inward. The implementation is the classic
+ * Photoshop-style normalized-radius warp: convert UV to centered polar,
+ * remap the radius by `r' = r * (1 + amount * (1 - r²))`, convert back.
+ *
+ * Output dimensions stay `same-as:source`. Pixels outside the unit circle
+ * pass through unchanged so the corners of a rectangular source aren't
+ * snipped; pixels inside the circle get the spherical remap.
+ */
+import * as d from "typegpu/data";
+export declare const SpherizeParams: d.WgslStruct<{
+    amount: d.F32;
+}>;
+export declare const transformSpherizeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    amount: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/spherize/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,cAAc;;EAEzB,CAAC;AAeH,eAAO,MAAM,mBAAmB;;GA8D9B,CAAC"}