@vysmo/transitions 0.1.0

package/dist/transitions/warp-zoom.js

@@ -0,0 +1,70 @@
+import { defineTransition } from "./define.js";
+export const warpZoom = defineTransition({
+    name: "warp-zoom",
+    defaults: {
+        center: [0.5, 0.5],
+        strength: 1.0,
+        rotation: 1.0,
+        blur: 0.02,
+    },
+    glsl: `
+uniform vec2 uCenter;
+uniform float uStrength;
+uniform float uRotation;
+uniform float uBlur;
+
+vec2 warpAround(vec2 uv, vec2 center, float angle, float scale) {
+  vec2 d = uv - center;
+  float c = cos(angle);
+  float s = sin(angle);
+  mat2 rot = mat2(c, -s, s, c);
+  return rot * d / scale + center;
+}
+
+vec4 sampleFromBlurred(vec2 uv, float amount) {
+  if (amount < 0.001) return getFromColor(clamp(uv, 0.0, 1.0));
+  const int N = 5;
+  vec4 sum = vec4(0.0);
+  for (int i = 0; i < N; i++) {
+    float t = (float(i) - 2.0) / 4.0;
+    vec2 offset = (uv - 0.5) * amount * t;
+    sum += getFromColor(clamp(uv + offset, 0.0, 1.0));
+  }
+  return sum / float(N);
+}
+
+vec4 sampleToBlurred(vec2 uv, float amount) {
+  if (amount < 0.001) return getToColor(clamp(uv, 0.0, 1.0));
+  const int N = 5;
+  vec4 sum = vec4(0.0);
+  for (int i = 0; i < N; i++) {
+    float t = (float(i) - 2.0) / 4.0;
+    vec2 offset = (uv - 0.5) * amount * t;
+    sum += getToColor(clamp(uv + offset, 0.0, 1.0));
+  }
+  return sum / float(N);
+}
+
+vec4 transition(vec2 uv) {
+  // From: rotates clockwise + zooms outward (gets bigger, we see less of it)
+  float fromAngle = uProgress * uRotation;
+  float fromScale = 1.0 + uProgress * uStrength;
+
+  // To: rotates counter-clockwise + zooms in (starts big, settles to native)
+  float toAngle = -(1.0 - uProgress) * uRotation;
+  float toScale = 1.0 + (1.0 - uProgress) * uStrength;
+
+  vec2 fromUv = warpAround(uv, uCenter, fromAngle, fromScale);
+  vec2 toUv = warpAround(uv, uCenter, toAngle, toScale);
+
+  // Velocity-scaled radial blur
+  float motion = 4.0 * uProgress * (1.0 - uProgress) * uBlur;
+  vec4 fromColor = sampleFromBlurred(fromUv, motion);
+  vec4 toColor = sampleToBlurred(toUv, motion);
+
+  float mixW = smoothstep(0.3, 0.7, uProgress);
+  return mix(fromColor, toColor, mixW);
+}
+`,
+});
+//# sourceMappingURL=warp-zoom.js.map

package/dist/transitions/warp-zoom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warp-zoom.js","sourceRoot":"","sources":["../../src/transitions/warp-zoom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,QAAQ,GAAG,gBAAgB,CAAC;IACvC,IAAI,EAAE,WAAW;IACjB,QAAQ,EAAE;QACR,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClB,QAAQ,EAAE,GAAG;QACb,QAAQ,EAAE,GAAG;QACb,IAAI,EAAE,IAAI;KACX;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DP;CACA,CAAC,CAAC"}

package/dist/transitions/wave-stripes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Inspired by chungeric's codepen MWQoLqV. The reveal pattern is a
+ * `mod()` modulation of an oblique sine field — which creates curved
+ * stripes following the iso-contours of `cos(x) + 0.8*sin(y)`. A moving
+ * threshold biased along `direction` flips stripes from from→to one by
+ * one. The original used a hard `step()`; we soften with smoothstep to
+ * honor the no-hard-cuts rule while keeping the curved-stripe character.
+ *
+ * `scale` and `softness` are baked-in — they don't expose meaningful
+ * tuning at this scale (single sine field, single stripe period). Only
+ * `direction` is user-tunable.
+ */
+export declare const waveStripes: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly direction: readonly [1, 0];
+}>>;
+//# sourceMappingURL=wave-stripes.d.ts.map

