reacthub-pixitweenjs 0.2.109-alpha.7 → 0.3.0-alpha.4

package/dist/hooks/aep/buildBezierPathTimeline.d.ts

@@ -0,0 +1,13 @@
+import { AepBezierPath, AepKeyframe } from '../../types/aep';
+export interface AepBezierPathTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    initial: AepBezierPath;
+}
+export type AepAnimatableBezier = AepBezierPath | AepKeyframe<AepBezierPath>[];
+/**
+ * @deprecated AEP bezier-path animation now flows via React-side
+ *   `sampleAnimatedBezier`. Preserved for downstream GSAP consumers and
+ *   the internal `useAepBezierPathAnimator` (also deprecated).
+ */
+export declare function buildBezierPathTimeline(field: AepAnimatableBezier | undefined, fps: number, inPointFrames: number, onPath: (path: AepBezierPath) => void): AepBezierPathTimelineBuild;

package/dist/hooks/aep/buildColorValueTimeline.d.ts

@@ -0,0 +1,24 @@
+import { AepAnimatable } from '../../types/aep';
+export interface RgbaColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare function parseHexColor(hex: string): RgbaColor;
+export declare function rgbaToHex(c: RgbaColor): string;
+export interface AepColorTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    target: RgbaColor;
+}
+/**
+ * Color → gsap subtimeline. Each segment tweens RGBA floats; the
+ * consumer reads `target` inside onUpdate and recomposes to a hex
+ * string for the renderer.
+ *
+ * @deprecated AEP color animation now flows via React-side
+ *   `sampleColor`. Preserved for downstream GSAP consumers and the
+ *   internal `useAepColorAnimator` (also deprecated).
+ */
+export declare function buildColorValueTimeline(field: AepAnimatable<string> | undefined, fps: number, inPointFrames: number): AepColorTimelineBuild;

package/dist/hooks/aep/buildLayerTimeline.d.ts

@@ -0,0 +1,20 @@
+import { AepLayer, AepTransform } from '../../types/aep';
+export type AepTweenTarget = Record<string, unknown>;
+export interface AepBuiltSegment {
+    at: number;
+    op: "to" | "set";
+    vars: Record<string, unknown>;
+    props: string[];
+}
+export declare function planPropSegments(prop: keyof AepTransform, field: unknown, fps: number, inPointFrames: number): AepBuiltSegment[];
+export interface AepLayerTimelineBuild {
+    timeline: gsap.core.Timeline;
+    segments: AepBuiltSegment[];
+}
+/**
+ * @deprecated The AEP runtime no longer builds GSAP sub-timelines for
+ *   layer transforms — `useAepLayerTransform` samples them directly
+ *   from `ctx.currentFrame`. Preserved for parity with downstream
+ *   consumers and the existing vitest coverage of segment planning.
+ */
+export declare function buildLayerTimeline(layer: AepLayer, target: AepTweenTarget, fps: number): AepLayerTimelineBuild;

package/dist/hooks/aep/buildScalarValueTimeline.d.ts

@@ -0,0 +1,6 @@
+import { AepAnimatable } from '../../types/aep';
+export interface AepScalarTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+}
+export declare function buildScalarValueTimeline(field: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, target: Record<string, number>, prop: string): AepScalarTimelineBuild;

package/dist/hooks/aep/buildVec2ValueTimeline.d.ts

@@ -0,0 +1,17 @@
+import { AepAnimatable } from '../../types/aep';
+export interface AepVec2TimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    target: {
+        x: number;
+        y: number;
+    };
+}
+type Vec2 = [number, number];
+/**
+ * @deprecated AEP vec2 animation now flows via React-side `sampleVec2`.
+ *   Preserved for downstream GSAP consumers and the internal
+ *   `useAepVec2Animator` (also deprecated).
+ */
+export declare function buildVec2ValueTimeline(field: AepAnimatable<Vec2> | undefined, fps: number, inPointFrames: number): AepVec2TimelineBuild;
+export {};

package/dist/hooks/aep/easeCache.d.ts

@@ -0,0 +1,3 @@
+export declare function easeNameFor(handles: readonly [number, number, number, number] | undefined | null): string;
+export declare function _resetEaseCache(): void;
+export declare function _easeCacheSize(): number;

