@nodetool-ai/gpu 0.8.1

package/dist/shaders/color/exposure/v1/module.js

@@ -0,0 +1,78 @@
+/**
+ * `color.exposure@1` — multiplicative exposure in stops (`rgb *= pow(2, stops)`).
+ *
+ * `0` stops is passthrough; `+1` doubles, `-1` halves. Clamps output to
+ * `[0, 1]` since the working format is SDR; HDR exposure ships with the
+ * separate HDR pipeline plan. Fragment, with the canonical mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ExposureParams = d.struct({
+    stops: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ExposureParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorExposureV1 = defineModule({
+    id: "color.exposure",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "linear-in-rgb",
+    kind: "fragment",
+    params: ExposureParams,
+    paramDefaults: { stops: 0 },
+    paramUi: {
+        stops: { min: -4, max: 4, step: 0.1, label: "Exposure", notes: "stops (2^x)" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let gain = pow(2.0, layout.$.params.stops);
+  // SDR clamp on the *straight* colour means clamping at alpha in premul
+  // space: straight C clamps at 1.0 ⇒ premul a*C clamps at a. Clamping at a
+  // literal 1.0 here let partial-alpha pixels escape with rgb > a (a 2×
+  // over-bright fringe once composited).
+  let processed = clamp(src.rgb * gain, vec3f(0.0), vec3f(src.a));
+  let mixed = mix(src.rgb, processed, coverage);
+  return vec4f(mixed, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/exposure/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/exposure/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,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,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,YAAY,CAAC;IAC1C,EAAE,EAAE,gBAAgB;IACpB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,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,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE;KAC/E;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;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;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/color/exposureTone/v1/module.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `color.exposureTone@1` — Lightroom/Camera-Raw style tonal exposure.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.Exposure` loop:
+ * multiplicative exposure in stops, luminance-weighted highlight/shadow
+ * recovery, white/black point push, and a final contrast pivot around
+ * mid-grey. With every tonal knob at its default (`0`) this collapses to the
+ * pure `rgb * 2^exposure` of the simpler `color.exposure` module. Fragment,
+ * with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const ExposureToneParams: d.WgslStruct<{
+    exposure: d.F32;
+    contrast: d.F32;
+    highlights: d.F32;
+    shadows: d.F32;
+    whites: d.F32;
+    blacks: d.F32;
+}>;
+export declare const colorExposureToneV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    exposure: d.F32;
+    contrast: d.F32;
+    highlights: d.F32;
+    shadows: d.F32;
+    whites: d.F32;
+    blacks: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/exposureTone/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/exposureTone/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,kBAAkB;;;;;;;EAO7B,CAAC;AAgBH,eAAO,MAAM,mBAAmB;;;;;;;GAuE9B,CAAC"}

package/dist/shaders/color/exposureTone/v1/module.js

@@ -0,0 +1,107 @@
+/**
+ * `color.exposureTone@1` — Lightroom/Camera-Raw style tonal exposure.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.Exposure` loop:
+ * multiplicative exposure in stops, luminance-weighted highlight/shadow
+ * recovery, white/black point push, and a final contrast pivot around
+ * mid-grey. With every tonal knob at its default (`0`) this collapses to the
+ * pure `rgb * 2^exposure` of the simpler `color.exposure` module. Fragment,
+ * with the canonical optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const ExposureToneParams = d.struct({
+    exposure: d.f32,
+    contrast: d.f32,
+    highlights: d.f32,
+    shadows: d.f32,
+    whites: d.f32,
+    blacks: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ExposureToneParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorExposureToneV1 = defineModule({
+    id: "color.exposureTone",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ExposureToneParams,
+    paramDefaults: {
+        exposure: 0,
+        contrast: 0,
+        highlights: 0,
+        shadows: 0,
+        whites: 0,
+        blacks: 0
+    },
+    paramUi: {
+        exposure: { min: -5, max: 5, step: 0.1, label: "Exposure", notes: "stops (2^x)" },
+        contrast: { min: -1, max: 1, step: 0.01, label: "Contrast" },
+        highlights: { min: -1, max: 1, step: 0.01, label: "Highlights" },
+        shadows: { min: -1, max: 1, step: 0.01, label: "Shadows" },
+        whites: { min: -1, max: 1, step: 0.01, label: "Whites" },
+        blacks: { min: -1, max: 1, step: 0.01, label: "Blacks" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+${WGSL_LUMA709}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let expMul = pow(2.0, p.exposure);
+  var rgb = straight * expMul;
+  let lum = luma709(rgb);
+  let hlMask = clamp((lum - 0.5) * 2.0, 0.0, 1.0);
+  let shMask = clamp((0.5 - lum) * 2.0, 0.0, 1.0);
+  rgb = rgb - vec3f(hlMask * p.highlights * 0.5) + vec3f(shMask * p.shadows * 0.5);
+  rgb = rgb + p.whites * 0.2 * rgb;
+  rgb = rgb + p.blacks * 0.2 * (vec3f(1.0) - rgb);
+  rgb = vec3f(0.5) + (rgb - vec3f(0.5)) * (1.0 + p.contrast);
+  let mixed = mix(straight, rgb, coverage);
+  return vec4f(clamp(mixed, vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/exposureTone/v1/module.js.map

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

package/dist/shaders/color/filmLook/v1/module.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `color.filmLook@1` — cinematic film-emulation grade with adjustable
+ * intensity.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.FilmLook` loop. The
+ * host resolves a named preset (teal/orange, noir, …) to its shadow/highlight
+ * tint colours plus contrast, saturation, and fade scalars, and passes them
+ * as params. The shader applies the look on straight RGB then lerps from the
+ * original by `intensity`. Fragment, with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const FilmLookParams: d.WgslStruct<{
+    shadow: d.Vec3f;
+    contrast: d.F32;
+    highlight: d.Vec3f;
+    saturation: d.F32;
+    fade: d.F32;
+    intensity: d.F32;
+}>;
+export declare const colorFilmLookV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    shadow: d.Vec3f;
+    contrast: d.F32;
+    highlight: d.Vec3f;
+    saturation: d.F32;
+    fade: d.F32;
+    intensity: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/filmLook/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/filmLook/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAC;AAgBH,eAAO,MAAM,eAAe;;;;;;;GAmE1B,CAAC"}

package/dist/shaders/color/filmLook/v1/module.js

@@ -0,0 +1,103 @@
+/**
+ * `color.filmLook@1` — cinematic film-emulation grade with adjustable
+ * intensity.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.FilmLook` loop. The
+ * host resolves a named preset (teal/orange, noir, …) to its shadow/highlight
+ * tint colours plus contrast, saturation, and fade scalars, and passes them
+ * as params. The shader applies the look on straight RGB then lerps from the
+ * original by `intensity`. Fragment, with the canonical optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+import { WGSL_LUMA709 } from "../../../../shared/lumaWgsl.js";
+export const FilmLookParams = d.struct({
+    shadow: d.vec3f,
+    contrast: d.f32,
+    highlight: d.vec3f,
+    saturation: d.f32,
+    fade: d.f32,
+    intensity: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: FilmLookParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorFilmLookV1 = defineModule({
+    id: "color.filmLook",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: FilmLookParams,
+    paramDefaults: {
+        shadow: d.vec3f(0.5, 0.5, 0.5),
+        contrast: 1,
+        highlight: d.vec3f(0.5, 0.5, 0.5),
+        saturation: 1,
+        fade: 0,
+        intensity: 0
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+${WGSL_LUMA709}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  var rgb = straight;
+  let lum = luma709(rgb);
+  let shMask = clamp(1.0 - lum * 2.0, 0.0, 1.0);
+  let hlMask = clamp(lum * 2.0 - 1.0, 0.0, 1.0);
+  rgb = rgb
+    + shMask * (p.shadow - vec3f(0.5)) * 0.3
+    + hlMask * (p.highlight - vec3f(0.5)) * 0.3;
+  rgb = (rgb - vec3f(0.5)) * p.contrast + vec3f(0.5);
+  let lum2 = luma709(rgb);
+  rgb = vec3f(lum2) + (rgb - vec3f(lum2)) * p.saturation;
+  // fade = 0 leaves rgb unchanged, so the CPU's "if (fade > 0)" guard is moot.
+  rgb = rgb * (1.0 - p.fade) + vec3f(p.fade * 0.15);
+  rgb = straight + (rgb - straight) * p.intensity;
+  let mixed = mix(straight, rgb, coverage);
+  return vec4f(clamp(mixed, vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/filmLook/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/filmLook/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;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK;IACf,QAAQ,EAAE,CAAC,CAAC,GAAG;IACf,SAAS,EAAE,CAAC,CAAC,KAAK;IAClB,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,SAAS,EAAE,CAAC,CAAC,GAAG;CACjB,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,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,YAAY,CAAC;IAC1C,EAAE,EAAE,gBAAgB;IACpB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE;QACb,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;QAC9B,QAAQ,EAAE,CAAC;QACX,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;QACjC,UAAU,EAAE,CAAC;QACb,IAAI,EAAE,CAAC;QACP,SAAS,EAAE,CAAC;KACb;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;EACjB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;CAyBb;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/grade/v1/module.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `color.grade@1` — per-pixel color grading (brightness, contrast,
+ * saturation, hue, temperature, tint, shadows/highlights).
+ *
+ * Migrated verbatim from the timeline preview's `effectsComputeShader`
+ * (`web/src/components/timeline/preview/gpu/shaders.ts`). The hand-packed
+ * 8×f32 uniform `Float32Array` is replaced by the TypeGPU `ColorGradeParams`
+ * schema; the effect math is unchanged. Stays `surface: "internal"` until the
+ * parameter schema is reviewed for promotion (Phase 3).
+ *
+ * `compute` kind is a migration accident — the timeline shader was authored as
+ * a compute pass. New image-in/image-out modules default to `fragment`.
+ */
+import * as d from "typegpu/data";
+export declare const ColorGradeParams: d.WgslStruct<{
+    brightness: d.F32;
+    contrast: d.F32;
+    saturation: d.F32;
+    hue: d.F32;
+    temperature: d.F32;
+    tint: d.F32;
+    shadows: d.F32;
+    highlights: d.F32;
+}>;
+export declare const colorGradeV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    brightness: d.F32;
+    contrast: d.F32;
+    saturation: d.F32;
+    hue: d.F32;
+    temperature: d.F32;
+    tint: d.F32;
+    shadows: d.F32;
+    highlights: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/grade/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/grade/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,gBAAgB;;;;;;;;;EAS3B,CAAC;AAQH,eAAO,MAAM,YAAY;;;;;;;;;GAqJvB,CAAC"}

