@nodetool-ai/gpu 0.8.1

package/dist/compositor/shaders.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared WebGPU compositing shaders.
+ *
+ * These power the single layer-compositing engine used by both the sketch
+ * editor and the timeline preview. The pipeline is:
+ *
+ *   background → (per layer: blend pass into ping-pong) → blit to target
+ *
+ * Each layer renders a full-screen quad; the fragment shader maps the
+ * screen UV back into the layer texture via a 2×3 inverse-affine matrix,
+ * samples the layer (nearest or linear), optionally applies a rounded-rect
+ * mask, and composites it over the current accumulation using the W3C
+ * compositing formula and the shared blend functions.
+ *
+ * The `nearest` + `radius == 0` path is identical to the sketch editor's
+ * historical blend-composite shader, so migrating sketch onto this engine
+ * does not change its output. `linear` sampling and the rounded-rect mask
+ * are opt-in via uniforms (used by the timeline for scaled video clips).
+ */
+export declare const FULLSCREEN_QUAD_VERTEX = "\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n  var pos = array<vec2f, 4>(\n    vec2f(-1.0, -1.0),\n    vec2f( 1.0, -1.0),\n    vec2f(-1.0,  1.0),\n    vec2f( 1.0,  1.0),\n  );\n  var uv = array<vec2f, 4>(\n    vec2f(0.0, 1.0),\n    vec2f(1.0, 1.0),\n    vec2f(0.0, 0.0),\n    vec2f(1.0, 0.0),\n  );\n  var out: VertexOutput;\n  out.position = vec4f(pos[vertexIndex], 0.0, 1.0);\n  out.uv = uv[vertexIndex];\n  return out;\n}\n";
+export declare const BLEND_COMPOSITE_FRAGMENT = "\nstruct BlendUniforms {\n  params0: vec4f,\n  invRow0: vec4f,\n  invRow1: vec4f,\n  invRow2: vec4f,\n  params1: vec4f,\n  params2: vec4f,\n};\n\n@group(0) @binding(0) var<uniform> u: BlendUniforms;\n@group(0) @binding(1) var srcTexture: texture_2d<f32>;\n@group(0) @binding(2) var dstTexture: texture_2d<f32>;\n@group(0) @binding(3) var srcSampler: sampler;\n\n\n// Blend mode ids (must match BLEND_MODE_INFOS[*].gpuId in blendModes.ts):\n// 0 = normal, 1 = multiply, 2 = screen, 3 = overlay, 4 = darken,\n// 5 = lighten, 6 = color-dodge, 7 = color-burn, 8 = hard-light,\n// 9 = soft-light, 10 = difference, 11 = exclusion, 12 = add\n\nfn softLightD(x: f32) -> f32 {\n  if (x <= 0.25) {\n    return ((16.0 * x - 12.0) * x + 4.0) * x;\n  }\n  return sqrt(x);\n}\n\nfn blendChannel(s: f32, d: f32, mode: u32) -> f32 {\n  switch (mode) {\n    case 0u: { return s; }\n    case 1u: { return s * d; }\n    case 2u: { return s + d - s * d; }\n    case 3u: {\n      return select(\n        1.0 - 2.0 * (1.0 - s) * (1.0 - d),\n        2.0 * s * d,\n        d <= 0.5\n      );\n    }\n    case 4u: { return min(s, d); }\n    case 5u: { return max(s, d); }\n    case 6u: {\n      return select(\n        min(1.0, d / max(1.0 - s, 0.001)),\n        1.0,\n        s >= 1.0\n      );\n    }\n    case 7u: {\n      return select(\n        max(0.0, 1.0 - (1.0 - d) / max(s, 0.001)),\n        0.0,\n        s <= 0.0\n      );\n    }\n    case 8u: {\n      return select(\n        1.0 - 2.0 * (1.0 - s) * (1.0 - d),\n        2.0 * s * d,\n        s <= 0.5\n      );\n    }\n    case 9u: {\n      return select(\n        d + (2.0 * s - 1.0) * (softLightD(d) - d),\n        d - (1.0 - 2.0 * s) * d * (1.0 - d),\n        s <= 0.5\n      );\n    }\n    case 10u: { return abs(s - d); }\n    case 11u: { return s + d - 2.0 * s * d; }\n    case 12u: { return min(1.0, s + d); }\n    default: { return s; }\n  }\n}\n\nfn applyBlendMode(src: vec3f, dst: vec3f, mode: u32) -> vec3f {\n  return vec3f(\n    blendChannel(src.x, dst.x, mode),\n    blendChannel(src.y, dst.y, mode),\n    blendChannel(src.z, dst.z, mode)\n  );\n}\n\n\nfn sdRoundedRect(p: vec2f, b: vec2f, r: f32) -> f32 {\n  let q = abs(p) - b + vec2f(r);\n  return min(max(q.x, q.y), 0.0) + length(max(q, vec2f(0.0))) - r;\n}\n\n@fragment\nfn fs_blend(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let opacity = u.params0.x;\n  let blendMode = u32(u.params0.y);\n  let canvasSize = u.params0.zw;\n  let radius = u.params1.x;\n  let smoothness = u.params1.y;\n  let filterMode = u32(u.params1.z);\n\n  // Destination = current accumulation, sampled at the screen UV (1:1).\n  let dstDims = textureDimensions(dstTexture);\n  let dstPx = vec2i(\n    i32(clamp(floor(uv.x * f32(dstDims.x)), 0.0, f32(dstDims.x) - 1.0)),\n    i32(clamp(floor(uv.y * f32(dstDims.y)), 0.0, f32(dstDims.y) - 1.0))\n  );\n  let dst = textureLoad(dstTexture, dstPx, 0);\n\n  // Map screen UV \u2192 layer texel through the inverse homography.\n  let px = uv * canvasSize;\n  let denominator = dot(u.invRow2.xyz, vec3f(px, 1.0));\n  if (abs(denominator) < 0.000001) { return dst; }\n  let texel = vec2f(\n    u.invRow0.x * px.x + u.invRow0.y * px.y + u.invRow0.z,\n    u.invRow1.x * px.x + u.invRow1.y * px.y + u.invRow1.z\n  ) / denominator;\n  let dims = textureDimensions(srcTexture);\n  let dimsF = vec2f(f32(dims.x), f32(dims.y));\n\n  if (texel.x < 0.0 || texel.x >= dimsF.x || texel.y < 0.0 || texel.y >= dimsF.y) {\n    return dst;\n  }\n\n  var srcRaw: vec4f;\n  if (filterMode == 1u) {\n    srcRaw = textureSampleLevel(srcTexture, srcSampler, texel / dimsF, 0.0);\n  } else {\n    let ix = i32(clamp(floor(texel.x), 0.0, max(dimsF.x - 1.0, 0.0)));\n    let iy = i32(clamp(floor(texel.y), 0.0, max(dimsF.y - 1.0, 0.0)));\n    srcRaw = textureLoad(srcTexture, vec2i(ix, iy), 0);\n  }\n\n  var sa = srcRaw.a * opacity;\n\n  // Optional rounded-rect mask in layer-local [-1, 1] space.\n  if (radius > 0.0) {\n    let local = (texel / dimsF) * 2.0 - vec2f(1.0);\n    let aspect = select(dimsF.x / dimsF.y, 1.0, dimsF.y == 0.0);\n    var p = local;\n    if (aspect > 1.0) {\n      p.y = p.y / aspect;\n    } else {\n      p.x = p.x * aspect;\n    }\n    let halfSize = vec2f(min(1.0, aspect), min(1.0, 1.0 / aspect));\n    let r = clamp(radius, 0.0, 0.5) * 2.0 * min(halfSize.x, halfSize.y);\n    let dist = sdRoundedRect(p, halfSize, r);\n    let mask = 1.0 - smoothstep(-smoothness, smoothness, dist);\n    sa = sa * mask;\n  }\n\n  // Optional directional wipe mask in the layer's normalized quad space\n  // (texel / dims), so the wipe edge rotates with the layer. c measures\n  // distance from the named edge; the reveal front sits at\n  // e = progress * (1 + softness), which clears the whole layer (including the\n  // feather band) exactly at progress 1 and hides it all at progress 0.\n  let wipeEdge = u32(u.params2.x);\n  if (wipeEdge != 0u) {\n    let progress = u.params2.y;\n    // A tiny floor keeps smoothstep well-defined; softness 0 stays visually a\n    // hard (sub-texel) edge.\n    let softness = max(u.params2.z, 1e-4);\n    let n = texel / dimsF;\n    var c = n.x; // 1u: reveal from the left edge\n    if (wipeEdge == 2u) {\n      c = 1.0 - n.x; // from the right edge\n    } else if (wipeEdge == 3u) {\n      c = n.y; // from the top edge (texel row 0)\n    } else if (wipeEdge == 4u) {\n      c = 1.0 - n.y; // from the bottom edge\n    }\n    let e = progress * (1.0 + softness);\n    sa = sa * (1.0 - smoothstep(e - softness, e, c));\n  }\n\n  // Radial iris reveal, in the layer's own normalized space.\n  let irisProgress = u.params2.w;\n  if (irisProgress >= 0.0) {\n    let p = (texel / dimsF - vec2f(0.5)) * 2.0;\n    let radial = length(p);\n    let feather = max(u.params1.w, 0.0001);\n    let edge = irisProgress * (1.41421356 + feather);\n    let iris = 1.0 - smoothstep(edge - feather, edge, radial);\n    sa = sa * select(iris, 0.0, irisProgress <= 0.0);\n  }\n\n  if (sa <= 0.0) {\n    return dst;\n  }\n\n  let da = dst.a;\n  let sc = srcRaw.rgb;\n  // Canvas lighter adds premultiplied channels and alpha. Applying a\n  // saturated straight-color sum inside source-over loses translucent light.\n  if (blendMode == 12u) {\n    return min(vec4f(sc * sa + dst.rgb, sa + da), vec4f(1.0));\n  }\n  // The accumulator stores premultiplied color (ad*Cd); the W3C formula needs\n  // straight Cd, so divide RGB by alpha before calling the blend functions.\n  // Non-normal modes (multiply, overlay, ...) silently produced wrong values\n  // before this un-premultiply was added.\n  let dc = select(vec3f(0.0), dst.rgb / max(da, 1.0 / 65535.0), da > 0.0);\n  let blended = applyBlendMode(sc, dc, blendMode);\n\n  // W3C compositing in premul-output form:\n  //   Co_premul = as*(1 - ad)*Cs + as*ad*B(Cs, Cd) + (1 - as)*ad*Cd\n  // The third term (1 - as)*ad*Cd_straight equals (1 - as)*dst.rgb because\n  // dst.rgb is already premultiplied (ad*Cd).\n  let co = sa * (1.0 - da) * sc + sa * da * blended + (1.0 - sa) * dst.rgb;\n  let ao = sa + da * (1.0 - sa);\n  return vec4f(co, ao);\n}\n";
+export declare const BLIT_FRAGMENT = "\n@group(0) @binding(0) var blitTexture: texture_2d<f32>;\n\n@fragment\nfn fs_blit(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let dims = textureDimensions(blitTexture);\n  let px = vec2i(\n    i32(clamp(floor(uv.x * f32(dims.x)), 0.0, f32(dims.x) - 1.0)),\n    i32(clamp(floor(uv.y * f32(dims.y)), 0.0, f32(dims.y) - 1.0))\n  );\n  return textureLoad(blitTexture, px, 0);\n}\n";
+export declare const UNPREMULTIPLY_FRAGMENT = "\n@group(0) @binding(0) var srcTexture: texture_2d<f32>;\n\n@fragment\nfn fs_unpremultiply(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let dims = textureDimensions(srcTexture);\n  let px = vec2i(\n    i32(clamp(floor(uv.x * f32(dims.x)), 0.0, f32(dims.x) - 1.0)),\n    i32(clamp(floor(uv.y * f32(dims.y)), 0.0, f32(dims.y) - 1.0))\n  );\n  let c = textureLoad(srcTexture, px, 0);\n  if (c.a <= 0.0) {\n    return vec4f(0.0, 0.0, 0.0, 0.0);\n  }\n  return vec4f(c.rgb / c.a, c.a);\n}\n";
+//# sourceMappingURL=shaders.d.ts.map