package/dist/hooks/aep/effectRegistry.d.ts

@@ -0,0 +1,5 @@
+import { AepEffectHandler } from './effects/types';
+export declare function getEffectHandler(name: string): AepEffectHandler | undefined;
+export declare function registerEffectHandler(handler: AepEffectHandler): void;
+export declare function _resetEffectRegistry(): void;
+export declare function _listEffectHandlers(): string[];

package/dist/hooks/aep/effects/brightnessContrast.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const brightnessContrastHandler: AepEffectHandler;

package/dist/hooks/aep/effects/dropShadow.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const dropShadowHandler: AepEffectHandler;

package/dist/hooks/aep/effects/fastBoxBlur.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const fastBoxBlurHandler: AepEffectHandler;

package/dist/hooks/aep/effects/gaussianBlur.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const gaussianBlurHandler: AepEffectHandler;

package/dist/hooks/aep/effects/glow.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const glowHandler: AepEffectHandler;

package/dist/hooks/aep/effects/hueSaturation.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const hueSaturationHandler: AepEffectHandler;

package/dist/hooks/aep/effects/index.d.ts

@@ -0,0 +1,9 @@
+export { gaussianBlurHandler } from './gaussianBlur';
+export { dropShadowHandler } from './dropShadow';
+export { glowHandler } from './glow';
+export { hueSaturationHandler } from './hueSaturation';
+export { levelsHandler } from './levels';
+export { tintHandler } from './tint';
+export { brightnessContrastHandler } from './brightnessContrast';
+export { fastBoxBlurHandler } from './fastBoxBlur';
+export { staticParam, type AepEffectHandler, type AepEffectParamSnapshot } from './types';

package/dist/hooks/aep/effects/levels.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const levelsHandler: AepEffectHandler;

package/dist/hooks/aep/effects/tint.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const tintHandler: AepEffectHandler;

package/dist/hooks/aep/effects/types.d.ts

@@ -0,0 +1,8 @@
+import { Filter } from 'pixi.js';
+export type AepEffectParamSnapshot = Record<string, unknown>;
+export interface AepEffectHandler {
+    name: string;
+    build(snapshot: AepEffectParamSnapshot): Filter;
+    apply(filter: Filter, snapshot: AepEffectParamSnapshot): void;
+}
+export declare function staticParam<T = unknown>(snapshot: AepEffectParamSnapshot, key: string, fallback: T): T;

package/dist/hooks/aep/index.d.ts

@@ -0,0 +1,22 @@
+export { easeNameFor } from './easeCache';
+export { buildLayerTimeline, planPropSegments, } from './buildLayerTimeline';
+export type { AepBuiltSegment, AepLayerTimelineBuild, AepTweenTarget, } from './buildLayerTimeline';
+export { useAepKeyframes } from './useAepKeyframes';
+export { useAepCurrentFrame } from './useAepCurrentFrame';
+export { useAepTextLayout } from './useAepTextLayout';
+export { useTypefaceMetrics } from './useTypefaceMetrics';
+export { sampleAnimatable, sampleScalar, sampleVec2, sampleColor, sampleAnimatedBezier, cubicBezierEase, lerpNumber, lerpVec2, lerpColor, } from './sampleAnimatable';
+export { useAepEffects } from './useAepEffects';
+export { useAepEffectKeyframes } from './useAepEffectKeyframes';
+export { useAepValueAnimator } from './useAepValueAnimator';
+export { useAepColorAnimator } from './useAepColorAnimator';
+export { useAepBezierPathAnimator } from './useAepBezierPathAnimator';
+export { useAepVec2Animator } from './useAepVec2Animator';
+export { buildVec2ValueTimeline, type AepVec2TimelineBuild, } from './buildVec2ValueTimeline';
+export { buildBezierPathTimeline, type AepAnimatableBezier, type AepBezierPathTimelineBuild, } from './buildBezierPathTimeline';
+export { interpolateBezierPath, clonePath, } from './interpolateBezierPath';
+export { buildScalarValueTimeline, type AepScalarTimelineBuild, } from './buildScalarValueTimeline';
+export { buildColorValueTimeline, parseHexColor, rgbaToHex, type AepColorTimelineBuild, type RgbaColor, } from './buildColorValueTimeline';
+export { getEffectHandler, registerEffectHandler, _listEffectHandlers, } from './effectRegistry';
+export * from './effects';
+export { buildAudioLevelTimeline, type AepAudioLevelBuild, type AudioLevelTarget, } from './buildAudioLevelTimeline';