package/dist/transitions/wave-stripes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-stripes.d.ts","sourceRoot":"","sources":["../../src/transitions/wave-stripes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW;;GAwCtB,CAAC"}

package/dist/transitions/wave-stripes.js

@@ -0,0 +1,55 @@
+import { defineTransition } from "./define.js";
+/**
+ * Inspired by chungeric's codepen MWQoLqV. The reveal pattern is a
+ * `mod()` modulation of an oblique sine field — which creates curved
+ * stripes following the iso-contours of `cos(x) + 0.8*sin(y)`. A moving
+ * threshold biased along `direction` flips stripes from from→to one by
+ * one. The original used a hard `step()`; we soften with smoothstep to
+ * honor the no-hard-cuts rule while keeping the curved-stripe character.
+ *
+ * `scale` and `softness` are baked-in — they don't expose meaningful
+ * tuning at this scale (single sine field, single stripe period). Only
+ * `direction` is user-tunable.
+ */
+export const waveStripes = defineTransition({
+    name: "wave-stripes",
+    defaults: {
+        direction: [1, 0],
+    },
+    glsl: `
+uniform vec2 uDirection;
+
+// Snap to nearest axis-aligned unit. The sweep math projects uv onto -d
+// for the threshold bias; diagonals give an out-of-range projection that
+// breaks endpoint correctness. Enforced in-shader so the UI's axis-only
+// picker matches.
+vec2 snapAxis(vec2 v) {
+  vec2 dn = normalize(v);
+  return abs(dn.x) > abs(dn.y) ? vec2(sign(dn.x), 0.0) : vec2(0.0, sign(dn.y));
+}
+
+vec4 transition(vec2 uv) {
+  const float SCALE = 1.0;
+  const float SOFTNESS = 0.003;
+
+  vec2 d = snapAxis(uDirection);
+
+  // Oblique sine field; mod creates stripes following its iso-contours.
+  float field = cos(uv.x * SCALE) + sin(uv.y * SCALE) * 0.8;
+  float stripe = mod(field, 0.05);
+
+  // Threshold sweeps from above-max-stripe to below-zero. Pixels flip
+  // earliest where threshold-bias is lowest, so the reveal travels in
+  // the direction +d. d=[1,0] (default) → bias = uv.x*0.05 → reveal
+  // moves left-to-right, matching the original hardcoded behavior.
+  float proj = dot(uv - vec2(0.5), d) + 0.5;
+  float bias = proj * 0.05;
+  float threshold = (0.05 + 2.0 * SOFTNESS + bias) * (1.0 - uProgress) - SOFTNESS;
+
+  float dMix = smoothstep(threshold - SOFTNESS, threshold + SOFTNESS, stripe);
+
+  return mix(getFromColor(uv), getToColor(uv), dMix);
+}
+`,
+});
+//# sourceMappingURL=wave-stripes.js.map

package/dist/transitions/wave-stripes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-stripes.js","sourceRoot":"","sources":["../../src/transitions/wave-stripes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,gBAAgB,CAAC;IAC1C,IAAI,EAAE,cAAc;IACpB,QAAQ,EAAE;QACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;KAClB;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCP;CACA,CAAC,CAAC"}

package/dist/transitions/wave-wipe.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Direct port of the "wave-wipe" CodePen shader: a directional wipe
+ * whose cut line is distorted by sin(uv.y · π) · wave · p·(1-p), so
+ * the reveal edge S-curves through the frame. to is zoomed slightly
+ * at the start and settles to normal; chromatic aberration on to's
+ * R and B channels jitters via sin(uProgress · 30); and a white-noise
+ * grain rides the same wave envelope.
+ *
+ * Endpoints: every effect rides p·(1-p), which is zero at progress 0
+ * and 1. The wipe saturates (m=0 at p=0, m=1 at p=1), zoom clamps to
+ * 1 at p=1, chroma offsets go to 0, grain goes to 0. Output is
+ * pixel-pure from/to.
+ *
+ * Differs from our existing wipe-directional by the curving cut line
+ * and the bundled cinematic polish (zoom, chroma jitter, grain) all
+ * gated cleanly by a single envelope.
+ */
+export declare const waveWipe: import("../types.js").Transition<import("../types.js").Widen<{
+    readonly wave: 4.5;
+    readonly chroma: 0.03;
+    readonly grain: 0.08;
+}>>;
+//# sourceMappingURL=wave-wipe.d.ts.map