package/dist/compositor/shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.d.ts","sourceRoot":"","sources":["../../src/compositor/shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,eAAO,MAAM,sBAAsB,mjBAyBlC,CAAC;AAeF,eAAO,MAAM,wBAAwB,44NA+IpC,CAAC;AAIF,eAAO,MAAM,aAAa,qYAYzB,CAAC;AASF,eAAO,MAAM,sBAAsB,gfAgBlC,CAAC"}

package/dist/compositor/shaders.js

@@ -0,0 +1,241 @@
+/**
+ * Shared WebGPU compositing shaders.
+ *
+ * These power the single layer-compositing engine used by both the sketch
+ * editor and the timeline preview. The pipeline is:
+ *
+ *   background → (per layer: blend pass into ping-pong) → blit to target
+ *
+ * Each layer renders a full-screen quad; the fragment shader maps the
+ * screen UV back into the layer texture via a 2×3 inverse-affine matrix,
+ * samples the layer (nearest or linear), optionally applies a rounded-rect
+ * mask, and composites it over the current accumulation using the W3C
+ * compositing formula and the shared blend functions.
+ *
+ * The `nearest` + `radius == 0` path is identical to the sketch editor's
+ * historical blend-composite shader, so migrating sketch onto this engine
+ * does not change its output. `linear` sampling and the rounded-rect mask
+ * are opt-in via uniforms (used by the timeline for scaled video clips).
+ */
+import { WGSL_BLEND_FUNCTIONS } from "../blend/wgsl.js";
+// ─── Full-screen quad vertex shader (4-vertex triangle strip) ─────────────
+export const FULLSCREEN_QUAD_VERTEX = /* wgsl */ `
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  var pos = array<vec2f, 4>(
+    vec2f(-1.0, -1.0),
+    vec2f( 1.0, -1.0),
+    vec2f(-1.0,  1.0),
+    vec2f( 1.0,  1.0),
+  );
+  var uv = array<vec2f, 4>(
+    vec2f(0.0, 1.0),
+    vec2f(1.0, 1.0),
+    vec2f(0.0, 0.0),
+    vec2f(1.0, 0.0),
+  );
+  var out: VertexOutput;
+  out.position = vec4f(pos[vertexIndex], 0.0, 1.0);
+  out.uv = uv[vertexIndex];
+  return out;
+}
+`;
+// ─── Blend composite fragment shader ──────────────────────────────────────
+//
+// Uniform layout (4 × vec4f = 64 bytes):
+//   params0: opacity, blendMode (as f32), canvasW, canvasH
+//   invRow0: a, b, tx, _   (inverse affine row 0: screen px → layer texel)
+//   invRow1: c, d, ty, _   (inverse affine row 1)
+//   invRow2: p, q, r, _    (projective denominator)
+//   params1: borderRadius (normalized 0..0.5), smoothness, filterMode, _
+//     filterMode: 0 = nearest (textureLoad), 1 = linear (sampler)
+//   params2: wipeEdge, wipeProgress, wipeSoftness, _
+//     wipeEdge: 0 = no mask, 1 = left, 2 = right, 3 = top, 4 = bottom
+//     (edge the reveal starts from, in the layer's own quad space)
+export const BLEND_COMPOSITE_FRAGMENT = /* wgsl */ `
+struct BlendUniforms {
+  params0: vec4f,
+  invRow0: vec4f,
+  invRow1: vec4f,
+  invRow2: vec4f,
+  params1: vec4f,
+  params2: vec4f,
+};
+
+@group(0) @binding(0) var<uniform> u: BlendUniforms;
+@group(0) @binding(1) var srcTexture: texture_2d<f32>;
+@group(0) @binding(2) var dstTexture: texture_2d<f32>;
+@group(0) @binding(3) var srcSampler: sampler;
+
+${WGSL_BLEND_FUNCTIONS}
+
+fn sdRoundedRect(p: vec2f, b: vec2f, r: f32) -> f32 {
+  let q = abs(p) - b + vec2f(r);
+  return min(max(q.x, q.y), 0.0) + length(max(q, vec2f(0.0))) - r;
+}
+
+@fragment
+fn fs_blend(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let opacity = u.params0.x;
+  let blendMode = u32(u.params0.y);
+  let canvasSize = u.params0.zw;
+  let radius = u.params1.x;
+  let smoothness = u.params1.y;
+  let filterMode = u32(u.params1.z);
+
+  // Destination = current accumulation, sampled at the screen UV (1:1).
+  let dstDims = textureDimensions(dstTexture);
+  let dstPx = vec2i(
+    i32(clamp(floor(uv.x * f32(dstDims.x)), 0.0, f32(dstDims.x) - 1.0)),
+    i32(clamp(floor(uv.y * f32(dstDims.y)), 0.0, f32(dstDims.y) - 1.0))
+  );
+  let dst = textureLoad(dstTexture, dstPx, 0);
+
+  // Map screen UV → layer texel through the inverse homography.
+  let px = uv * canvasSize;
+  let denominator = dot(u.invRow2.xyz, vec3f(px, 1.0));
+  if (abs(denominator) < 0.000001) { return dst; }
+  let texel = vec2f(
+    u.invRow0.x * px.x + u.invRow0.y * px.y + u.invRow0.z,
+    u.invRow1.x * px.x + u.invRow1.y * px.y + u.invRow1.z
+  ) / denominator;
+  let dims = textureDimensions(srcTexture);
+  let dimsF = vec2f(f32(dims.x), f32(dims.y));
+
+  if (texel.x < 0.0 || texel.x >= dimsF.x || texel.y < 0.0 || texel.y >= dimsF.y) {
+    return dst;
+  }
+
+  var srcRaw: vec4f;
+  if (filterMode == 1u) {
+    srcRaw = textureSampleLevel(srcTexture, srcSampler, texel / dimsF, 0.0);
+  } else {
+    let ix = i32(clamp(floor(texel.x), 0.0, max(dimsF.x - 1.0, 0.0)));
+    let iy = i32(clamp(floor(texel.y), 0.0, max(dimsF.y - 1.0, 0.0)));
+    srcRaw = textureLoad(srcTexture, vec2i(ix, iy), 0);
+  }
+
+  var sa = srcRaw.a * opacity;
+
+  // Optional rounded-rect mask in layer-local [-1, 1] space.
+  if (radius > 0.0) {
+    let local = (texel / dimsF) * 2.0 - vec2f(1.0);
+    let aspect = select(dimsF.x / dimsF.y, 1.0, dimsF.y == 0.0);
+    var p = local;
+    if (aspect > 1.0) {
+      p.y = p.y / aspect;
+    } else {
+      p.x = p.x * aspect;
+    }
+    let halfSize = vec2f(min(1.0, aspect), min(1.0, 1.0 / aspect));
+    let r = clamp(radius, 0.0, 0.5) * 2.0 * min(halfSize.x, halfSize.y);
+    let dist = sdRoundedRect(p, halfSize, r);
+    let mask = 1.0 - smoothstep(-smoothness, smoothness, dist);
+    sa = sa * mask;
+  }
+
+  // Optional directional wipe mask in the layer's normalized quad space
+  // (texel / dims), so the wipe edge rotates with the layer. c measures
+  // distance from the named edge; the reveal front sits at
+  // e = progress * (1 + softness), which clears the whole layer (including the
+  // feather band) exactly at progress 1 and hides it all at progress 0.
+  let wipeEdge = u32(u.params2.x);
+  if (wipeEdge != 0u) {
+    let progress = u.params2.y;
+    // A tiny floor keeps smoothstep well-defined; softness 0 stays visually a
+    // hard (sub-texel) edge.
+    let softness = max(u.params2.z, 1e-4);
+    let n = texel / dimsF;
+    var c = n.x; // 1u: reveal from the left edge
+    if (wipeEdge == 2u) {
+      c = 1.0 - n.x; // from the right edge
+    } else if (wipeEdge == 3u) {
+      c = n.y; // from the top edge (texel row 0)
+    } else if (wipeEdge == 4u) {
+      c = 1.0 - n.y; // from the bottom edge
+    }
+    let e = progress * (1.0 + softness);
+    sa = sa * (1.0 - smoothstep(e - softness, e, c));
+  }
+
+  // Radial iris reveal, in the layer's own normalized space.
+  let irisProgress = u.params2.w;
+  if (irisProgress >= 0.0) {
+    let p = (texel / dimsF - vec2f(0.5)) * 2.0;
+    let radial = length(p);
+    let feather = max(u.params1.w, 0.0001);
+    let edge = irisProgress * (1.41421356 + feather);
+    let iris = 1.0 - smoothstep(edge - feather, edge, radial);
+    sa = sa * select(iris, 0.0, irisProgress <= 0.0);
+  }
+
+  if (sa <= 0.0) {
+    return dst;
+  }
+
+  let da = dst.a;
+  let sc = srcRaw.rgb;
+  // Canvas lighter adds premultiplied channels and alpha. Applying a
+  // saturated straight-color sum inside source-over loses translucent light.
+  if (blendMode == 12u) {
+    return min(vec4f(sc * sa + dst.rgb, sa + da), vec4f(1.0));
+  }
+  // The accumulator stores premultiplied color (ad*Cd); the W3C formula needs
+  // straight Cd, so divide RGB by alpha before calling the blend functions.
+  // Non-normal modes (multiply, overlay, ...) silently produced wrong values
+  // before this un-premultiply was added.
+  let dc = select(vec3f(0.0), dst.rgb / max(da, 1.0 / 65535.0), da > 0.0);
+  let blended = applyBlendMode(sc, dc, blendMode);
+
+  // W3C compositing in premul-output form:
+  //   Co_premul = as*(1 - ad)*Cs + as*ad*B(Cs, Cd) + (1 - as)*ad*Cd
+  // The third term (1 - as)*ad*Cd_straight equals (1 - as)*dst.rgb because
+  // dst.rgb is already premultiplied (ad*Cd).
+  let co = sa * (1.0 - da) * sc + sa * da * blended + (1.0 - sa) * dst.rgb;
+  let ao = sa + da * (1.0 - sa);
+  return vec4f(co, ao);
+}
+`;
+// ─── Blit fragment shader (composite → target/swap chain) ─────────────────
+export const BLIT_FRAGMENT = /* wgsl */ `
+@group(0) @binding(0) var blitTexture: texture_2d<f32>;
+
+@fragment
+fn fs_blit(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let dims = textureDimensions(blitTexture);
+  let px = vec2i(
+    i32(clamp(floor(uv.x * f32(dims.x)), 0.0, f32(dims.x) - 1.0)),
+    i32(clamp(floor(uv.y * f32(dims.y)), 0.0, f32(dims.y) - 1.0))
+  );
+  return textureLoad(blitTexture, px, 0);
+}
+`;
+// ─── Un-premultiply resolve fragment (premultiplied → straight alpha) ──────
+//
+// The blend pipeline accumulates premultiplied color. Headless readback wants
+// straight (non-premultiplied) RGBA for a faithful PNG encode, so this pass
+// divides RGB by alpha on the GPU — replacing a per-pixel CPU loop over the
+// whole readback. Pairs with `FULLSCREEN_QUAD_VERTEX` (`vs_main`).
+export const UNPREMULTIPLY_FRAGMENT = /* wgsl */ `
+@group(0) @binding(0) var srcTexture: texture_2d<f32>;
+
+@fragment
+fn fs_unpremultiply(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let dims = textureDimensions(srcTexture);
+  let px = vec2i(
+    i32(clamp(floor(uv.x * f32(dims.x)), 0.0, f32(dims.x) - 1.0)),
+    i32(clamp(floor(uv.y * f32(dims.y)), 0.0, f32(dims.y) - 1.0))
+  );
+  let c = textureLoad(srcTexture, px, 0);
+  if (c.a <= 0.0) {
+    return vec4f(0.0, 0.0, 0.0, 0.0);
+  }
+  return vec4f(c.rgb / c.a, c.a);
+}
+`;
+//# sourceMappingURL=shaders.js.map