package/dist/hooks/aep/interpolateBezierPath.d.ts

@@ -0,0 +1,3 @@
+import { AepBezierPath } from '../../types/aep';
+export declare function interpolateBezierPath(a: AepBezierPath, b: AepBezierPath, t: number): AepBezierPath;
+export declare function clonePath(p: AepBezierPath): AepBezierPath;

package/dist/hooks/aep/sampleAnimatable.d.ts

@@ -0,0 +1,13 @@
+import { AepAnimatable, AepBezierPath, AepEaseHandle } from '../../types/aep';
+export declare function cubicBezierEase(handles: AepEaseHandle, x: number): number;
+export declare function sampleAnimatable<T>(field: AepAnimatable<T> | undefined, fallback: T, frame: number, lerp: (a: T, b: T, k: number) => T): T;
+export declare const lerpNumber: (a: number, b: number, k: number) => number;
+export declare const lerpVec2: (a: [number, number], b: [number, number], k: number) => [number, number];
+export declare const lerpVec3: (a: [number, number, number], b: [number, number, number], k: number) => [number, number, number];
+export declare function sampleScalar(field: AepAnimatable<number> | undefined, fallback: number, frame: number): number;
+export declare function sampleVec2(field: AepAnimatable<[number, number]> | undefined, fallback: [number, number], frame: number): [number, number];
+export declare function sampleVec3(field: AepAnimatable<[number, number, number]> | undefined, fallback: [number, number, number], frame: number): [number, number, number];
+export declare const sampleEuler: typeof sampleVec3;
+export declare const lerpColor: (a: string, b: string, k: number) => string;
+export declare function sampleColor(field: AepAnimatable<string> | undefined, fallback: string, frame: number): string;
+export declare function sampleAnimatedBezier(field: AepAnimatable<AepBezierPath> | undefined, fallback: AepBezierPath, frame: number): AepBezierPath;

package/dist/hooks/aep/useAepBezierPathAnimator.d.ts

@@ -0,0 +1,12 @@
+import { AepBezierPath } from '../../types/aep';
+import { AepAnimatableBezier } from './buildBezierPathTimeline';
+/**
+ * Drive an animatable bezier path through the master timeline. Fires
+ * `onChange(path)` per onUpdate, plus once at mount with the initial
+ * (keyframe-0) value. Static fields emit once and return.
+ *
+ * @deprecated AEP shape + mask paths now sample directly from
+ *   `ctx.currentFrame` (see `sampleAnimatedBezier`). This hook is
+ *   preserved for downstream consumers driving non-AEP path tweens.
+ */
+export declare function useAepBezierPathAnimator(field: AepAnimatableBezier | undefined, fps: number, inPointFrames: number, onChange: (path: AepBezierPath) => void): void;

package/dist/hooks/aep/useAepColorAnimator.d.ts

@@ -0,0 +1,11 @@
+import { AepAnimatable } from '../../types/aep';
+/**
+ * Drive an animatable hex-color field via a GSAP sub-timeline that
+ * interpolates RGBA floats and fires `onChange(hex)` per tick.
+ *
+ * @deprecated AEP shape fills / stroke colors / effect colors now
+ *   sample directly from `ctx.currentFrame` (see `sampleColor`). This
+ *   hook is preserved for downstream consumers driving non-AEP color
+ *   tweens through the master timeline.
+ */
+export declare function useAepColorAnimator(field: AepAnimatable<string> | undefined, fps: number, inPointFrames: number, onChange: (hex: string) => void): void;

package/dist/hooks/aep/useAepCurrentFrame.d.ts

@@ -0,0 +1 @@
+export declare function useAepCurrentFrame(fps: number): number;

package/dist/hooks/aep/useAepEffectKeyframes.d.ts

