@vysmo/transitions 0.1.0

package/dist/transitions/bloom-reveal.js

@@ -0,0 +1,106 @@
+import { defineTransition } from "./define.js";
+/**
+ * Multi-pass transition. As a noise-masked reveal of to emerges, its
+ * bright highlights bloom outward with big cinematic halos impossible
+ * in a single pass — the blur radius grows to ~32 pixels via five
+ * doubling-step iterations (1, 2, 4, 8, 16 px), which would need
+ * ~65² samples single-pass.
+ *
+ *   pass 0               — extract to-highlights gated by the reveal
+ *                          mask AND a 4·p·(1-p) envelope that zeroes
+ *                          at both endpoints.
+ *   pass 1..passCount-2  — expanding-step 9-tap box blur, doubling
+ *                          radius each iteration.
+ *   final pass           — composite: base = mix(from, to, mask), then
+ *                          add the blurred bloom scaled by intensity.
+ *
+ * Endpoints: the bloom envelope is zero at progress 0 and 1, so all
+ * intermediate passes carry zeros and the composite is pure from/to.
+ * Noise is remapped to [softness+safety, 1-softness-safety] so the
+ * reveal-mask smoothstep saturates cleanly at progress 0 and 1.
+ */
+export const bloomReveal = defineTransition({
+    name: "bloom-reveal",
+    passes: 7,
+    defaults: {
+        scale: 5,
+        softness: 0.08,
+        threshold: 0.55,
+        intensity: 3.0,
+    },
+    glsl: `
+uniform float uScale;
+uniform float uSoftness;
+uniform float uThreshold;
+uniform float uIntensity;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+float valNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+float fbm(vec2 p) {
+  return valNoise(p) * 0.55 +
+         valNoise(p * 2.1) * 0.28 +
+         valNoise(p * 4.3) * 0.17;
+}
+
+float revealMask(vec2 uv) {
+  // Safe noise bounds guarantee the mask smoothstep saturates to 0 at
+  // progress=0 and 1 at progress=1 regardless of where the noise lands.
+  float safeLow = uSoftness + 0.005;
+  float safeHigh = 1.0 - uSoftness - 0.005;
+  float n = mix(safeLow, safeHigh, clamp(fbm(uv * uScale), 0.0, 1.0));
+  return smoothstep(n - uSoftness, n + uSoftness, uProgress);
+}
+
+vec4 transition(vec2 uv) {
+  // Final pass: composite bloom on top of the from→to reveal.
+  if (uPass == uPassCount - 1) {
+    vec3 bloom = getPrevious(uv).rgb;
+    float mask = revealMask(uv);
+    vec3 base = mix(getFromColor(uv).rgb, getToColor(uv).rgb, mask);
+    return vec4(base + bloom * uIntensity, 1.0);
+  }
+
+  // Seed: bloom contribution = to_color * (brightness_mask) * reveal
+  // * envelope. Envelope vanishes at progress 0/1 → clean endpoints.
+  if (uPass == 0) {
+    float mask = revealMask(uv);
+    vec3 toColor = getToColor(uv).rgb;
+    float lum = dot(toColor, vec3(0.299, 0.587, 0.114));
+    float brightness = smoothstep(uThreshold - 0.1, uThreshold + 0.1, lum);
+    float envelope = 4.0 * uProgress * (1.0 - uProgress);
+    vec3 bloom = toColor * brightness * mask * envelope;
+    return vec4(bloom, 1.0);
+  }
+
+  // Blur: 9-tap box blur with an expanding step so the effective
+  // radius doubles each pass. After 5 blur passes, reach is ~32 px.
+  float step = pow(2.0, float(uPass - 1));
+  vec2 px = vec2(step) / uResolution;
+  vec3 sum = vec3(0.0);
+  sum += getPrevious(uv + vec2(-px.x, -px.y)).rgb;
+  sum += getPrevious(uv + vec2(0.0, -px.y)).rgb;
+  sum += getPrevious(uv + vec2(px.x, -px.y)).rgb;
+  sum += getPrevious(uv + vec2(-px.x, 0.0)).rgb;
+  sum += getPrevious(uv).rgb;
+  sum += getPrevious(uv + vec2(px.x, 0.0)).rgb;
+  sum += getPrevious(uv + vec2(-px.x, px.y)).rgb;
+  sum += getPrevious(uv + vec2(0.0, px.y)).rgb;
+  sum += getPrevious(uv + vec2(px.x, px.y)).rgb;
+  return vec4(sum / 9.0, 1.0);
+}
+`,
+});
+//# sourceMappingURL=bloom-reveal.js.map

