@nodetool-ai/gpu 0.8.1

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

@@ -0,0 +1,94 @@
+/**
+ * `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 tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const AffineParams = d.struct({
+    m00: d.f32,
+    m01: d.f32,
+    tx: d.f32,
+    m10: d.f32,
+    m11: d.f32,
+    ty: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: AffineParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformAffineV1 = defineModule({
+    id: "transform.affine",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: AffineParams,
+    // Identity inverse affine = passthrough.
+    paramDefaults: { m00: 1, m01: 0, tx: 0, m10: 0, m11: 1, ty: 0 },
+    paramUi: {
+        m00: { label: "m00", notes: "inverse matrix row 0" },
+        m01: { label: "m01", notes: "inverse matrix row 0" },
+        tx: { label: "tx", notes: "inverse translation X" },
+        m10: { label: "m10", notes: "inverse matrix row 1" },
+        m11: { label: "m11", notes: "inverse matrix row 1" },
+        ty: { label: "ty", notes: "inverse translation Y" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let s = vec2f(
+    p.m00 * uv.x + p.m01 * uv.y + p.tx,
+    p.m10 * uv.x + p.m11 * uv.y + p.ty
+  );
+  // Sample unconditionally (WGSL requires textureSample in uniform control
+  // flow) and select transparent black for out-of-bounds taps. The clamp-to-
+  // edge sampler makes the discarded out-of-bounds read harmless.
+  let oob = s.x < 0.0 || s.x > 1.0 || s.y < 0.0 || s.y > 1.0;
+  let col = textureSample(layout.$.source, layout.$.samp, s);
+  return select(col, vec4f(0.0), oob);
+}
+`,
+    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/affine/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/affine/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;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,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,EAAE,EAAE,CAAC,CAAC,GAAG;IACT,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,EAAE,EAAE,CAAC,CAAC,GAAG;CACV,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,yCAAyC;IACzC,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE;IAC/D,OAAO,EAAE;QACP,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACpD,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACpD,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,uBAAuB,EAAE;QACnD,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACpD,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE;QACpD,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,uBAAuB,EAAE;KACpD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;CAelB;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/cornerPin/v1/module.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `transform.cornerPin@1` — perspective warp via an inverse 3×3 homography.
+ *
+ * Each output UV `(x, y)` is mapped to source UV by
+ * `(u, v, w) = H · (x, y, 1)` and then `(u/w, v/w)`. The eight free
+ * coefficients of `H` (with `h22 = 1`) are exposed as params; the host
+ * computes them from a four-corner correspondence using the standard
+ * homography formula and passes the matrix down. Authoring the **inverse**
+ * keeps the WGSL a single multiply + divide rather than a per-pixel
+ * inverse-bilinear solve.
+ *
+ * Out-of-bounds samples return transparent black so the warped source leaves
+ * the surrounding area transparent rather than smearing the edge color.
+ * Output dimensions are `same-as:source` — pinning happens inside the
+ * source's canvas. For perspective warps onto a different canvas size, run
+ * `transform.resize` upstream or `transform.affine` for non-perspective
+ * cases.
+ */
+import * as d from "typegpu/data";
+export declare const CornerPinParams: d.WgslStruct<{
+    h00: d.F32;
+    h01: d.F32;
+    h02: d.F32;
+    h10: d.F32;
+    h11: d.F32;
+    h12: d.F32;
+    h20: d.F32;
+    h21: d.F32;
+}>;
+export declare const transformCornerPinV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    h00: d.F32;
+    h01: d.F32;
+    h02: d.F32;
+    h10: d.F32;
+    h11: d.F32;
+    h12: d.F32;
+    h20: d.F32;
+    h21: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/transform/cornerPin/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,eAAe;;;;;;;;;EAS1B,CAAC;AAeH,eAAO,MAAM,oBAAoB;;;;;;;;;GAiE/B,CAAC"}

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