@@ -0,0 +1,4 @@
+import { Filter } from 'pixi.js';
+import { AepLayer } from '../../types/aep';
+import * as React from "react";
+export declare function useAepEffectKeyframes(layer: AepLayer, filters: ReadonlyArray<Filter>): React.ReactNode;

package/dist/hooks/aep/useAepEffects.d.ts

@@ -0,0 +1,3 @@
+import { AepLayer } from '../../types/aep';
+import type * as PIXI from "pixi.js";
+export declare function useAepEffects(layer: AepLayer): PIXI.Filter[];

package/dist/hooks/aep/useAepKeyframes.d.ts

@@ -0,0 +1,15 @@
+import { AepLayer } from '../../types/aep';
+import * as React from "react";
+import type * as PIXI from "pixi.js";
+/**
+ * Drives the layer's keyframe animation by attaching a GSAP sub-timeline
+ * to the master `tl.current` at `layer.inPoint / fps` seconds. Cleans up
+ * on unmount or when the layer / target ref changes.
+ *
+ * @deprecated Internal AEP rendering now samples transform keyframes
+ *   from `ctx.currentFrame` directly (see `useAepLayerTransform`). This
+ *   hook is preserved for downstream consumers that drive Pixi
+ *   containers via GSAP outside the AEP composition pipeline. For new
+ *   code, prefer `sampleScalar` / `sampleVec2` from `hooks/aep`.
+ */
+export declare function useAepKeyframes(layer: AepLayer, targetRef: React.RefObject<PIXI.Container | null>, fps: number, readyKey?: unknown): void;

package/dist/hooks/aep/useAepTextLayout.d.ts

@@ -0,0 +1,12 @@
+import { AepLayer, AepThemeMap } from '../../types/aep';
+import { AepTextLayoutResult, AepTextMetricsProvider } from '../../utils/textLayout';
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+interface UseAepTextLayoutOptions {
+    boxWidth?: number;
+    metrics?: AepTextMetricsProvider;
+    theme?: AepThemeMap;
+}
+export declare function useAepTextLayout(layer: AepTextLayer, currentFrame: number, options?: UseAepTextLayoutOptions): AepTextLayoutResult;
+export {};

package/dist/hooks/aep/useAepValueAnimator.d.ts

@@ -0,0 +1,2 @@
+import { AepAnimatable } from '../../types/aep';
+export declare function useAepValueAnimator(field: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, onChange: (value: number) => void): void;

package/dist/hooks/aep/useAepVec2Animator.d.ts

@@ -0,0 +1,10 @@
+import { AepAnimatable } from '../../types/aep';
+/**
+ * Animatable [x, y] field driver. Fires `onChange(x, y)` per onUpdate
+ * and once at mount with the keyframe-0 value.
+ *
+ * @deprecated AEP effect-param vec2s now sample directly from
+ *   `ctx.currentFrame` (see `sampleVec2`). This hook is preserved for
+ *   downstream consumers driving non-AEP vec2 tweens.
+ */
+export declare function useAepVec2Animator(field: AepAnimatable<[number, number]> | undefined, fps: number, inPointFrames: number, onChange: (x: number, y: number) => void): void;

package/dist/hooks/aep/useTypefaceMetrics.d.ts

@@ -0,0 +1,2 @@
+import { AepTextMetricsProvider } from '../../utils/textLayout';
+export declare function useTypefaceMetrics(url: string | undefined): AepTextMetricsProvider | undefined;

package/dist/hooks/index.d.ts

@@ -1 +1,13 @@
 export * from './useGsapEffect';
+export * from './useSpriteFilters';
+export * from './aep';
+export { default as usePixiAnimation } from './usePixiAnimation';
+export { useVideoTexture } from './video/useVideoTexture';
+export { useVideoLifecycle } from './video/useVideoLifecycle';
+export { useVideoTimelineSync } from './video/useVideoTimelineSync';
+export { withFiltersHook } from './withFiltersHook';
+export { withEffectsHook, useEffects, getEffectFilter } from './withEffectsHook';
+export { fromMultiplierColorCorrection, type SpriteColorCorrection, type SpriteEffectsInput } from './useSpriteFilters';
+export { useSvgTexture, type UseSvgTextureOptions } from './useSvgTexture';
+export { useDebouncedValue } from './useDebouncedValue';
+export { useFontEpoch } from './useFontEpoch';