package/dist/transitions/bloom-reveal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom-reveal.js","sourceRoot":"","sources":["../../src/transitions/bloom-reveal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,gBAAgB,CAAC;IAC1C,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,CAAC;IACT,QAAQ,EAAE;QACR,KAAK,EAAE,CAAC;QACR,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,GAAG;KACf;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEP;CACA,CAAC,CAAC"}

package/dist/transitions/chromatic-pulse.d.ts

@@ -0,0 +1,4 @@
+export declare const chromaticPulse: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly intensity: 0.6;
+}>>;
+//# sourceMappingURL=chromatic-pulse.d.ts.map

package/dist/transitions/chromatic-pulse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chromatic-pulse.d.ts","sourceRoot":"","sources":["../../src/transitions/chromatic-pulse.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;GAqCzB,CAAC"}

package/dist/transitions/chromatic-pulse.js

@@ -0,0 +1,40 @@
+import { defineTransition } from "./define.js";
+export const chromaticPulse = defineTransition({
+    name: "chromatic-pulse",
+    defaults: {
+        intensity: 0.6,
+    },
+    glsl: `
+uniform float uIntensity;
+
+vec4 transition(vec2 uv) {
+  // Envelope peaks at midpoint, zero at endpoints.
+  float env = 4.0 * uProgress * (1.0 - uProgress);
+  float aberration = env * uIntensity * 0.03;
+
+  // Radial direction from center → outward chromatic shift feels lens-like.
+  vec2 toCenter = uv - 0.5;
+  float r = length(toCenter);
+  vec2 dir = r > 0.0001 ? toCenter / r : vec2(1.0, 0.0);
+
+  vec2 offR = clamp(uv + dir * aberration, 0.0, 1.0);
+  vec2 offG = uv;
+  vec2 offB = clamp(uv - dir * aberration, 0.0, 1.0);
+
+  vec3 fromRGB = vec3(
+    getFromColor(offR).r,
+    getFromColor(offG).g,
+    getFromColor(offB).b
+  );
+  vec3 toRGB = vec3(
+    getToColor(offR).r,
+    getToColor(offG).g,
+    getToColor(offB).b
+  );
+
+  float mixW = smoothstep(0.3, 0.7, uProgress);
+  return vec4(mix(fromRGB, toRGB, mixW), 1.0);
+}
+`,
+});
+//# sourceMappingURL=chromatic-pulse.js.map

package/dist/transitions/chromatic-pulse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chromatic-pulse.js","sourceRoot":"","sources":["../../src/transitions/chromatic-pulse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,cAAc,GAAG,gBAAgB,CAAC;IAC7C,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE;QACR,SAAS,EAAE,GAAG;KACf;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BP;CACA,CAAC,CAAC"}

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

@@ -0,0 +1,6 @@
+export declare const clockWipe: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly startAngle: -1.5707963;
+    readonly direction: 1;
+    readonly softness: 0.02;
+}>>;
+//# sourceMappingURL=clock-wipe.d.ts.map

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

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

package/dist/transitions/clock-wipe.js