package/dist/compositor/shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.js","sourceRoot":"","sources":["../../src/compositor/shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,6EAA6E;AAE7E,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBhD,CAAC;AAEF,6EAA6E;AAC7E,EAAE;AACF,yCAAyC;AACzC,2DAA2D;AAC3D,2EAA2E;AAC3E,kDAAkD;AAClD,oDAAoD;AACpD,yEAAyE;AACzE,kEAAkE;AAClE,qDAAqD;AACrD,sEAAsE;AACtE,mEAAmE;AAEnE,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;EAejD,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgIrB,CAAC;AAEF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;CAYvC,CAAC;AAEF,8EAA8E;AAC9E,EAAE;AACF,8EAA8E;AAC9E,4EAA4E;AAC5E,4EAA4E;AAC5E,mEAAmE;AAEnE,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBhD,CAAC"}

package/dist/compositor/transform.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Per-layer 2D transform → inverse-affine conversion.
+ *
+ * The Compositor places each layer on a fixed-size canvas with a position,
+ * scale, and rotation. This module is the single source of truth for turning
+ * that human-friendly transform into the `InverseAffine` (canvas px → layer
+ * texel) the {@link WebGPULayerCompositor} blend shader consumes — so the
+ * in-editor live preview and the server-side node render produce identical
+ * placement.
+ *
+ * Convention: the transform rotates and scales the layer about its own center,
+ * and `(x, y)` is where that center sits in canvas pixels. With the default
+ * transform (`scale = 1`, `rotation = 0`, center at `(w/2, h/2)`) a layer's
+ * top-left lands at the canvas origin — identical to an untransformed
+ * top-left paste.
+ */
+import type { InverseAffine } from "./compositor.js";
+/** Layer placement on the composite canvas. Angles are radians, CCW. */
+export interface LayerTransform2D {
+    /** Canvas-pixel X of the layer center. */
+    x: number;
+    /** Canvas-pixel Y of the layer center. */
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    /** Rotation about the layer center, in radians. */
+    rotation: number;
+}
+/**
+ * Default placement for a layer with no explicit transform: contain-fit
+ * centered on the canvas, never upscaled.
+ *
+ * Scale is `min(canvasW/layerW, canvasH/layerH, 1)` — large layers shrink to
+ * fit, smaller layers keep their native size. The layer center is pinned to
+ * the canvas center. For a same-size base layer this reduces to scale=1 with
+ * the top-left at the canvas origin (the historical "untransformed paste"),
+ * so single-layer pipelines are unaffected.
+ */
+export declare function defaultLayerTransform(layerWidth: number, layerHeight: number, canvasWidth: number, canvasHeight: number): LayerTransform2D;
+/**
+ * Build the {@link InverseAffine} (canvas px → layer texel) for a layer of the
+ * given pixel dimensions placed by `transform`.
+ *
+ * Forward map (texel → canvas): `canvas = R·S·(texel - center) + (x, y)`,
+ * with `center = (width/2, height/2)`. The shader needs the inverse; degenerate
+ * (zero) scales fall back to identity rather than producing NaNs.
+ */
+export declare function layerTransformToInverseAffine(transform: LayerTransform2D, width: number, height: number): InverseAffine;
+//# sourceMappingURL=transform.d.ts.map