package/dist/hooks/useBlendFilter.d.ts

@@ -0,0 +1,17 @@
+import { PixiBlendModeString } from '../utils/blendMode';
+/**
+ * Resolves the editor's numeric blend-mode code (from `transformation.blendMode`)
+ * to the PIXI v8 string value expected by `Container.blendMode` / `Sprite.blendMode`.
+ *
+ * PIXI v8 replaced the old numeric `BLEND_MODES` enum with a string union
+ * ('normal' | 'multiply' | 'darken' | ...). Photoshop-style modes (Overlay,
+ * Darken, Lighten, Color Dodge/Burn, Hard/Soft Light) additionally require the
+ * `pixi.js/advanced-blend-modes` side-effect module to be imported once at app
+ * bootstrap (see src/index.tsx) — without it those string values are inert and
+ * the renderer silently falls back to 'normal'.
+ *
+ * Callers set the returned string directly on a Container/Sprite's `blendMode`
+ * prop — no filter needed for this to take effect.
+ */
+export declare const useBlendFilter: (blendMode?: number) => PixiBlendModeString;
+export default useBlendFilter;

package/dist/hooks/useDebouncedValue.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `value`, but only after it has stopped changing for `delayMs`.
+ *
+ * A single timer is restarted on every change and cleared on cleanup, so only the FINAL value
+ * of a burst is ever published, never an intermediate one. (`delayMs <= 0` publishes on the
+ * next effect tick.) The first value is returned immediately.
+ *
+ * Used by `useSvgTexture` / `PixiSvgRawSprite` so dragging a resize handle re-rasterises once.
+ */
+export declare function useDebouncedValue<T>(value: T, delayMs: number): T;
+export default useDebouncedValue;

package/dist/hooks/useFontEpoch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A counter that increments every time fonts finish loading (`Events.FONTS_LOADED`).
+ *
+ * Put it in any memo/effect dependency list that builds a `TextStyle` or a text layout, so it
+ * re-runs against the real font instead of the fallback it measured with before the load.
+ * On each event it also flushes both measurement caches:
+ *   - Pixi's `CanvasTextMetrics` (keyed by font string)
+ *   - this engine's default layout metrics provider
+ */
+export declare function useFontEpoch(): number;

package/dist/hooks/usePixiAnimation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * usePixiAnimation
+ *
+ * Drives entrance/exit animations by creating a child timeline and adding it
+ * to the parent GSAP timeline. Follows the same pattern as PixiSequence for
+ * consistent timeline nesting behavior.
+ *
+ * @param {Object} config - Animation configuration
+ * @param {React.RefObject} config.targetRef - Reference to the PIXI container
+ * @param {Object} config.transformation - Transformation properties
+ * @param {number} config.start - Element start time in seconds
+ * @param {number} config.end - Element end time in seconds
+ * @param {Object} [config.effectOptions] - Additional options for GSAP effects
+ */
+declare const usePixiAnimation: ({ targetRef, transformation, start, end, effectOptions }: {
+    targetRef: any;
+    transformation: any;
+    start: any;
+    end: any;
+    effectOptions?: {} | undefined;
+}) => {
+    childTimelineRef: import('react').RefObject<null>;
+};
+export default usePixiAnimation;

package/dist/hooks/useSpriteFilters.d.ts