package/dist/transitions/wave-wipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-wipe.d.ts","sourceRoot":"","sources":["../../src/transitions/wave-wipe.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ;;;;GAgEnB,CAAC"}

package/dist/transitions/wave-wipe.js

@@ -0,0 +1,84 @@
+import { defineTransition } from "./define.js";
+/**
+ * Direct port of the "wave-wipe" CodePen shader: a directional wipe
+ * whose cut line is distorted by sin(uv.y · π) · wave · p·(1-p), so
+ * the reveal edge S-curves through the frame. to is zoomed slightly
+ * at the start and settles to normal; chromatic aberration on to's
+ * R and B channels jitters via sin(uProgress · 30); and a white-noise
+ * grain rides the same wave envelope.
+ *
+ * Endpoints: every effect rides p·(1-p), which is zero at progress 0
+ * and 1. The wipe saturates (m=0 at p=0, m=1 at p=1), zoom clamps to
+ * 1 at p=1, chroma offsets go to 0, grain goes to 0. Output is
+ * pixel-pure from/to.
+ *
+ * Differs from our existing wipe-directional by the curving cut line
+ * and the bundled cinematic polish (zoom, chroma jitter, grain) all
+ * gated cleanly by a single envelope.
+ */
+export const waveWipe = defineTransition({
+    name: "wave-wipe",
+    defaults: {
+        wave: 4.5,
+        chroma: 0.03,
+        grain: 0.08,
+    },
+    glsl: `
+uniform float uWave;
+uniform float uChroma;
+uniform float uGrain;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  float waveProgress = uProgress * (1.0 - uProgress);
+
+  // Wave-distorted cut direction. Base is (0, 1) (top-to-bottom wipe);
+  // x-component gets a sin(uv.y · π) wobble so the cut S-curves.
+  vec2 v = vec2(0.0, 1.0);
+  v /= abs(v.x) + abs(v.y);
+  v.x += sin(uv.y * 3.14159265) * uWave * waveProgress;
+
+  float cx = 0.5;
+  float d = v.x * cx + v.y * cx;
+  float smoothness = 0.005;
+  float m = 1.0 - smoothstep(
+    -smoothness, 0.0,
+    v.x * uv.x + v.y * uv.y - (d - 0.5 + uProgress * (1.0 + smoothness))
+  );
+
+  // to zooms in at start (samples a tighter region, appears magnified)
+  // and eases out to normal by progress 1.
+  float zoom = clamp(0.5 + uProgress * 0.5, 0.7, 1.0);
+  vec2 toUV = clamp((uv - 0.5) * zoom + 0.5, 0.0, 1.0);
+
+  // Chromatic aberration jitter on to: R and B sampled with opposite
+  // horizontal offsets, phase riding sin(uProgress · 30) so the
+  // jitter wiggles through the transition.
+  float caPhase = sin(uProgress * 30.0);
+  vec2 displR = vec2(caPhase * waveProgress * -uChroma, 0.0);
+  vec2 displB = vec2(caPhase * waveProgress * uChroma, 0.0);
+
+  vec3 toCol = vec3(
+    getToColor(clamp(toUV + displR, 0.0, 1.0)).r,
+    getToColor(toUV).g,
+    getToColor(clamp(toUV + displB, 0.0, 1.0)).b
+  );
+  vec3 fromCol = getFromColor(uv).rgb;
+
+  // White-noise grain, reseeded in discrete progress frames so
+  // scrubbing reads as film-like jitter. Gated by waveProgress·4 so
+  // endpoints have grain = 0 (peaks 1 at mid-transition).
+  float grainSeed = floor(uProgress * 30.0);
+  float whiteNoise = (hash21(uv + vec2(grainSeed)) * 2.0 - 1.0) *
+                     uGrain * waveProgress * 4.0;
+  vec3 result = mix(fromCol, toCol, m);
+  result *= 1.0 - whiteNoise;
+
+  return vec4(result, 1.0);
+}
+`,
+});
+//# sourceMappingURL=wave-wipe.js.map