@@ -0,0 +1,33 @@
+import { defineTransition } from "./define.js";
+export const clockWipe = defineTransition({
+    name: "clock-wipe",
+    defaults: {
+        startAngle: -1.5707963, // -π/2 (12 o'clock)
+        direction: 1, // +1 clockwise, -1 counter-clockwise
+        softness: 0.02,
+    },
+    glsl: `
+uniform float uStartAngle;
+uniform float uDirection;
+uniform float uSoftness;
+
+const float TWO_PI = 6.2831853;
+
+vec4 transition(vec2 uv) {
+  vec2 delta = uv - vec2(0.5);
+  // Aspect-correct so the sweep stays angularly uniform on non-square canvases.
+  vec2 aspectDelta = delta * vec2(uResolution.x / uResolution.y, 1.0);
+
+  float angle = atan(aspectDelta.y, aspectDelta.x);
+  float sweep = mod(uDirection * (angle - uStartAngle), TWO_PI);
+
+  // Threshold extends beyond [0, 2π] by the softness on each side so the
+  // feather zone is outside the visible sweep range at the endpoints.
+  float threshold = uProgress * (TWO_PI + 2.0 * uSoftness) - uSoftness;
+  float w = smoothstep(threshold - uSoftness, threshold + uSoftness, sweep);
+
+  return mix(getToColor(uv), getFromColor(uv), w);
+}
+`,
+});
+//# sourceMappingURL=clock-wipe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clock-wipe.js","sourceRoot":"","sources":["../../src/transitions/clock-wipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAC;IACxC,IAAI,EAAE,YAAY;IAClB,QAAQ,EAAE;QACR,UAAU,EAAE,CAAC,SAAS,EAAE,oBAAoB;QAC5C,SAAS,EAAE,CAAC,EAAE,qCAAqC;QACnD,QAAQ,EAAE,IAAI;KACf;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;CAsBP;CACA,CAAC,CAAC"}

package/dist/transitions/color-phase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Port of gl-transitions' ColorPhase. Each color channel transitions on its
+ * own sub-range of progress via smoothstep, giving a phased spectrum-shift
+ * reveal (red fades early, green middle, blue late, for the defaults).
+ */
+export declare const colorPhase: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly fromStep: readonly [0, 0.2, 0.4, 0];
+    readonly toStep: readonly [0.6, 0.8, 1, 1];
+}>>;
+//# sourceMappingURL=color-phase.d.ts.map

package/dist/transitions/color-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-phase.d.ts","sourceRoot":"","sources":["../../src/transitions/color-phase.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;GAgBrB,CAAC"}

package/dist/transitions/color-phase.js

@@ -0,0 +1,24 @@
+import { defineTransition } from "./define.js";
+/**
+ * Port of gl-transitions' ColorPhase. Each color channel transitions on its
+ * own sub-range of progress via smoothstep, giving a phased spectrum-shift
+ * reveal (red fades early, green middle, blue late, for the defaults).
+ */
+export const colorPhase = defineTransition({
+    name: "color-phase",
+    defaults: {
+        fromStep: [0.0, 0.2, 0.4, 0.0],
+        toStep: [0.6, 0.8, 1.0, 1.0],
+    },
+    glsl: `
+uniform vec4 uFromStep;
+uniform vec4 uToStep;
+
+vec4 transition(vec2 uv) {
+  vec4 a = getFromColor(uv);
+  vec4 b = getToColor(uv);
+  return mix(a, b, smoothstep(uFromStep, uToStep, vec4(uProgress)));
+}
+`,
+});
+//# sourceMappingURL=color-phase.js.map

package/dist/transitions/color-phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-phase.js","sourceRoot":"","sources":["../../src/transitions/color-phase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC;IACzC,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE;QACR,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;QAC9B,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;KAC7B;IACD,IAAI,EAAE;;;;;;;;;CASP;CACA,CAAC,CAAC"}

package/dist/transitions/colour-distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colour-distance.d.ts","sourceRoot":"","sources":["../../src/transitions/colour-distance.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;GAyBzB,CAAC"}

package/dist/transitions/cross-warp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-warp.d.ts","sourceRoot":"","sources":["../../src/transitions/cross-warp.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;GAyBpB,CAAC"}