package/dist/compositor/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/compositor/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,gBAAgB,CAalB;AAID;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,aAAa,CAwBf"}

package/dist/compositor/transform.js

@@ -0,0 +1,74 @@
+/**
+ * Per-layer 2D transform → inverse-affine conversion.
+ *
+ * The Compositor places each layer on a fixed-size canvas with a position,
+ * scale, and rotation. This module is the single source of truth for turning
+ * that human-friendly transform into the `InverseAffine` (canvas px → layer
+ * texel) the {@link WebGPULayerCompositor} blend shader consumes — so the
+ * in-editor live preview and the server-side node render produce identical
+ * placement.
+ *
+ * Convention: the transform rotates and scales the layer about its own center,
+ * and `(x, y)` is where that center sits in canvas pixels. With the default
+ * transform (`scale = 1`, `rotation = 0`, center at `(w/2, h/2)`) a layer's
+ * top-left lands at the canvas origin — identical to an untransformed
+ * top-left paste.
+ */
+/**
+ * Default placement for a layer with no explicit transform: contain-fit
+ * centered on the canvas, never upscaled.
+ *
+ * Scale is `min(canvasW/layerW, canvasH/layerH, 1)` — large layers shrink to
+ * fit, smaller layers keep their native size. The layer center is pinned to
+ * the canvas center. For a same-size base layer this reduces to scale=1 with
+ * the top-left at the canvas origin (the historical "untransformed paste"),
+ * so single-layer pipelines are unaffected.
+ */
+export function defaultLayerTransform(layerWidth, layerHeight, canvasWidth, canvasHeight) {
+    const safeLW = Math.max(1, layerWidth);
+    const safeLH = Math.max(1, layerHeight);
+    const safeCW = Math.max(1, canvasWidth);
+    const safeCH = Math.max(1, canvasHeight);
+    const scale = Math.min(safeCW / safeLW, safeCH / safeLH, 1);
+    return {
+        x: safeCW / 2,
+        y: safeCH / 2,
+        scaleX: scale,
+        scaleY: scale,
+        rotation: 0
+    };
+}
+const IDENTITY = { a: 1, b: 0, tx: 0, c: 0, d: 1, ty: 0 };
+/**
+ * Build the {@link InverseAffine} (canvas px → layer texel) for a layer of the
+ * given pixel dimensions placed by `transform`.
+ *
+ * Forward map (texel → canvas): `canvas = R·S·(texel - center) + (x, y)`,
+ * with `center = (width/2, height/2)`. The shader needs the inverse; degenerate
+ * (zero) scales fall back to identity rather than producing NaNs.
+ */
+export function layerTransformToInverseAffine(transform, width, height) {
+    const sx = transform.scaleX;
+    const sy = transform.scaleY;
+    if (sx === 0 || sy === 0) {
+        return { ...IDENTITY };
+    }
+    const cos = Math.cos(transform.rotation);
+    const sin = Math.sin(transform.rotation);
+    const cx = width / 2;
+    const cy = height / 2;
+    // texel = S⁻¹·R⁻¹·(canvas - (x, y)) + center
+    const a = cos / sx;
+    const b = sin / sx;
+    const c = -sin / sy;
+    const d = cos / sy;
+    return {
+        a,
+        b,
+        tx: cx - a * transform.x - b * transform.y,
+        c,
+        d,
+        ty: cy - c * transform.x - d * transform.y
+    };
+}
+//# sourceMappingURL=transform.js.map