package/dist/transitions/wave-wipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-wipe.js","sourceRoot":"","sources":["../../src/transitions/wave-wipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,gBAAgB,CAAC;IACvC,IAAI,EAAE,WAAW;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,GAAG;QACT,MAAM,EAAE,IAAI;QACZ,KAAK,EAAE,IAAI;KACZ;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDP;CACA,CAAC,CAAC"}

package/dist/transitions/wind.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ported from gl-transitions' wind. Per-row random offset creates a ragged,
+ * wind-blown edge sweeping across the frame.
+ */
+export declare const wind: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly size: 0.2;
+    readonly direction: readonly [1, 0];
+}>>;
+//# sourceMappingURL=wind.d.ts.map

package/dist/transitions/wind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind.d.ts","sourceRoot":"","sources":["../../src/transitions/wind.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,IAAI;;;GAyCf,CAAC"}

package/dist/transitions/wind.js

@@ -0,0 +1,48 @@
+import { defineTransition } from "./define.js";
+/**
+ * Ported from gl-transitions' wind. Per-row random offset creates a ragged,
+ * wind-blown edge sweeping across the frame.
+ */
+export const wind = defineTransition({
+    name: "wind",
+    defaults: {
+        size: 0.2,
+        direction: [1, 0],
+    },
+    glsl: `
+uniform float uSize;
+uniform vec2 uDirection;
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  vec2 d = normalize(uDirection);
+  // Perpendicular coordinate: one random value per "row" along the direction.
+  vec2 perp = vec2(-d.y, d.x);
+  float rowCoord = dot(uv, perp);
+  float r = hash(vec2(rowCoord, 0.0));
+
+  // Projected position along direction, normalized to [0, 1] regardless
+  // of direction (axis-aligned or diagonal). See paint-bleed.ts.
+  float maxProj = max((abs(d.x) + abs(d.y)) * 0.5, 0.0001);
+  float projected = 0.5 + dot(uv - 0.5, -d) / (2.0 * maxProj);
+
+  // size is a fractional ratio in [0, 1]: how much per-row jitter the
+  // wavefront has. Values >1 break endpoint correctness because the
+  // smoothstep range no longer covers the projected coordinate at p=0 or
+  // p=1, leaving per-row stripes visible. Clamp here so the transition
+  // is reliable regardless of caller input.
+  float size = clamp(uSize, 0.0, 1.0);
+
+  // Wavefront sweeps from 0 to 1 + size. Per-row random shift gives ragged edge.
+  // Note: smoothstep(edge0, edge1, x) is undefined when edge0 > edge1, so
+  // express the inverted form as 1 - smoothstep(low, high, x) instead.
+  float arg = projected * (1.0 - size) + size * r - uProgress * (1.0 + size);
+  float m = 1.0 - smoothstep(-size, 0.0, arg);
+  return mix(getFromColor(uv), getToColor(uv), m);
+}
+`,
+});
+//# sourceMappingURL=wind.js.map

package/dist/transitions/wind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind.js","sourceRoot":"","sources":["../../src/transitions/wind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,gBAAgB,CAAC;IACnC,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,GAAG;QACT,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;KAClB;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCP;CACA,CAAC,CAAC"}

package/dist/transitions/window-slice.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Vertical slice curtain: the frame is partitioned into N vertical strips
+ * which open one after another (left-to-right by default), each strip
+ * itself revealing top-to-bottom. Distinct from kinetic-bands (which
+ * uses staggered horizontal bands) and from a simple wipe.
+ */
+export declare const windowSlice: import("../types.js").Transition<import("../types.js").Widen<{
+    readonly count: 12;
+    readonly stagger: 0.6;
+}>>;
+//# sourceMappingURL=window-slice.d.ts.map

package/dist/transitions/window-slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-slice.d.ts","sourceRoot":"","sources":["../../src/transitions/window-slice.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;GAyBtB,CAAC"}

package/dist/transitions/window-slice.js