package/dist/transitions/cross-zoom.d.ts

@@ -0,0 +1,5 @@
+export declare const crossZoom: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly strength: 1.2;
+    readonly blur: 0.04;
+}>>;
+//# sourceMappingURL=cross-zoom.d.ts.map

package/dist/transitions/cross-zoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-zoom.d.ts","sourceRoot":"","sources":["../../src/transitions/cross-zoom.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;GAwDpB,CAAC"}

package/dist/transitions/cross-zoom.js

@@ -0,0 +1,59 @@
+import { defineTransition } from "./define.js";
+export const crossZoom = defineTransition({
+    name: "cross-zoom",
+    defaults: {
+        strength: 1.2,
+        blur: 0.04,
+    },
+    glsl: `
+uniform float uStrength;
+uniform float uBlur;
+
+vec2 zoomUv(vec2 uv, float scale) {
+  return (uv - 0.5) / scale + 0.5;
+}
+
+vec4 sampleFromBlurred(vec2 uv, float amount) {
+  if (amount < 0.001) return getFromColor(uv);
+  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(uv + offset);
+  }
+  return sum / float(N);
+}
+
+vec4 sampleToBlurred(vec2 uv, float amount) {
+  if (amount < 0.001) return getToColor(uv);
+  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(uv + offset);
+  }
+  return sum / float(N);
+}
+
+vec4 transition(vec2 uv) {
+  float fromScale = 1.0 + uProgress * uStrength;
+  float toScale = 1.0 + (1.0 - uProgress) * uStrength;
+
+  vec2 fromUv = zoomUv(uv, fromScale);
+  vec2 toUv = zoomUv(uv, toScale);
+
+  // Velocity-scaled radial blur (peak at midpoint, zero at endpoints).
+  float motion = 4.0 * uProgress * (1.0 - uProgress) * uBlur;
+
+  vec4 fromColor = sampleFromBlurred(fromUv, motion);
+  vec4 toColor = sampleToBlurred(toUv, motion);
+
+  // Crossfade concentrated in the middle 40% of the transition.
+  float mixW = smoothstep(0.3, 0.7, uProgress);
+  return mix(fromColor, toColor, mixW);
+}
+`,
+});
+//# sourceMappingURL=cross-zoom.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cross-zoom.js","sourceRoot":"","sources":["../../src/transitions/cross-zoom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAC;IACxC,IAAI,EAAE,YAAY;IAClB,QAAQ,EAAE;QACR,QAAQ,EAAE,GAAG;QACb,IAAI,EAAE,IAAI;KACX;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDP;CACA,CAAC,CAAC"}

package/dist/transitions/crosshatch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Port of gl-transitions' CrossHatch. Pixels reveal based on an outer
+ * radial wave from `center` combined with per-row and per-column random
+ * thresholds, producing a sketchy hand-drawn crosshatch reveal. Outer
+ * smoothstep envelopes guarantee pixel-pure endpoints.
+ */
+export declare const crosshatch: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly center: readonly [0.5, 0.5];
+    readonly threshold: 3;
+    readonly fadeEdge: 0.1;
+}>>;
+//# sourceMappingURL=crosshatch.d.ts.map

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

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

package/dist/transitions/crosshatch.js