@@ -0,0 +1,81 @@
+import { Effects } from '../types/Effects';
+import type * as PIXI from "pixi.js";
+/**
+ * Colour correction in SLIDER units (ported from the Clippy editor).
+ *
+ *   brightness, contrast, saturation, red, green, blue,
+ *   temperature, tint, highlights, shadows, exposure, vibrance : -100..100, 0 = no change
+ *   hue                                                         : -180..180 degrees
+ *   sharpness, blurRadius, vignette, noise, edgeFeather         : 0..100
+ *   gamma, alpha                                                : 1 = no change
+ *
+ * This replaces the earlier multiplier convention (neutral = 1). To convert old
+ * values use `fromMultiplierColorCorrection`.
+ */
+export interface SpriteColorCorrection {
+    enabled?: boolean;
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    red?: number;
+    green?: number;
+    blue?: number;
+    gamma?: number;
+    alpha?: number;
+    temperature?: number;
+    tint?: number;
+    hue?: number;
+    highlights?: number;
+    shadows?: number;
+    exposure?: number;
+    vibrance?: number;
+    sharpness?: number;
+    blurRadius?: number;
+    vignette?: number;
+    noise?: number;
+    edgeFeather?: number;
+}
+export interface SpriteEffectsInput {
+    name?: Effects | string;
+    /** 0..100. Defaults to 100 for any real effect, 0 for "None". */
+    intensity?: number;
+    params?: Record<string, unknown>;
+}
+export type PlateKeyInput = boolean | string | {
+    color?: string;
+    tolerance?: number;
+} | null;
+export interface UseSpriteFiltersProps {
+    colorCorrection?: SpriteColorCorrection;
+    effects?: SpriteEffectsInput;
+    neonColor?: number | string | null;
+    /** `transformation.blendMode` (numeric code). Appended as the LAST filter when others exist. */
+    blendMode?: number;
+    /** Key a flat background plate out of the image. `true` = default cream plate. */
+    plateKey?: PlateKeyInput;
+}
+/**
+ * Convert the old multiplier-style correction (neutral = 1: `contrast: 2`) to the
+ * slider scale (neutral = 0: `contrast: 100`). Fields that were not multipliers
+ * (hue, temperature, sharpness, blurRadius, vignette, noise, gamma, alpha) pass
+ * through unchanged. Only the six multiplier fields are rescaled.
+ */
+export declare const fromMultiplierColorCorrection: (old: Record<string, number | undefined> | null | undefined) => SpriteColorCorrection;
+/**
+ * One ordered filter array for a sprite: plate-key -> colour correction ->
+ * effect preset(s) -> blur/vignette/noise -> blend composite (last).
+ *
+ * Ported from the Clippy editor, with two deliberate differences:
+ *  - colour-correction fields are read individually so the memo only re-runs when a
+ *    value changes, not whenever the caller passes a fresh `{}`
+ *  - the filters this hook created are destroyed when they are replaced or on
+ *    unmount (Clippy leaks them)
+ *
+ * Time-varying effects (VHS, glitch, godray...) are driven from the master GSAP
+ * timeline via `registerTimeUpdateListener`, so they follow the playhead: animate
+ * while playing, jump on seek, freeze when paused. Deterministic for export.
+ *
+ * Returns `[]` (never null) when no filter applies, so it is safe to pass straight
+ * to `<pixiSprite filters={...}>`.
+ */
+export declare const useSpriteFilters: ({ colorCorrection, effects, neonColor, blendMode, plateKey, }: UseSpriteFiltersProps) => PIXI.Filter[];

package/dist/hooks/useSvgTexture.d.ts

@@ -0,0 +1,29 @@
+import * as PIXI from "pixi.js";
+export interface UseSvgTextureOptions {
+    src?: string;
+    width?: number;
+    height?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    /** Render multiplier. 2 gives crisp results without devicePixelRatio jitter. */
+    resolution?: number;
+    /** ms to wait after the LAST width/height change before re-rasterising. Default 120. */
+    resizeDebounceMs?: number;
+}
+export interface UseSvgTextureResult {
+    texture: PIXI.Texture | null;
+    isLoading: boolean;
+}
+/**
+ * Rasterise an SVG (with optional stroke override) to a PIXI.Texture at
+ * `width x height x resolution`. Non-SVG sources fall back to the regular texture loader.
+ * Ported from the Clippy editor's `useSvgTexture`, with these fixes:
+ *
+ *  - The previous texture (and its canvas) is DESTROYED when a new one replaces it and on
+ *    unmount. Clippy leaked one CanvasSource per re-raster.
+ *  - width/height changes are debounced, so dragging a resize handle re-rasterises once
+ *    after the drag settles instead of on every pointer move.
+ *  - Inline `data:image/svg+xml` sources are rasterised too (Clippy only matched `.svg` URLs).
+ *  - A failed fetch (HTTP error) yields `null` instead of rasterising an error page.
+ */
+export declare function useSvgTexture({ src, width, height, stroke, strokeWidth, resolution, resizeDebounceMs, }: UseSvgTextureOptions): UseSvgTextureResult;