@@ -0,0 +1,34 @@
+import { defineTransition } from "./define.js";
+/**
+ * Vertical slice curtain: the frame is partitioned into N vertical strips
+ * which open one after another (left-to-right by default), each strip
+ * itself revealing top-to-bottom. Distinct from kinetic-bands (which
+ * uses staggered horizontal bands) and from a simple wipe.
+ */
+export const windowSlice = defineTransition({
+    name: "window-slice",
+    defaults: {
+        count: 12,
+        stagger: 0.6,
+    },
+    glsl: `
+uniform float uCount;
+uniform float uStagger;
+
+vec4 transition(vec2 uv) {
+  float sliceI = floor(uv.x * uCount);
+  // Linear left-to-right sweep across slices.
+  float sliceProg = sliceI / max(uCount - 1.0, 1.0);
+  float start = sliceProg * uStagger;
+  float window = max(1.0 - uStagger, 0.0001);
+  float localP = clamp((uProgress - start) / window, 0.0, 1.0);
+
+  // Each slice opens top-to-bottom: at localP=0 nothing revealed,
+  // localP=1 fully revealed.
+  float reveal = smoothstep(0.0, 1.0, localP * 2.0 - uv.y);
+
+  return mix(getFromColor(uv), getToColor(uv), reveal);
+}
+`,
+});
+//# sourceMappingURL=window-slice.js.map

package/dist/transitions/window-slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-slice.js","sourceRoot":"","sources":["../../src/transitions/window-slice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,gBAAgB,CAAC;IAC1C,IAAI,EAAE,cAAc;IACpB,QAAQ,EAAE;QACR,KAAK,EAAE,EAAE;QACT,OAAO,EAAE,GAAG;KACb;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;CAkBP;CACA,CAAC,CAAC"}

package/dist/transitions/wipe-directional.d.ts

@@ -0,0 +1,5 @@
+export declare const wipeDirectional: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly angle: 0;
+    readonly softness: 0.05;
+}>>;
+//# sourceMappingURL=wipe-directional.d.ts.map

package/dist/transitions/wipe-directional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipe-directional.d.ts","sourceRoot":"","sources":["../../src/transitions/wipe-directional.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;GAuB1B,CAAC"}

package/dist/transitions/wipe-directional.js

@@ -0,0 +1,26 @@
+import { defineTransition } from "./define.js";
+export const wipeDirectional = defineTransition({
+    name: "wipe-directional",
+    defaults: {
+        angle: 0,
+        softness: 0.05,
+    },
+    glsl: `
+uniform float uAngle;
+uniform float uSoftness;
+
+vec4 transition(vec2 uv) {
+  vec2 dir = vec2(cos(uAngle), sin(uAngle));
+  // Normalize the projection by max |dot(uv-0.5, dir)| = (|dx|+|dy|)/2 so
+  // gradient ∈ [0, 1] for any angle (axis-aligned or diagonal). Without
+  // this, diagonal angles leave corner slivers of the previous image at
+  // progress=1.
+  float maxProj = max((abs(dir.x) + abs(dir.y)) * 0.5, 0.0001);
+  float p = 0.5 + dot(uv - 0.5, dir) / (2.0 * maxProj);
+  float reveal = uProgress * (1.0 + uSoftness);
+  float m = smoothstep(reveal - uSoftness, reveal, p);
+  return mix(getToColor(uv), getFromColor(uv), m);
+}
+`,
+});
+//# sourceMappingURL=wipe-directional.js.map