@@ -0,0 +1,49 @@
+import { defineTransition } from "./define.js";
+/**
+ * Port of gl-transitions' CrossHatch. Pixels reveal based on an outer
+ * radial wave from `center` combined with per-row and per-column random
+ * thresholds, producing a sketchy hand-drawn crosshatch reveal. Outer
+ * smoothstep envelopes guarantee pixel-pure endpoints.
+ */
+export const crosshatch = defineTransition({
+    name: "crosshatch",
+    defaults: {
+        center: [0.5, 0.5],
+        threshold: 3,
+        fadeEdge: 0.1,
+    },
+    glsl: `
+uniform vec2 uCenter;
+uniform float uThreshold;
+uniform float uFadeEdge;
+
+float rand(vec2 co) {
+  return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  // Below threshold=3 the radial wave doesn't have enough range to cover
+  // the full canvas before the outer fade-edge envelope kicks in, leaving
+  // patchy unrevealed pixels mid-transition that snap to revealed at the
+  // end. Clamp here so the transition is reliable regardless of caller input.
+  float threshold = max(uThreshold, 3.0);
+  float dist = distance(uCenter, uv) / threshold;
+  float r = uProgress - min(rand(vec2(uv.y, 0.0)), rand(vec2(0.0, uv.x)));
+
+  float feather = 0.02;
+  float inner = smoothstep(dist - feather, dist + feather, r);
+
+  // Outer mix structure (from gl-transitions): no reveal until uFadeEdge,
+  // forced full reveal in last uFadeEdge of progress — guarantees clean
+  // endpoints regardless of the random threshold's noisiness.
+  float w = mix(
+    0.0,
+    mix(inner, 1.0, smoothstep(1.0 - uFadeEdge, 1.0, uProgress)),
+    smoothstep(0.0, uFadeEdge, uProgress)
+  );
+
+  return mix(getFromColor(uv), getToColor(uv), w);
+}
+`,
+});
+//# sourceMappingURL=crosshatch.js.map

package/dist/transitions/crosshatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crosshatch.js","sourceRoot":"","sources":["../../src/transitions/crosshatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC;IACzC,IAAI,EAAE,YAAY;IAClB,QAAQ,EAAE;QACR,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClB,SAAS,EAAE,CAAC;QACZ,QAAQ,EAAE,GAAG;KACd;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCP;CACA,CAAC,CAAC"}

package/dist/transitions/define.d.ts

@@ -0,0 +1,35 @@
+import type { MeshGeometry, Transition, UniformParams, Widen } from "../types.js";
+export interface DefineTransitionSpec<P extends UniformParams> {
+    name: string;
+    glsl: string;
+    /**
+     * Full vertex-shader main(). Required when `mesh` is set. See
+     * TransitionShader.vertex for shell details.
+     */
+    vertex?: string;
+    wgsl?: string;
+    defaults: P;
+    passes?: number;
+    mesh?: MeshGeometry;
+}
+/**
+ * Build a `Transition` from a plain spec. Authors write a fragment-shader
+ * `vec4 transition(vec2 uv) { … }` body and a `defaults` object of named
+ * uniforms; the Runner wraps it with the standard headers (`#version
+ * 300 es`, precision, `uFrom` / `uTo` / `uProgress` / `uResolution`,
+ * sampler helpers `getFromColor` / `getToColor`) and maps each key in
+ * `defaults` to a `u<PascalCase>` uniform via the runner's binding rule.
+ *
+ * Mesh transitions add a `vertex` shader body and a `mesh` geometry
+ * descriptor; multi-pass transitions add `passes`.
+ *
+ * The returned object is a plain `Transition<Widen<P>>` — the `Widen`
+ * step lifts literal default tuples (e.g. `readonly [-1, 0]`) back to
+ * the general uniform tuple types so callers can override freely.
+ *
+ * Per the project's engineering invariants, every defined transition
+ * must clear the endpoint-correctness, polish-degrades-at-endpoints,
+ * no-hard-cuts, full-frame, and continuous-motion rules.
+ */
+export declare function defineTransition<const P extends UniformParams>(spec: DefineTransitionSpec<P>): Transition<Widen<P>>;
+//# sourceMappingURL=define.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/transitions/define.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EAEV,aAAa,EACb,KAAK,EACN,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,aAAa;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,aAAa,EAC5D,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC5B,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAYtB"}

package/dist/transitions/define.js

