@remotion/effects 4.0.536 → 4.0.538

package/dist/starburst.d.ts

@@ -1,49 +1,49 @@
 export declare const starburstEffectSchema: {
     readonly rays: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 2;
         readonly max: 100;
         readonly step: 1;
         readonly default: undefined;
-        readonly description: "Number of Rays";
+        readonly description: 'Number of Rays';
         readonly hiddenFromList: false;
     };
     readonly colors: {
-        readonly type: "array";
+        readonly type: 'array';
         readonly item: {
-            readonly type: "color";
+            readonly type: 'color';
         };
         readonly default: undefined;
         readonly minLength: 2;
-        readonly newItemDefault: "#ff0000";
-        readonly description: "Colors";
+        readonly newItemDefault: '#ff0000';
+        readonly description: 'Colors';
         readonly keyframable: false;
     };
     readonly rotation: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 360;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Rotation";
+        readonly description: 'Rotation';
         readonly hiddenFromList: false;
     };
     readonly smoothness: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0;
-        readonly description: "Edge Smoothness";
+        readonly description: 'Edge Smoothness';
         readonly hiddenFromList: false;
     };
     readonly origin: {
-        readonly type: "uv-coordinate";
+        readonly type: 'uv-coordinate';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: readonly [0.5, 0.5];
-        readonly description: "Origin";
+        readonly description: 'Origin';
     };
 };
 export type StarburstOrigin = readonly [number, number];
@@ -55,5 +55,5 @@ export type StarburstEffectParams = {
     readonly origin?: StarburstOrigin;
 };
 export declare const starburst: (params: StarburstEffectParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) => import("remotion").EffectDescriptor<unknown>;

package/dist/tear.d.ts