package/dist/hooks/video/useVideoLifecycle.d.ts

@@ -0,0 +1,23 @@
+export interface VideoLifecycleState {
+    isPlaying: boolean;
+    progress: number;
+    isMuted: boolean;
+    isWaiting: boolean;
+    isStalled: boolean;
+}
+/**
+ * useVideoLifecycle
+ *
+ * Attaches DOM event listeners to track waiting / stalled / loaded state
+ * on the underlying HTMLVideoElement. Returns a mutable state ref the caller
+ * can read inside GSAP callbacks (without triggering React re-renders).
+ *
+ * Also keeps `muted` and `playbackRate` in sync with props via dedicated
+ * effects — each prop change touches only the relevant attribute.
+ */
+export declare function useVideoLifecycle({ getVideo, ready, muted, playbackRate, }: {
+    getVideo: () => HTMLVideoElement | null | undefined;
+    ready: boolean;
+    muted: boolean;
+    playbackRate: number;
+}): React.MutableRefObject<VideoLifecycleState>;

package/dist/hooks/video/useVideoTexture.d.ts

@@ -0,0 +1,34 @@
+import * as PIXI from 'pixi.js';
+interface UseVideoTextureOptions {
+    src: string;
+    uniqueId: string;
+    frameStartAt: number;
+    fps?: number;
+    isRemotion?: boolean;
+}
+interface UseVideoTextureResult {
+    texture: PIXI.Texture | null;
+    videoElement: HTMLVideoElement | null;
+    isLoaded: boolean;
+    error: Error | null;
+}
+/**
+ * useVideoTexture (v8, scrub model)
+ *
+ * Builds a PixiJS v8 video texture. Mirrors the proven pixi-test-v1 reference:
+ *
+ *   - MP4: `PIXI.Assets.load({ src, data: { autoPlay:false, autoUpdate:false, ... } })`.
+ *     The Assets video loader buffers the full file and resolves decode-ready,
+ *     so the per-frame seeks the timeline drives return frames for EVERY clip.
+ *     (A lazily-built VideoSource from a raw <video> only buffers ~2 of N collage
+ *     clips in time, leaving the rest black.)
+ *   - Other containers (.mov/.avi/...): manual <video> wrapped in a VideoSource.
+ *   (HLS is intentionally not ported — add hls.js + a branch here if needed.)
+ *
+ * `source.autoUpdate = false` — GSAP is the clock (useVideoTimelineSync scrubs
+ * currentTime + calls source.update()). We never call play(), to dodge the
+ * browser's concurrent-video hardware-decode cap (~2-4) that blacks out extra
+ * clips. First frame is painted via a one-shot seeked/loadeddata → update().
+ */
+export declare function useVideoTexture({ src, uniqueId, frameStartAt, fps: _fps, isRemotion: _isRemotion, }: UseVideoTextureOptions): UseVideoTextureResult;
+export {};

package/dist/hooks/video/useVideoTimelineSync.d.ts

@@ -0,0 +1,24 @@
+import { VideoLifecycleState } from './useVideoLifecycle';
+import * as PIXI from 'pixi.js';
+interface UseVideoTimelineSyncOptions {
+    textureRef: React.MutableRefObject<PIXI.Texture | null>;
+    stateRef: React.MutableRefObject<VideoLifecycleState>;
+    ready: boolean;
+    start: number;
+    end: number;
+    frameStartAt: number;
+    uniqueId: string;
+}
+/**
+ * useVideoTimelineSync (v8 scrub model)
+ *
+ * GSAP is the clock. Every tick maps timeline time → source time, seeks the
+ * element, and flags a GPU re-upload via `source.update()` (the AEP
+ * registerVideoSync model). While paused/scrubbing we only seek (no play()),
+ * keeping the concurrent-video hardware-decode cap (~2-4 clips) in check.
+ * During real playback (Events.RESUME) the active clip's element is also
+ * play()'d so its audio track is audible — drift correction still runs via
+ * the currentTime check below.
+ */
+export declare function useVideoTimelineSync({ textureRef, stateRef, ready, start, end, frameStartAt, uniqueId, }: UseVideoTimelineSyncOptions): import('react').RefObject<gsap.core.Tween | null>;
+export {};