@@ -0,0 +1,37 @@
+/**
+ * Build a `Transition` from a plain spec. Authors write a fragment-shader
+ * `vec4 transition(vec2 uv) { … }` body and a `defaults` object of named
+ * uniforms; the Runner wraps it with the standard headers (`#version
+ * 300 es`, precision, `uFrom` / `uTo` / `uProgress` / `uResolution`,
+ * sampler helpers `getFromColor` / `getToColor`) and maps each key in
+ * `defaults` to a `u<PascalCase>` uniform via the runner's binding rule.
+ *
+ * Mesh transitions add a `vertex` shader body and a `mesh` geometry
+ * descriptor; multi-pass transitions add `passes`.
+ *
+ * The returned object is a plain `Transition<Widen<P>>` — the `Widen`
+ * step lifts literal default tuples (e.g. `readonly [-1, 0]`) back to
+ * the general uniform tuple types so callers can override freely.
+ *
+ * Per the project's engineering invariants, every defined transition
+ * must clear the endpoint-correctness, polish-degrades-at-endpoints,
+ * no-hard-cuts, full-frame, and continuous-motion rules.
+ */
+export function defineTransition(spec) {
+    const shader = { glsl: spec.glsl };
+    if (spec.vertex !== undefined)
+        shader.vertex = spec.vertex;
+    if (spec.wgsl !== undefined)
+        shader.wgsl = spec.wgsl;
+    const t = {
+        name: spec.name,
+        shader,
+        defaults: spec.defaults,
+    };
+    if (spec.passes !== undefined)
+        t.passes = spec.passes;
+    if (spec.mesh !== undefined)
+        t.mesh = spec.mesh;
+    return t;
+}
+//# sourceMappingURL=define.js.map

package/dist/transitions/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/transitions/define.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAA6B;IAE7B,MAAM,MAAM,GAAqB,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IACrD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;QAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3D,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACrD,MAAM,CAAC,GAAyB;QAC9B,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM;QACN,QAAQ,EAAE,IAAI,CAAC,QAA+B;KAC/C,CAAC;IACF,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;QAAE,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IACtD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IAChD,OAAO,CAAC,CAAC;AACX,CAAC"}

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

@@ -0,0 +1,14 @@
+/**
+ * Linear film-burn sibling: a warm-glowing fire line advances across the
+ * frame from one edge, like a sparkler running along a fuse. Distinct
+ * from light-leak (smooth colored band passing through) — this is a
+ * state-change front: unburned ahead, reveal behind, hot glow ON the
+ * line.
+ */
+export declare const directionalBurn: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly direction: readonly [1, 0];
+    readonly scale: 10;
+    readonly edgeWidth: 0.035;
+    readonly flameColor: readonly [1.6, 0.7, 0.15];
+}>>;
+//# sourceMappingURL=directional-burn.d.ts.map

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

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

package/dist/transitions/directional-burn.js