package/dist/shaders/color/grade/v1/module.js

@@ -0,0 +1,182 @@
+/**
+ * `color.grade@1` — per-pixel color grading (brightness, contrast,
+ * saturation, hue, temperature, tint, shadows/highlights).
+ *
+ * Migrated verbatim from the timeline preview's `effectsComputeShader`
+ * (`web/src/components/timeline/preview/gpu/shaders.ts`). The hand-packed
+ * 8×f32 uniform `Float32Array` is replaced by the TypeGPU `ColorGradeParams`
+ * schema; the effect math is unchanged. Stays `surface: "internal"` until the
+ * parameter schema is reviewed for promotion (Phase 3).
+ *
+ * `compute` kind is a migration accident — the timeline shader was authored as
+ * a compute pass. New image-in/image-out modules default to `fragment`.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ColorGradeParams = d.struct({
+    brightness: d.f32,
+    contrast: d.f32,
+    saturation: d.f32,
+    hue: d.f32,
+    temperature: d.f32,
+    tint: d.f32,
+    shadows: d.f32,
+    highlights: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    source: { texture: "float" },
+    outputTexture: { storageTexture: "rgba8unorm" },
+    params: { uniform: ColorGradeParams }
+});
+export const colorGradeV1 = defineModule({
+    id: "color.grade",
+    version: 1,
+    // Promoted in Phase 3: param schema is stable across Phase 2 + Batch 1
+    // and is the most-used per-clip color effect in the timeline.
+    surface: "published",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "compute",
+    params: ColorGradeParams,
+    paramDefaults: {
+        brightness: 0,
+        contrast: 1,
+        saturation: 1,
+        hue: 0,
+        temperature: 0,
+        tint: 0,
+        shadows: 0,
+        highlights: 0
+    },
+    paramUi: {
+        brightness: { min: -1, max: 1, step: 0.01, label: "Brightness" },
+        contrast: { min: 0, max: 4, step: 0.01, label: "Contrast" },
+        saturation: { min: 0, max: 4, step: 0.01, label: "Saturation" },
+        hue: { min: -180, max: 180, step: 1, label: "Hue", notes: "degrees" },
+        temperature: { min: -1, max: 1, step: 0.01, label: "Temperature" },
+        tint: { min: -1, max: 1, step: 0.01, label: "Tint" },
+        shadows: { min: -1, max: 1, step: 0.01, label: "Shadows" },
+        highlights: { min: -1, max: 1, step: 0.01, label: "Highlights" }
+    },
+    layout,
+    workgroupSize: [16, 16, 1],
+    wgsl: /* wgsl */ `
+fn rgb2hsv(rgb: vec3<f32>) -> vec3<f32> {
+  let maxC = max(max(rgb.r, rgb.g), rgb.b);
+  let minC = min(min(rgb.r, rgb.g), rgb.b);
+  let delta = maxC - minC;
+  var h: f32 = 0.0;
+  var s: f32 = 0.0;
+  let v: f32 = maxC;
+  if (delta > 0.00001) {
+    s = delta / maxC;
+    if (maxC == rgb.r) {
+      h = (rgb.g - rgb.b) / delta;
+      if (rgb.g < rgb.b) { h = h + 6.0; }
+    } else if (maxC == rgb.g) {
+      h = 2.0 + (rgb.b - rgb.r) / delta;
+    } else {
+      h = 4.0 + (rgb.r - rgb.g) / delta;
+    }
+    h = h / 6.0;
+  }
+  return vec3<f32>(h, s, v);
+}
+
+fn hsv2rgb(hsv: vec3<f32>) -> vec3<f32> {
+  let h = hsv.x * 6.0;
+  let s = hsv.y;
+  let v = hsv.z;
+  let i = floor(h);
+  let f = h - i;
+  let p = v * (1.0 - s);
+  let q = v * (1.0 - s * f);
+  let t = v * (1.0 - s * (1.0 - f));
+  let idx = i32(i) % 6;
+  if (idx == 0) { return vec3<f32>(v, t, p); }
+  if (idx == 1) { return vec3<f32>(q, v, p); }
+  if (idx == 2) { return vec3<f32>(p, v, t); }
+  if (idx == 3) { return vec3<f32>(p, q, v); }
+  if (idx == 4) { return vec3<f32>(t, p, v); }
+  return vec3<f32>(v, p, q);
+}
+
+fn smoothstepCustom(e0: f32, e1: f32, x: f32) -> f32 {
+  let t = clamp((x - e0) / (e1 - e0), 0.0, 1.0);
+  return t * t * (3.0 - 2.0 * t);
+}
+
+@compute @workgroup_size(16, 16, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let dims = textureDimensions(layout.$.source);
+  if (gid.x >= dims.x || gid.y >= dims.y) { return; }
+  let coords = vec2<i32>(i32(gid.x), i32(gid.y));
+  let effects = layout.$.params;
+  var color = textureLoad(layout.$.source, coords, 0);
+  // Input is premultiplied (rgb = a*C); the additive brightness / tint /
+  // shadows-highlights stages assume straight color. Un-premultiply first,
+  // run the full effect chain on straight RGB, then re-premultiply on store.
+  let safeA = max(color.a, 1.0 / 255.0);
+  var rgb = color.rgb / safeA;
+
+  if (abs(effects.brightness) > 0.001) {
+    rgb = clamp(rgb + vec3<f32>(effects.brightness), vec3<f32>(0.0), vec3<f32>(1.0));
+  }
+  if (abs(effects.contrast - 1.0) > 0.001) {
+    rgb = clamp((rgb - 0.5) * effects.contrast + 0.5, vec3<f32>(0.0), vec3<f32>(1.0));
+  }
+  if (abs(effects.saturation - 1.0) > 0.001) {
+    let lum = dot(rgb, vec3<f32>(0.299, 0.587, 0.114));
+    rgb = clamp(mix(vec3<f32>(lum), rgb, effects.saturation), vec3<f32>(0.0), vec3<f32>(1.0));
+  }
+  if (abs(effects.hue) > 0.001) {
+    var hsv = rgb2hsv(rgb);
+    hsv.x = fract(hsv.x + effects.hue / 360.0);
+    rgb = hsv2rgb(hsv);
+  }
+  if (abs(effects.temperature) > 0.001) {
+    if (effects.temperature > 0.0) {
+      rgb.r = min(1.0, rgb.r + effects.temperature * 0.2);
+      rgb.g = min(1.0, rgb.g + effects.temperature * 0.1);
+      rgb.b = max(0.0, rgb.b - effects.temperature * 0.2);
+    } else {
+      rgb.r = max(0.0, rgb.r + effects.temperature * 0.2);
+      rgb.g = max(0.0, rgb.g + effects.temperature * 0.05);
+      rgb.b = min(1.0, rgb.b - effects.temperature * 0.2);
+    }
+  }
+  if (abs(effects.tint) > 0.001) {
+    rgb.r = clamp(rgb.r + effects.tint * 0.1, 0.0, 1.0);
+    rgb.g = clamp(rgb.g - effects.tint * 0.2, 0.0, 1.0);
+    rgb.b = clamp(rgb.b + effects.tint * 0.1, 0.0, 1.0);
+  }
+  if (abs(effects.shadows) > 0.001 || abs(effects.highlights) > 0.001) {
+    let lum = dot(rgb, vec3<f32>(0.299, 0.587, 0.114));
+    let shadowW = 1.0 - smoothstepCustom(0.0, 0.33, lum);
+    let highlightW = smoothstepCustom(0.66, 1.0, lum);
+    let adj = effects.shadows * shadowW * 0.3 + effects.highlights * highlightW * 0.3;
+    rgb = clamp(rgb + vec3<f32>(adj), vec3<f32>(0.0), vec3<f32>(1.0));
+  }
+
+  textureStore(layout.$.outputTexture, coords, vec4<f32>(rgb * color.a, color.a));
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/grade/v1/module.js.map

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

package/dist/shaders/color/grayscale/v1/module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `color.grayscale@1` — collapse RGB to luminance.
+ *
+ * `output.rgb = vec3(luma709(rgb))`. Alpha preserved. Honours the canonical
+ * mask slot so workflows can grayscale a region while the rest stays colored.
+ */
+import * as d from "typegpu/data";
+export declare const GrayscaleParams: d.WgslStruct<{
+    amount: d.F32;
+}>;
+export declare const colorGrayscaleV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    amount: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/grayscale/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/grayscale/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,eAAO,MAAM,eAAe;;EAE1B,CAAC;AAgBH,eAAO,MAAM,gBAAgB;;GAoD3B,CAAC"}