@@ -0,0 +1,109 @@
+/**
+ * `transform.cornerPin@1` — perspective warp via an inverse 3×3 homography.
+ *
+ * Each output UV `(x, y)` is mapped to source UV by
+ * `(u, v, w) = H · (x, y, 1)` and then `(u/w, v/w)`. The eight free
+ * coefficients of `H` (with `h22 = 1`) are exposed as params; the host
+ * computes them from a four-corner correspondence using the standard
+ * homography formula and passes the matrix down. Authoring the **inverse**
+ * keeps the WGSL a single multiply + divide rather than a per-pixel
+ * inverse-bilinear solve.
+ *
+ * Out-of-bounds samples return transparent black so the warped source leaves
+ * the surrounding area transparent rather than smearing the edge color.
+ * Output dimensions are `same-as:source` — pinning happens inside the
+ * source's canvas. For perspective warps onto a different canvas size, run
+ * `transform.resize` upstream or `transform.affine` for non-perspective
+ * cases.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const CornerPinParams = d.struct({
+    h00: d.f32,
+    h01: d.f32,
+    h02: d.f32,
+    h10: d.f32,
+    h11: d.f32,
+    h12: d.f32,
+    h20: d.f32,
+    h21: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CornerPinParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformCornerPinV1 = defineModule({
+    id: "transform.cornerPin",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: CornerPinParams,
+    // Identity homography: H = I (h22 = 1 implicit).
+    paramDefaults: {
+        h00: 1,
+        h01: 0,
+        h02: 0,
+        h10: 0,
+        h11: 1,
+        h12: 0,
+        h20: 0,
+        h21: 0
+    },
+    paramUi: {
+        h00: { label: "H00" },
+        h01: { label: "H01" },
+        h02: { label: "H02" },
+        h10: { label: "H10" },
+        h11: { label: "H11" },
+        h12: { label: "H12" },
+        h20: { label: "H20" },
+        h21: { label: "H21" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let w = p.h20 * uv.x + p.h21 * uv.y + 1.0;
+  let degenerate = abs(w) < 1e-6;
+  // Guard the perspective divide so u/v stay finite even at the singularity;
+  // those pixels are discarded by the select below anyway.
+  let wSafe = select(w, 1.0, degenerate);
+  let u = (p.h00 * uv.x + p.h01 * uv.y + p.h02) / wSafe;
+  let v = (p.h10 * uv.x + p.h11 * uv.y + p.h12) / wSafe;
+  // Sample unconditionally (textureSample must run in uniform control flow);
+  // select transparent black at the singularity or outside the source.
+  let oob = degenerate || u < 0.0 || u > 1.0 || v < 0.0 || v > 1.0;
+  let col = textureSample(layout.$.source, layout.$.samp, vec2f(u, v));
+  return select(col, vec4f(0.0), oob);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "explicit"
+    }
+});
+//# sourceMappingURL=module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/cornerPin/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;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,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;IACV,GAAG,EAAE,CAAC,CAAC,GAAG;CACX,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,oBAAoB,GAAG,YAAY,CAAC;IAC/C,EAAE,EAAE,qBAAqB;IACzB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,eAAe;IACvB,iDAAiD;IACjD,aAAa,EAAE;QACb,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;KACP;IACD,OAAO,EAAE;QACP,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QACrB,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;KACtB;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,gBAAgB;SAC7B;QACD,GAAG,EAAE,UAAU;KAChB;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * `transform.crop@1` — sample a sub-rectangle of the source defined in
+ * normalized UV space.
+ *
+ * `(originX, originY, width, height)` are all in `[0, 1]` with top-left
+ * origin. Output dimensions are `derived` from the requested crop —
+ * the host allocates a target sized `(source.width * width, source.height * height)`
+ * (integer-rounded) and the module samples the corresponding region.
+ *
+ * Out-of-source samples (when the crop extends beyond `[0, 1]`) return
+ * transparent black so a crop is a *crop*, not a stretch.
+ */
+import * as d from "typegpu/data";
+export declare const CropParams: d.WgslStruct<{
+    originX: d.F32;
+    originY: d.F32;
+    width: d.F32;
+    height: d.F32;
+}>;
+export declare const transformCropV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    originX: d.F32;
+    originY: d.F32;
+    width: d.F32;
+    height: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,82 @@
+/**
+ * `transform.crop@1` — sample a sub-rectangle of the source defined in
+ * normalized UV space.
+ *
+ * `(originX, originY, width, height)` are all in `[0, 1]` with top-left
+ * origin. Output dimensions are `derived` from the requested crop —
+ * the host allocates a target sized `(source.width * width, source.height * height)`
+ * (integer-rounded) and the module samples the corresponding region.
+ *
+ * Out-of-source samples (when the crop extends beyond `[0, 1]`) return
+ * transparent black so a crop is a *crop*, not a stretch.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const CropParams = d.struct({
+    originX: d.f32,
+    originY: d.f32,
+    width: d.f32,
+    height: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CropParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformCropV1 = defineModule({
+    id: "transform.crop",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: CropParams,
+    paramDefaults: { originX: 0, originY: 0, width: 1, height: 1 },
+    paramUi: {
+        originX: { min: 0, max: 1, step: 0.01, label: "Origin X" },
+        originY: { min: 0, max: 1, step: 0.01, label: "Origin Y" },
+        width: { min: 0.01, max: 1, step: 0.01, label: "Width" },
+        height: { min: 0.01, max: 1, step: 0.01, label: "Height" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let sampleUv = vec2f(
+    p.originX + uv.x * p.width,
+    p.originY + uv.y * p.height
+  );
+  // Sample unconditionally (textureSample must run in uniform control flow);
+  // select transparent black for taps outside the crop region.
+  let oob = sampleUv.x < 0.0 || sampleUv.x > 1.0 || sampleUv.y < 0.0 || sampleUv.y > 1.0;
+  let col = textureSample(layout.$.source, layout.$.samp, sampleUv);
+  return select(col, vec4f(0.0), oob);
+}
+`,
+    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/crop/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/crop/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,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,MAAM,EAAE,CAAC,CAAC,GAAG;CACd,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,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,eAAe,GAAG,YAAY,CAAC;IAC1C,EAAE,EAAE,gBAAgB;IACpB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,eAAe;IAC1B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,UAAU;IAClB,aAAa,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;IAC9D,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;QAC1D,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;QAC1D,KAAK,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;QACxD,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;KAC3D;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;CAclB;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/displace/v1/module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `transform.displace@1` — per-pixel UV offset driven by a displacement map.
+ *
+ * Each output pixel reads `(dx, dy)` from the displacement texture's R+G
+ * channels (centered: `0.5` is no offset, `0` and `1` are the extremes), scales
+ * by `(amountX, amountY)`, and samples the source at `uv + offset`. Used for
+ * heat-haze, water ripples, glass, and as the "warp by noise" building block
+ * when paired with `sources.noise` (Phase 3 Batch 1+).
+ *
+ * Output dimensions stay `same-as:source`. Out-of-range samples (after the
+ * offset pushes UV outside `[0, 1]`) return transparent black so a strong
+ * displacement leaves clean transparency instead of smearing edge color.
+ */
+import * as d from "typegpu/data";
+export declare const DisplaceParams: d.WgslStruct<{
+    amountX: d.F32;
+    amountY: d.F32;
+}>;
+export declare const transformDisplaceV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    amountX: d.F32;
+    amountY: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,95 @@
+/**
+ * `transform.displace@1` — per-pixel UV offset driven by a displacement map.
+ *
+ * Each output pixel reads `(dx, dy)` from the displacement texture's R+G
+ * channels (centered: `0.5` is no offset, `0` and `1` are the extremes), scales
+ * by `(amountX, amountY)`, and samples the source at `uv + offset`. Used for
+ * heat-haze, water ripples, glass, and as the "warp by noise" building block
+ * when paired with `sources.noise` (Phase 3 Batch 1+).
+ *
+ * Output dimensions stay `same-as:source`. Out-of-range samples (after the
+ * offset pushes UV outside `[0, 1]`) return transparent black so a strong
+ * displacement leaves clean transparency instead of smearing edge color.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const DisplaceParams = d.struct({
+    amountX: d.f32,
+    amountY: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: DisplaceParams },
+    source: { texture: "float" },
+    displacement: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformDisplaceV1 = defineModule({
+    id: "transform.displace",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: DisplaceParams,
+    paramDefaults: { amountX: 0.05, amountY: 0.05 },
+    paramUi: {
+        amountX: { min: -1, max: 1, step: 0.005, label: "Amount X", notes: "× UV" },
+        amountY: { min: -1, max: 1, step: 0.005, label: "Amount Y", notes: "× UV" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  // The displacement map is premultiplied like everything in the pool, but its
+  // R/G are a straight signed control signal (0.5 = no offset). Un-premultiply
+  // to recover the true control values — otherwise a translucent displacement
+  // texel biases the offset. Fully transparent texels carry no signal at all
+  // (rgb = 0, so the divide would recover 0 → full negative offset);
+  // substitute the neutral 0.5 so uncovered map regions leave pixels in place.
+  let dispP = textureSample(layout.$.displacement, layout.$.samp, uv);
+  let disp = select(
+    vec3f(0.5),
+    dispP.rgb / max(dispP.a, 1.0 / 255.0),
+    dispP.a > 0.0
+  );
+  let offset = vec2f((disp.r - 0.5) * 2.0 * p.amountX, (disp.g - 0.5) * 2.0 * p.amountY);
+  let s = uv + offset;
+  // Sample unconditionally (textureSample must run in uniform control flow);
+  // select transparent black where the offset pushes UV outside the source.
+  let oob = s.x < 0.0 || s.x > 1.0 || s.y < 0.0 || s.y > 1.0;
+  let col = textureSample(layout.$.source, layout.$.samp, s);
+  return select(col, vec4f(0.0), oob);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            displacement: {
+                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/displace/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/displace/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,OAAO,EAAE,CAAC,CAAC,GAAG;CACf,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,YAAY,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAClC,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,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,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;IAC/C,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE;QAC3E,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE;KAC5E;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB;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,YAAY,EAAE;gBACZ,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/mirror/v1/module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `transform.mirror@1` — flip horizontally, vertically, or both.
+ *
+ * `axes` packs the two flags into a single param: `1` → horizontal, `2` →
+ * vertical, `3` → both. Output dimensions are `same-as:source`.
+ */
+import * as d from "typegpu/data";
+export declare const MirrorParams: d.WgslStruct<{
+    axes: d.F32;
+}>;
+export declare const transformMirrorV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    axes: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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

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