@@ -0,0 +1,67 @@
+import { defineTransition } from "./define.js";
+/**
+ * Linear film-burn sibling: a warm-glowing fire line advances across the
+ * frame from one edge, like a sparkler running along a fuse. Distinct
+ * from light-leak (smooth colored band passing through) — this is a
+ * state-change front: unburned ahead, reveal behind, hot glow ON the
+ * line.
+ */
+export const directionalBurn = defineTransition({
+    name: "directional-burn",
+    defaults: {
+        direction: [1, 0],
+        scale: 10,
+        edgeWidth: 0.035,
+        flameColor: [1.6, 0.7, 0.15],
+    },
+    glsl: `
+uniform vec2 uDirection;
+uniform float uScale;
+uniform float uEdgeWidth;
+uniform vec3 uFlameColor;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+float valueNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+vec4 transition(vec2 uv) {
+  vec2 d = normalize(uDirection);
+  float projected = dot(uv - 0.5, -d);
+  // Max projection magnitude for any uv in [0,1]^2 given this direction;
+  // L1 formula that works for axis-aligned and diagonal directions alike.
+  float maxProj = 0.5 * (abs(d.x) + abs(d.y));
+
+  float noiseStrength = 0.06;
+  float n = valueNoise(uv * uScale);
+  float perturbed = projected - (n - 0.5) * noiseStrength;
+
+  float totalEdge = uEdgeWidth + noiseStrength * 0.5;
+  float boundary = (maxProj + totalEdge) * (1.0 - 2.0 * uProgress);
+  float signedDist = perturbed - boundary;
+
+  // Behind the front: reveal "to". Ahead: still "from".
+  float w = smoothstep(-uEdgeWidth, uEdgeWidth, signedDist);
+  vec4 base = mix(getFromColor(uv), getToColor(uv), w);
+
+  // Tight flame band centered on the front, env-gated to zero at endpoints.
+  float bandX = signedDist / max(uEdgeWidth * 1.3, 0.0001);
+  float flameBand = exp(-bandX * bandX * 3.5);
+  float env = 4.0 * uProgress * (1.0 - uProgress);
+  vec3 flame = uFlameColor * flameBand * env;
+
+  return vec4(base.rgb + flame, base.a);
+}
+`,
+});
+//# sourceMappingURL=directional-burn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directional-burn.js","sourceRoot":"","sources":["../../src/transitions/directional-burn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC;IAC9C,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE;QACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACjB,KAAK,EAAE,EAAE;QACT,SAAS,EAAE,KAAK;QAChB,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC;KAC7B;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDP;CACA,CAAC,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * Ported from gl-transitions' directionalwarp. Uses L1-normalized direction
+ * so the wavefront covers the full image regardless of direction, and a
+ * shrink-to-center sampling that never needs to clamp outside [0,1] — so
+ * there are no stretched edge artifacts (the "bars" a naive displacement
+ * approach produces).
+ */
+export declare const directionalWarp: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly direction: readonly [-1, 1];
+    readonly smoothness: 0.5;
+}>>;
+//# sourceMappingURL=directional-warp.d.ts.map

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

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

package/dist/transitions/directional-warp.js

@@ -0,0 +1,46 @@
+import { defineTransition } from "./define.js";
+/**
+ * Ported from gl-transitions' directionalwarp. Uses L1-normalized direction
+ * so the wavefront covers the full image regardless of direction, and a
+ * shrink-to-center sampling that never needs to clamp outside [0,1] — so
+ * there are no stretched edge artifacts (the "bars" a naive displacement
+ * approach produces).
+ */
+export const directionalWarp = defineTransition({
+    name: "directional-warp",
+    defaults: {
+        direction: [-1, 1],
+        smoothness: 0.5,
+    },
+    glsl: `
+uniform vec2 uDirection;
+uniform float uSmoothness;
+
+vec4 transition(vec2 uv) {
+  // L1 normalization: ensures the projection v.x*uv.x + v.y*uv.y covers a
+  // range of length 1 regardless of direction.
+  vec2 v = uDirection;
+  float l = abs(v.x) + abs(v.y);
+  if (l < 0.0001) v = vec2(1.0, 0.0);
+  else v = v / l;
+
+  vec2 center = vec2(0.5);
+  float d = v.x * center.x + v.y * center.y;
+
+  float m = 1.0 - smoothstep(
+    -uSmoothness,
+    0.0,
+    v.x * uv.x + v.y * uv.y - (d - 0.5 + uProgress * (1.0 + uSmoothness))
+  );
+
+  // Shrink-to-center sampling: fromUv shrinks toward center as m grows,
+  // toUv grows out from center. UVs stay in [0,1] — no clamping needed.
+  return mix(
+    getFromColor((uv - 0.5) * (1.0 - m) + 0.5),
+    getToColor((uv - 0.5) * m + 0.5),
+    m
+  );
+}
+`,
+});
+//# sourceMappingURL=directional-warp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directional-warp.js","sourceRoot":"","sources":["../../src/transitions/directional-warp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC;IAC9C,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE;QACR,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAClB,UAAU,EAAE,GAAG;KAChB;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BP;CACA,CAAC,CAAC"}

package/dist/transitions/dissolve.d.ts

@@ -0,0 +1,2 @@
+export declare const dissolve: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{}>>;
+//# sourceMappingURL=dissolve.d.ts.map