@@ -9,5 +9,5 @@ export type TearParams = {
     readonly jaggedness?: number;
 };
 export declare const tear: (params?: (TearParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/thermal-vision.d.ts

@@ -1,22 +1,22 @@
 export declare const thermalVisionSchema: {
     readonly amount: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 1;
-        readonly description: "Amount";
+        readonly description: 'Amount';
         readonly hiddenFromList: false;
     };
     readonly palette: {
-        readonly type: "array";
+        readonly type: 'array';
         readonly item: {
-            readonly type: "color";
+            readonly type: 'color';
         };
         readonly default: readonly ["#020617", "#1238ff", "#00a6ff", "#00c853", "#d6f542", "#ffb000", "#ff2f00", "#ffffff"];
         readonly minLength: 2;
-        readonly newItemDefault: "#00c853";
-        readonly description: "Palette";
+        readonly newItemDefault: '#00c853';
+        readonly description: 'Palette';
         readonly keyframable: false;
     };
 };
@@ -27,5 +27,5 @@ export type ThermalVisionParams = {
     readonly palette?: readonly string[];
 };
 export declare const thermalVision: (params?: (ThermalVisionParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/tile.d.ts

@@ -5,5 +5,5 @@ export type TileParams = {
     readonly vertical?: boolean;
 };
 export declare const tile: (params?: (TileParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/tint.d.ts

@@ -1,16 +1,16 @@
 export declare const tintSchema: {
     readonly color: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: undefined;
-        readonly description: "Color";
+        readonly description: 'Color';
     };
     readonly amount: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.5;
-        readonly description: "Amount";
+        readonly description: 'Amount';
         readonly hiddenFromList: false;
     };
 };
@@ -19,5 +19,5 @@ export type TintParams = {
     readonly amount?: number;
 };
 export declare const tint: (params: TintParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) => import("remotion").EffectDescriptor<unknown>;

package/dist/translate/index.d.ts

@@ -11,8 +11,8 @@ export type UvTranslateParams = {
     readonly v?: number;
 };
 export declare const xyTranslate: (params?: (XyTranslateParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export declare const uvTranslate: (params?: (UvTranslateParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/turbulent-displace/index.d.ts

@@ -0,0 +1,28 @@
+declare const DISPLACEMENT_MODES: readonly ['turbulent', 'bulge', 'twist', 'turbulent-smoother', 'bulge-smoother', 'twist-smoother', 'vertical', 'horizontal', 'cross'];
+declare const PINNING_MODES: readonly ['none', 'all', 'horizontal', 'vertical', 'left', 'top', 'right', 'bottom', 'all-locked', 'horizontal-locked', 'vertical-locked', 'left-locked', 'top-locked', 'right-locked', 'bottom-locked'];
+export type TurbulentDisplaceParams = {
+    /** Distortion mode. Defaults to `turbulent`. */
+    readonly displacement?: (typeof DISPLACEMENT_MODES)[number];
+    /** Displacement strength in pixels. May be negative. Defaults to `50`. */
+    readonly amount?: number;
+    /** Size of the noise features in pixels. Must be at least `1`. Defaults to `100`. */
+    readonly size?: number;
+    /** Noise origin in UV coordinates. Defaults to `[0.5, 0.5]`. */
+    readonly offset?: readonly [number, number];
+    /** Number of noise layers, including fractional layers, from `1` to `10`. Defaults to `1`. */
+    readonly complexity?: number;
+    /** Noise evolution in degrees. Animate to morph the distortion. Defaults to `0`. */
+    readonly evolution?: number;
+    /** Loop the evolution after `cycle` revolutions. Defaults to `false`. */
+    readonly cycleEvolution?: boolean;
+    /** Loop length in whole revolutions. Defaults to `1`. */
+    readonly cycle?: number;
+    /** Unsigned 32-bit integer seed for repeatable distortion. Defaults to `0`. */
+    readonly seed?: number;
+    /** Edges kept in place. Locked modes also keep samples inside the source. Defaults to `all`. */
+    readonly pinning?: (typeof PINNING_MODES)[number];
+};
+export declare const turbulentDisplace: (params?: (TurbulentDisplaceParams & {
+    readonly disabled?: boolean;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;
+export {};

package/dist/turbulent-displace/shader.d.ts

@@ -0,0 +1 @@
+export declare const TURBULENT_DISPLACE_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nin vec2 vUv;\nout vec4 fragColor;\nuniform sampler2D uSource;\nuniform vec2 uResolution;\nuniform float uAmount;\nuniform float uSize;\nuniform vec2 uOffset;\nuniform float uComplexity;\nuniform float uEvolution;\nuniform bool uCycleEvolution;\nuniform float uCycle;\nuniform uint uSeed;\nuniform int uDisplacement;\nuniform int uPinning;\nconst int uNoiseType = 2;\n\n\nfloat lattice(ivec3 point, uint seed) {\n  // Wrap lattice indices as well as coordinates so interpolation stays continuous\n  // across the period boundary, including negative coordinates.\n  uvec3 p = uvec3(point) & uvec3(65535u);\n  uint h = p.x * 0x27d4eb2du ^ p.y * 0x165667b1u ^ p.z * 0x9e3779b9u ^ seed * 0x85ebca6bu;\n  h ^= h >> 15;\n  h *= 0x2c1b3c6du;\n  h ^= h >> 12;\n  h *= 0x297a2d39u;\n  h ^= h >> 15;\n  return float(h & 65535u) / 65535.0;\n}\n\nfloat catmull(vec4 p, float t) {\n  return 0.5 * (2.0 * p.y + (p.z - p.x) * t\n    + (2.0 * p.x - 5.0 * p.y + 4.0 * p.z - p.w) * t * t\n    + (3.0 * p.y - p.x - 3.0 * p.z + p.w) * t * t * t);\n}\n\nvec3 bspline(float t) {\n  return vec3(0.5 * (1.0-t) * (1.0-t), 0.5 + t * (1.0-t), 0.5 * t * t);\n}\n\nfloat sliceNoise(ivec3 p, vec2 t, uint seed) {\n  if (uNoiseType == 0) return lattice(p, seed);\n  if (uNoiseType == 1) {\n    return mix(mix(lattice(p, seed), lattice(p + ivec3(1,0,0), seed), t.x),\n      mix(lattice(p + ivec3(0,1,0), seed), lattice(p + ivec3(1,1,0), seed), t.x), t.y);\n  }\n  if (uNoiseType == 2) {\n    vec3 wx = bspline(t.x);\n    vec3 wy = bspline(t.y);\n    float result = 0.0;\n    for (int y = 0; y < 3; y++) {\n      for (int x = 0; x < 3; x++) {\n        result += wx[x] * wy[y] * lattice(p + ivec3(x-1, y-1, 0), seed);\n      }\n    }\n    return result;\n  }\n  vec4 rows;\n  for (int y = 0; y < 4; y++) {\n    vec4 row;\n    for (int x = 0; x < 4; x++) {\n      row[x] = lattice(p + ivec3(x-1, y-1, 0), seed);\n    }\n    rows[y] = catmull(row, t.x);\n  }\n  return catmull(rows, t.y);\n}\n\nfloat valueNoise(vec3 point, uint seed) {\n  // A large period keeps conversion to integer coordinates defined at extreme scales.\n  vec3 p = mod(point + vec3(uNoiseType == 2 ? 0.5 : 0.0, uNoiseType == 2 ? 0.5 : 0.0, 0.0), 65536.0);\n  ivec3 cell = ivec3(floor(p));\n  vec3 t = fract(p);\n  float fz = t.z * t.z * t.z * (t.z * (t.z * 6.0 - 15.0) + 10.0);\n  float n = mix(sliceNoise(cell, t.xy, seed), sliceNoise(cell + ivec3(0,0,1), t.xy, seed), fz);\n  return uNoiseType == 2 ? 0.5 + (n - 0.5) * (181.0 / 231.0) / 0.55 : n;\n}\n\n\nfloat noiseLayer(vec2 p, float z, uint seed) {\n  if (!uCycleEvolution) return valueNoise(vec3(p, uEvolution + z), seed);\n  float t = mod(uEvolution, uCycle);\n  // Zero blend derivatives at the seam keep the looping motion smooth.\n  float weight = smoothstep(0.0, 1.0, t / uCycle);\n  return mix(valueNoise(vec3(p, t + z), seed), valueNoise(vec3(p, t - uCycle + z), seed), weight);\n}\n\nfloat turbulence(vec2 p, uint channel) {\n  float sum = 0.0;\n  float norm = 0.0;\n  float amplitude = 1.0;\n  float frequency = 1.0;\n  float falloff = uDisplacement >= 3 && uDisplacement <= 5 ? 0.3 : 0.5;\n  for (int octave = 0; octave < 10; octave++) {\n    float weight = clamp(uComplexity - float(octave), 0.0, 1.0);\n    if (weight == 0.0) break;\n    uint seed = (uSeed ^ 0x7d15u) + channel + uint(octave) * 101u;\n    sum += noiseLayer(p * frequency, float(octave) * 5.17, seed) * amplitude * weight;\n    norm += amplitude * weight;\n    amplitude *= falloff;\n    frequency *= 2.0;\n  }\n  return sum / norm - 0.5;\n}\n\nvec4 readPixel(ivec2 p) {\n  if (any(lessThan(p, ivec2(0))) || any(greaterThanEqual(p, ivec2(uResolution)))) return vec4(0.0);\n  return texelFetch(uSource, ivec2(p.x, int(uResolution.y) - 1 - p.y), 0);\n}\n\nvec4 sampleSource(vec2 p) {\n  // Bilinear interpolation with transparent samples outside the source, so\n  // warped alpha edges do not smear the outermost pixel across the canvas.\n  ivec2 base = ivec2(floor(p - 0.5));\n  vec2 t = fract(p - 0.5);\n  return mix(mix(readPixel(base), readPixel(base + ivec2(1,0)), t.x),\n    mix(readPixel(base + ivec2(0,1)), readPixel(base + ivec2(1,1)), t.x), t.y);\n}\n\nvoid main() {\n  if (uAmount == 0.0) {\n    fragColor = texture(uSource, vUv);\n    return;\n  }\n  vec2 pixel = vec2(vUv.x, 1.0 - vUv.y) * uResolution;\n  vec2 p = (pixel - uOffset * uResolution) / uSize;\n  vec2 displacement;\n  if (uDisplacement == 1 || uDisplacement == 2 || uDisplacement == 4 || uDisplacement == 5) {\n    float epsilon = 0.05;\n    vec2 gradient = vec2(\n      turbulence(p + vec2(epsilon,0), 0u) - turbulence(p - vec2(epsilon,0), 0u),\n      turbulence(p + vec2(0,epsilon), 0u) - turbulence(p - vec2(0,epsilon), 0u)\n    ) / (2.0 * epsilon);\n    displacement = (uDisplacement == 1 || uDisplacement == 4) ? gradient : vec2(-gradient.y, gradient.x);\n    displacement *= uAmount * 0.25;\n  } else if (uDisplacement == 6) {\n    displacement = vec2(0.0, turbulence(p, 17u) * uAmount);\n  } else if (uDisplacement == 7) {\n    displacement = vec2(turbulence(p, 0u) * uAmount, 0.0);\n  } else if (uDisplacement == 8) {\n    displacement = vec2(turbulence(p, 0u) * uAmount);\n  } else {\n    displacement = vec2(turbulence(p, 0u), turbulence(p, 17u)) * uAmount;\n  }\n  bool locked = uPinning >= 8;\n  int pin = locked ? uPinning - 7 : uPinning;\n  float edge = max(1.0, min(uResolution.x, uResolution.y) * (locked ? 0.25 : 0.1));\n  vec2 nearEdge = clamp((pixel - 0.5) / edge, 0.0, 1.0);\n  vec2 farEdge = clamp((uResolution - 0.5 - pixel) / edge, 0.0, 1.0);\n  float horizontal = min(nearEdge.x, farEdge.x);\n  float vertical = min(nearEdge.y, farEdge.y);\n  float weight = 1.0;\n  if (pin == 1) weight = min(horizontal, vertical);\n  if (pin == 2) weight = vertical;\n  if (pin == 3) weight = horizontal;\n  if (pin == 4) weight = nearEdge.x;\n  if (pin == 5) weight = nearEdge.y;\n  if (pin == 6) weight = farEdge.x;\n  if (pin == 7) weight = farEdge.y;\n  vec2 sourcePixel = pixel + displacement * weight;\n  if (locked) sourcePixel = clamp(sourcePixel, vec2(0.5), uResolution - 0.5);\n  fragColor = sampleSource(sourcePixel);\n}\n";

package/dist/turbulent-displace.d.ts

@@ -0,0 +1 @@
+export { turbulentDisplace, type TurbulentDisplaceParams, } from './turbulent-displace/index.js';

package/dist/tv-signal-off.d.ts

@@ -3,5 +3,5 @@ export type TvSignalOffParams = {
     readonly amount?: number;
 };
 export declare const tvSignalOff: (params?: (TvSignalOffParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/value-noise-shader.d.ts

@@ -0,0 +1 @@
+export declare const VALUE_NOISE_SHADER = "\nfloat lattice(ivec3 point, uint seed) {\n  // Wrap lattice indices as well as coordinates so interpolation stays continuous\n  // across the period boundary, including negative coordinates.\n  uvec3 p = uvec3(point) & uvec3(65535u);\n  uint h = p.x * 0x27d4eb2du ^ p.y * 0x165667b1u ^ p.z * 0x9e3779b9u ^ seed * 0x85ebca6bu;\n  h ^= h >> 15;\n  h *= 0x2c1b3c6du;\n  h ^= h >> 12;\n  h *= 0x297a2d39u;\n  h ^= h >> 15;\n  return float(h & 65535u) / 65535.0;\n}\n\nfloat catmull(vec4 p, float t) {\n  return 0.5 * (2.0 * p.y + (p.z - p.x) * t\n    + (2.0 * p.x - 5.0 * p.y + 4.0 * p.z - p.w) * t * t\n    + (3.0 * p.y - p.x - 3.0 * p.z + p.w) * t * t * t);\n}\n\nvec3 bspline(float t) {\n  return vec3(0.5 * (1.0-t) * (1.0-t), 0.5 + t * (1.0-t), 0.5 * t * t);\n}\n\nfloat sliceNoise(ivec3 p, vec2 t, uint seed) {\n  if (uNoiseType == 0) return lattice(p, seed);\n  if (uNoiseType == 1) {\n    return mix(mix(lattice(p, seed), lattice(p + ivec3(1,0,0), seed), t.x),\n      mix(lattice(p + ivec3(0,1,0), seed), lattice(p + ivec3(1,1,0), seed), t.x), t.y);\n  }\n  if (uNoiseType == 2) {\n    vec3 wx = bspline(t.x);\n    vec3 wy = bspline(t.y);\n    float result = 0.0;\n    for (int y = 0; y < 3; y++) {\n      for (int x = 0; x < 3; x++) {\n        result += wx[x] * wy[y] * lattice(p + ivec3(x-1, y-1, 0), seed);\n      }\n    }\n    return result;\n  }\n  vec4 rows;\n  for (int y = 0; y < 4; y++) {\n    vec4 row;\n    for (int x = 0; x < 4; x++) {\n      row[x] = lattice(p + ivec3(x-1, y-1, 0), seed);\n    }\n    rows[y] = catmull(row, t.x);\n  }\n  return catmull(rows, t.y);\n}\n\nfloat valueNoise(vec3 point, uint seed) {\n  // A large period keeps conversion to integer coordinates defined at extreme scales.\n  vec3 p = mod(point + vec3(uNoiseType == 2 ? 0.5 : 0.0, uNoiseType == 2 ? 0.5 : 0.0, 0.0), 65536.0);\n  ivec3 cell = ivec3(floor(p));\n  vec3 t = fract(p);\n  float fz = t.z * t.z * t.z * (t.z * (t.z * 6.0 - 15.0) + 10.0);\n  float n = mix(sliceNoise(cell, t.xy, seed), sliceNoise(cell + ivec3(0,0,1), t.xy, seed), fz);\n  return uNoiseType == 2 ? 0.5 + (n - 0.5) * (181.0 / 231.0) / 0.55 : n;\n}\n";

package/dist/venetian-blinds.d.ts

@@ -1,32 +1,32 @@
-declare const VENETIAN_BLINDS_DIRECTIONS: readonly ["vertical", "horizontal"];
+declare const VENETIAN_BLINDS_DIRECTIONS: readonly ['vertical', 'horizontal'];
 export type VenetianBlindsDirection = (typeof VENETIAN_BLINDS_DIRECTIONS)[number];
 export declare const venetianBlindsSchema: {
     readonly progress: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.5;
-        readonly description: "Progress";
+        readonly description: 'Progress';
         readonly hiddenFromList: false;
     };
     readonly direction: {
-        readonly type: "enum";
+        readonly type: 'enum';
         readonly variants: {
             readonly vertical: {};
             readonly horizontal: {};
         };
         readonly default: "vertical";
-        readonly description: "Direction";
+        readonly description: 'Direction';
     };
     readonly slats: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 100;
         readonly step: 1;
         readonly integer: true;
         readonly default: 12;
-        readonly description: "Slats";
+        readonly description: 'Slats';
         readonly hiddenFromList: false;
     };
 };
@@ -39,6 +39,6 @@ export type VenetianBlindsParams = {
     readonly slats?: number;
 };
 export declare const venetianBlinds: (params?: (VenetianBlindsParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/vibrance.d.ts

@@ -3,5 +3,5 @@ export type VibranceParams = {
     readonly amount?: number;
 };
 export declare const vibrance: (params?: (VibranceParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/vignette.d.ts

@@ -1,60 +1,60 @@
-declare const VIGNETTE_MODES: readonly ["color", "alpha"];
+declare const VIGNETTE_MODES: readonly ['color', 'alpha'];
 export declare const vignetteSchema: {
     readonly amount: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.5;
-        readonly description: "Amount";
+        readonly description: 'Amount';
         readonly hiddenFromList: false;
     };
     readonly radius: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.65;
-        readonly description: "Radius";
+        readonly description: 'Radius';
         readonly hiddenFromList: false;
     };
     readonly feather: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.35;
-        readonly description: "Feather";
+        readonly description: 'Feather';
         readonly hiddenFromList: false;
     };
     readonly roundness: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 1;
-        readonly description: "Roundness";
+        readonly description: 'Roundness';
         readonly hiddenFromList: false;
     };
     readonly color: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "#000000";
-        readonly description: "Color";
+        readonly description: 'Color';
     };
     readonly mode: {
-        readonly type: "enum";
+        readonly type: 'enum';
         readonly default: "color";
-        readonly description: "Mode";
+        readonly description: 'Mode';
         readonly variants: {
             readonly color: {};
             readonly alpha: {};
         };
     };
     readonly center: {
-        readonly type: "uv-coordinate";
+        readonly type: 'uv-coordinate';
         readonly step: 0.01;
         readonly default: readonly [0.5, 0.5];
-        readonly description: "Center";
+        readonly description: 'Center';
     };
 };
 export type VignetteMode = (typeof VIGNETTE_MODES)[number];
@@ -76,6 +76,6 @@ export type VignetteParams = {
     readonly center?: VignetteCenter;
 };
 export declare const vignette: (params?: (VignetteParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/visual-test/visual-utils.d.ts

@@ -2,19 +2,19 @@ import { type EffectDefinitionAndStack, type EffectDescriptor } from 'remotion';
 export declare const testImage: ({ blob, testId, threshold, allowedMismatchedPixelRatio, }: {
     blob: Blob;
     testId: string;
-    threshold?: number | undefined;
-    allowedMismatchedPixelRatio?: number | undefined;
+    threshold?: number;
+    allowedMismatchedPixelRatio?: number;
 }) => Promise<void>;
 export declare const descriptorsToMemoizedEffects: (effects: EffectDescriptor<unknown>[]) => EffectDefinitionAndStack<unknown>[];
 export declare const renderEffectChainToCanvas: ({ effects, width, height, source, }: {
     effects: EffectDefinitionAndStack<unknown>[];
-    width?: number | undefined;
-    height?: number | undefined;
-    source?: CanvasImageSource | undefined;
+    width?: number;
+    height?: number;
+    source?: CanvasImageSource;
 }) => Promise<HTMLCanvasElement>;
 export declare const renderEffectChainToBlob: ({ effects, width, height, source, }: {
     effects: EffectDefinitionAndStack<unknown>[];
-    width?: number | undefined;
-    height?: number | undefined;
-    source?: CanvasImageSource | undefined;
+    width?: number;
+    height?: number;
+    source?: CanvasImageSource;
 }) => Promise<Blob>;

package/dist/wave/index.d.ts

@@ -8,5 +8,5 @@ export type WaveParams = {
     readonly wavelength?: number;
 };
 export declare const wave: (params?: (WaveParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/waves.d.ts

@@ -1,87 +1,87 @@
-declare const WAVE_DIRECTIONS: readonly ["horizontal", "vertical"];
+declare const WAVE_DIRECTIONS: readonly ['horizontal', 'vertical'];
 export declare const wavesSchema: {
     readonly colors: {
-        readonly type: "array";
+        readonly type: 'array';
         readonly item: {
-            readonly type: "color";
+            readonly type: 'color';
         };
         readonly default: readonly ["#dff4ff", "#7cc6ff"];
         readonly minLength: 2;
-        readonly newItemDefault: "#ff0000";
-        readonly description: "Colors";
+        readonly newItemDefault: '#ff0000';
+        readonly description: 'Colors';
         readonly keyframable: false;
     };
     readonly direction: {
-        readonly type: "enum";
+        readonly type: 'enum';
         readonly variants: {
             readonly horizontal: {};
             readonly vertical: {};
         };
         readonly default: "horizontal";
-        readonly description: "Direction";
+        readonly description: 'Direction';
     };
     readonly thickness: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0.1;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 40;
-        readonly description: "Thickness";
+        readonly description: 'Thickness';
         readonly hiddenFromList: false;
     };
     readonly gap: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Gap";
+        readonly description: 'Gap';
         readonly hiddenFromList: false;
     };
     readonly angle: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Angle";
+        readonly description: 'Angle';
     };
     readonly offset: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Offset";
+        readonly description: 'Offset';
         readonly hiddenFromList: false;
     };
     readonly amplitude: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 500;
         readonly step: 0.1;
         readonly default: 24;
-        readonly description: "Amplitude";
+        readonly description: 'Amplitude';
         readonly hiddenFromList: false;
     };
     readonly wavelength: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 2000;
         readonly step: 1;
         readonly default: 160;
-        readonly description: "Wavelength";
+        readonly description: 'Wavelength';
         readonly hiddenFromList: false;
     };
     readonly phase: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: -360;
         readonly max: 360;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Phase";
+        readonly description: 'Phase';
         readonly hiddenFromList: false;
     };
     readonly maskToSourceAlpha: {
-        readonly type: "boolean";
+        readonly type: 'boolean';
         readonly default: false;
-        readonly description: "Mask to source alpha";
+        readonly description: 'Mask to source alpha';
     };
 };
 export type WavesDirection = (typeof WAVE_DIRECTIONS)[number];
@@ -108,6 +108,6 @@ export type WavesParams = {
     readonly maskToSourceAlpha?: boolean;
 };
 export declare const waves: (params?: (WavesParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/webgpu-projection-runtime.d.ts

@@ -0,0 +1,24 @@
+export type WebGpuProjectionState = {
+    context: GPUCanvasContext;
+    resources: {
+        device: GPUDevice;
+        pipeline: GPURenderPipeline;
+        uniforms: GPUBuffer;
+        sampler: GPUSampler;
+        texture: GPUTexture;
+        bindGroup: GPUBindGroup;
+        width: number;
+        height: number;
+    } | null;
+};
+export declare const cleanupWebGpuProjection: (state: WebGpuProjectionState) => void;
+export declare const setupWebGpuProjection: (target: HTMLCanvasElement, label: string) => WebGpuProjectionState;
+export declare const applyWebGpuProjection: ({ state, source, width, height, device, shader, uniformData, }: {
+    state: WebGpuProjectionState;
+    source: CanvasImageSource;
+    width: number;
+    height: number;
+    device: GPUDevice;
+    shader: string;
+    uniformData: Float32Array<ArrayBuffer>;
+}) => void;

package/dist/white-balance.d.ts

@@ -5,5 +5,5 @@ export type WhiteBalanceParams = {
     readonly tint?: number;
 };
 export declare const whiteBalance: (params?: (WhiteBalanceParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/white-noise.d.ts

@@ -5,5 +5,5 @@ export type WhiteNoiseParams = {
     readonly seed?: number;
 };
 export declare const whiteNoise: (params?: (WhiteNoiseParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;