@@ -0,0 +1,73 @@
+/**
+ * `transform.mirror@1` — flip horizontally, vertically, or both.
+ *
+ * `axes` packs the two flags into a single param: `1` → horizontal, `2` →
+ * vertical, `3` → both. Output dimensions are `same-as:source`.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const MirrorParams = d.struct({
+    axes: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: MirrorParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const transformMirrorV1 = defineModule({
+    id: "transform.mirror",
+    version: 1,
+    surface: "internal",
+    category: "transform",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: MirrorParams,
+    paramDefaults: { axes: 1 },
+    paramUi: {
+        axes: {
+            min: 0,
+            max: 3,
+            step: 1,
+            label: "Axes",
+            notes: "0 none / 1 H / 2 V / 3 both"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let axes = i32(round(layout.$.params.axes));
+  let flipH = (axes & 1) != 0;
+  let flipV = (axes & 2) != 0;
+  var u = uv;
+  if (flipH) { u.x = 1.0 - u.x; }
+  if (flipV) { u.y = 1.0 - u.y; }
+  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/mirror/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/transform/mirror/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,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,6BAA6B;SACrC;KACF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;CAWlB;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/offset/v1/module.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `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 * as d from "typegpu/data";
+export declare const OffsetParams: d.WgslStruct<{
+    dx: d.F32;
+    dy: d.F32;
+    wrap: d.F32;
+}>;
+export declare const transformOffsetV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    dx: d.F32;
+    dy: d.F32;
+    wrap: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

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

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