package/dist/transitions/wipe-directional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipe-directional.js","sourceRoot":"","sources":["../../src/transitions/wipe-directional.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC;IAC9C,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE;QACR,KAAK,EAAE,CAAC;QACR,QAAQ,EAAE,IAAI;KACf;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;CAgBP;CACA,CAAC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+import type { TextureSource, UniformValue, UniformParams, Widen } from "@vysmo/gl-core";
+export type { TextureSource, UniformValue, UniformParams, Widen };
+export interface TransitionShader {
+    glsl: string;
+    /**
+     * Full vertex-shader main() body. Required when the transition declares
+     * a `mesh`. Runner prepends a header with `#version 300 es`, precision,
+     * standard uniforms (uProgress, uResolution, uPass, uPassCount,
+     * uInstances, plus author's custom uniforms), the standard attribute
+     * inputs (aPosition, aUv, aOffset, aCentroid, aBary, aRandom), and
+     * `out vec2 vUv`. The author writes `void main() { ... }` and is
+     * responsible for assigning `gl_Position` and passing through `vUv`
+     * (and any other varyings they declare themselves).
+     */
+    vertex?: string;
+    wgsl?: string;
+}
+export interface MeshGeometry {
+    /**
+     * Grid subdivisions of the [-1, 1] plane. `[nx, ny]` yields `2·nx·ny`
+     * triangles.
+     */
+    subdivisions: readonly [number, number];
+    /**
+     * Number of mesh instances rendered per pass via drawArraysInstanced.
+     * The vertex shader can branch on `gl_InstanceID` (0..instances-1) to
+     * produce overlapping meshes with different behaviours (e.g. a back
+     * plane + a rotating foreground). Defaults to 1.
+     */
+    instances?: number;
+}
+export interface Transition<P extends UniformParams = UniformParams> {
+    name: string;
+    shader: TransitionShader;
+    defaults: P;
+    /**
+     * Number of fragment-shader passes the runner should execute per
+     * render(). Defaults to 1. When > 1, the runner ping-pongs between
+     * two framebuffers; each pass can read the previous pass's output
+     * via getPrevious(uv). The final pass renders to the canvas.
+     *
+     * Ignored when `mesh` is set (mesh transitions are single-pass in v1).
+     */
+    passes?: number;
+    /**
+     * If set, the runner renders this transition with a subdivided-plane
+     * mesh and the author-provided vertex shader, enabling true vertex
+     * geometry effects (per-triangle rotation, flying tiles, real 3D
+     * flips). Transitions without `mesh` keep using the fullscreen-triangle
+     * fragment-only pipeline.
+     */
+    mesh?: MeshGeometry;
+}
+export interface RenderArgs<P extends UniformParams> {
+    from: TextureSource;
+    to: TextureSource;
+    progress: number;
+    params?: Partial<P>;
+    /**
+     * Optional displacement-map texture. Transitions that read it via the
+     * `getDisplacement(uv)` shader helper (e.g. flow-warp) will use it to
+     * drive per-pixel UV offsets. Mid-gray (RGB ≈ 128) is interpreted as
+     * "no displacement"; brighter / darker pixels offset positively /
+     * negatively. If omitted, the runner binds a default 1×1 mid-gray
+     * texture so displacement-using transitions degrade to no-op rather
+     * than failing.
+     */
+    displacement?: TextureSource;
+    /**
+     * Optional environment-map texture. Transitions that read it via the
+     * getEnvironment(uv) shader helper (e.g. liquid-chrome with reflection
+     * enabled) use it to fake reflections off metallic / glass surfaces.
+     * If omitted, the runner binds a default 1×1 mid-gray texture so
+     * environment-using transitions degrade to a neutral no-op.
+     */
+    environment?: TextureSource;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,KAAK,EACN,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;AAElE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,CAAC,CAAC;IACZ;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,aAAa;IACjD,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,aAAa,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC;CAC7B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@vysmo/transitions",
+  "version": "0.1.0",
+  "description": "60 WebGL2 transition shaders, defined as plain data. Mesh-based, tree-shakable to the byte, endpoint-correct by construction. Drives canvas, image, and video sources via one Runner.",
+  "license": "MIT",
+  "keywords": [
+    "webgl",
+    "webgl2",
+    "transitions",
+    "video",
+    "canvas",
+    "shader",
+    "glsl",
+    "animation",
+    "mesh",
+    "page-curl",
+    "tree-shakable",
+    "headless"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@vysmo/gl-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@vitest/browser": "^3.2.4",
+    "esbuild": "^0.28.0",
+    "playwright": "^1.59.1",
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run && vitest run --config vitest.ssr.config.ts",
+    "test:browser": "vitest run",
+    "test:ssr": "vitest run --config vitest.ssr.config.ts",
+    "test:watch": "vitest",
+    "size": "node scripts/check-bundle-size.mjs"
+  }
+}