package/dist/compositor/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../src/compositor/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgBH;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,UAAkB,EAClB,WAAmB,EACnB,WAAmB,EACnB,YAAoB;IAEpB,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IACzC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;IAC5D,OAAO;QACL,CAAC,EAAE,MAAM,GAAG,CAAC;QACb,CAAC,EAAE,MAAM,GAAG,CAAC;QACb,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,KAAK;QACb,QAAQ,EAAE,CAAC;KACZ,CAAC;AACJ,CAAC;AAED,MAAM,QAAQ,GAAkB,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AAEzE;;;;;;;GAOG;AACH,MAAM,UAAU,6BAA6B,CAC3C,SAA2B,EAC3B,KAAa,EACb,MAAc;IAEd,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC;IAC5B,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC;IAC5B,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAC;IACzB,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACzC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IACrB,MAAM,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC;IAEtB,6CAA6C;IAC7C,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC;IACnB,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC;IACnB,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;IACpB,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC;IACnB,OAAO;QACL,CAAC;QACD,CAAC;QACD,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC;QAC1C,CAAC;QACD,CAAC;QACD,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC;KAC3C,CAAC;AACJ,CAAC"}

package/dist/context.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `GPUContext` — the host-portability adapter.
+ *
+ * Holds a TypeGPU `root` (from `tgpu.initFromDevice({ device })`) plus the
+ * per-host services the Executor leans on: a pipeline cache, a scratch
+ * texture pool, and a capability record. The same `ShaderModule` code runs
+ * against a browser `navigator.gpu` device, an Electron device, or a
+ * Node.js Dawn device — only the adapter that builds this object differs.
+ */
+import type { TgpuRoot } from "typegpu";
+import { LabeledTexture } from "./texture.js";
+import type { LabeledTextureMeta } from "./texture.js";
+/** Host capabilities used by variant resolution (Phase 3) and validation. */
+export interface GPUCapabilities {
+    /** `texture_external` import supported (camera/video fast path). */
+    textureExternal: boolean;
+    /** `float16` storage textures supported. */
+    f16Storage: boolean;
+}
+export type CachedPipeline = GPURenderPipeline | GPUComputePipeline;
+/** Get-or-compile cache for pipelines, keyed by the caller (module id+variant). */
+export interface PipelineCache {
+    get(key: string): CachedPipeline | undefined;
+    set(key: string, pipeline: CachedPipeline): void;
+}
+export interface ScratchSpec {
+    width: number;
+    height: number;
+    format: GPUTextureFormat;
+    usage: GPUTextureUsageFlags;
+    meta?: Partial<LabeledTextureMeta>;
+    label?: string;
+    /**
+     * Allocate at exactly `width`×`height` instead of rounding up to the
+     * allocation bucket. Needed when the texture is sampled in normalized
+     * `[0,1]` space by a later pass *and* is filled by a writer that only covers
+     * the logical dimensions (the alpha auto-convert pass): a bucketed texture
+     * would leave the margin between the logical size and the bucket unwritten,
+     * which normalized sampling then reads as garbage. Trades pool reuse across
+     * sizes for a physical size that equals the logical size.
+     */
+    exact?: boolean;
+}
+/**
+ * Frame/run-scoped texture pool. `acquire` returns a texture at least as
+ * large as requested (bucketed); `release` returns it for reuse. Hosts own
+ * lifetime — the pool never reads pixels back to the CPU.
+ */
+export interface ScratchPool {
+    acquire(spec: ScratchSpec): LabeledTexture;
+    release(texture: LabeledTexture): void;
+    dispose(): void;
+}
+/**
+ * Reusable uniform buffers. Each dispatch in a submission needs its own slot;
+ * the host calls `beginSubmission` before recording a new command buffer.
+ *
+ * Reuse is safe because of WebGPU's queue ordering: a `writeBuffer` is ordered
+ * after every previously-submitted command on the queue timeline, so reusing a
+ * buffer never races a prior submit's read of it. The only constraint is
+ * *within a single submit*: two dispatches must not share a buffer, regardless
+ * of how many effects the frame contains.
+ */
+export interface UniformRing {
+    beginSubmission(): void;
+    acquire(size: number): GPUBuffer;
+    dispose(): void;
+}
+export interface GPUContext {
+    readonly root: TgpuRoot;
+    readonly device: GPUDevice;
+    readonly capabilities: GPUCapabilities;
+    readonly pipelineCache: PipelineCache;
+    readonly scratch: ScratchPool;
+    readonly uniformRing: UniformRing;
+    /**
+     * 1×1 white texture used as the default for unbound optional inputs (the
+     * canonical case is the `mask` slot — modules sample as if a mask is always
+     * present, the executor supplies coverage = 1 when no mask is bound).
+     * Lazy-allocated on first use; lifetime is tied to the context (no
+     * per-encode allocation).
+     */
+    getDefaultWhiteTexture(): LabeledTexture;
+}
+/** Round a dimension up to the allocation bucket (multiple of 64, pow2 ≥ 256). */
+export declare function ceilToBucket(value: number): number;
+/**
+ * Bucketed, refcounted scratch pool. Buckets on
+ * `(format, usage, bucketW, bucketH)`; the caller sees only the requested
+ * viewport, the underlying texture may be larger.
+ */
+export declare function makeScratchPool(device: GPUDevice): ScratchPool;
+/** Pool of uniform buffers, sized to the largest submission seen. */
+export declare function makeUniformRing(device: GPUDevice): UniformRing;
+/**
+ * Build a {@link GPUContext} from the browser `navigator.gpu`. Browser/WebGPU
+ * only — kept out of the package's pure root so Node consumers can import the
+ * catalog without touching `navigator`.
+ */
+export declare function createBrowserGPUContext(options?: {
+    adapterOptions?: GPURequestAdapterOptions;
+}): Promise<GPUContext>;
+/**
+ * Build a {@link GPUContext} from an already-acquired `GPUDevice` (browser,
+ * Electron, or Node.js Dawn). The shared path every adapter funnels into.
+ */
+export declare function createGPUContextFromDevice(device: GPUDevice): GPUContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,cAAc,EAAwB,MAAM,cAAc,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,eAAe,EAAE,OAAO,CAAC;IACzB,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAEpE,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAC7C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,oBAAoB,CAAC;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc,CAAC;IAC3C,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,eAAe,IAAI,IAAI,CAAC;IACxB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,eAAe,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC;;;;;;OAMG;IACH,sBAAsB,IAAI,cAAc,CAAC;CAC1C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUlD;AAeD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CAuE9D;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CA8B9D;AAUD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,wBAAwB,CAAA;CAAO,GAC1D,OAAO,CAAC,UAAU,CAAC,CAgBrB;AA8BD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAWxE"}