framefields 2.2.0-beta.4 → 2.3.0

package/dist/index.d.mts

@@ -1,13 +1,13 @@
 import "./chunk-GBe2k3y8.mjs";
-import { $ as AdvancedTextAnimatorSchema, $a as TimelineTransform, $i as NodeMetadata, $n as samplePathChainGeometry, $o as parseCssGradient, $r as DEFAULT_DURATION_MS, $t as TextCursorConfig, A as SlugFontCache, Aa as SignalDataSchema, Ai as GradientType, An as buildPathLUT, Ao as extractSvgDimensions, Ar as resolveEnvironment, At as LongShadowConfig, B as loadModel3D, Ba as SingleOutputGenericSchema, Bi as MediaMetadata, Bn as evaluateMarqueeOffset, Bo as getMediaType, Br as BaseVideoLayerPropsSchema, Bt as SelectorShape, C as Renderer3D, Ca as SegmentationOptions, Ci as FrameSignal, Cn as VariableFontAxesSchema, Co as computeVideoCropRenderProps, Cr as Path3DPoint, Ct as GlyphAnchorGroupingSchema, Da as SignalChannelMetaSchema, Di as GeneratorSignalDataSchema, Dn as VolumetricFormationConfigSchema, Do as createVirtualMedia, Dr as Vec3, Dt as KineticMarqueeConfigSchema, E as ShadowPipeline, Ea as SignalChannelMeta, Ei as GeneratorSignalData, En as VolumetricFormationConfig, Eo as createOutputItemSchema, Er as ShadowUniformInfo, Et as KineticMarqueeConfig, F as describeGpu, Fa as SignalStats, Fi as JsonValue, Fn as distanceToCurveParameter, Fo as generateId, Fr as AudioExtractorSignalData, Ft as PathChainLUTEntry, G as parseOBJ, Ga as TensorDimensions, Gi as MediaSourceDescriptor, Gn as evaluateVolumetricFormation, Go as isEqual, Gr as Color, Gt as SkewPropertiesSchema, H as lutStore, Ha as StorageService, Hi as MediaOperation, Hn as evaluateSkewMatrix, Ho as gradientStopsToOklab, Hr as COMPOSITE_OPERATIONS, Ht as SelectorUnits, I as ensureDevice, Ia as SignalStatsSchema, Ii as JsonValueSchema, In as ellipseToCubicBeziers, Io as getActiveMediaMetadata, Ir as AudioExtractorSignalDataSchema, It as SelectorBasedOn, J as textureCache, Ja as TensorPipelineConfig, Ji as MeshAudioDeformConfig, Jn as getScramblePool, Jo as limitGradientStops, Jr as ConfigHandleSchema, Jt as SpringPhysics, K as shaderStore, Ka as TensorFormat, Ki as MediaSourceInput, Kn as generateArcLengthLUT, Ko as isSignal, Kr as ColorStopLike, Kt as Spatial3DProperties, La as SignalValue, Li as Landmark3D, Ln as evaluateCubicBezier, Lo as getFileDataMetadata, Lr as BaseMediaOperationProps, Lt as SelectorBasedOnSchema, M as SphereGeometryOptions, Ma as SignalGateDataSchema, Mi as HandleTypeVal, Mn as computeLineLeadingDisplacement, Mo as formatHex, Mr as AnimationTypeSchema, Mt as ParticleDissolveConfig, Na as SignalMathData, Ni as JsonArray, Nn as computeRangeSelectorWeight, No as frameArraySignal, Nr as AnyOutputUnion, Nt as ParticleDissolveConfigSchema, Oa as SignalContext, Oi as GlobalCompositeOperation, On as VolumetricFormationMode, Oo as dataTypeColors, Or as Vector3Math, Ot as LineSpacingDynamics, Pa as SignalMathDataSchema, Pi as JsonObject, Pn as deterministicWigglyNoise, Po as frameSignal, Pr as AnyOutputUnionSchema, Pt as PathChainLUT, Q as AdvancedTextAnimatorBuilder, Qa as TimelineSegmentSchema, Qi as MultiOutputGenericSchema, Qn as sampleCurveGeometry, Qo as parseCssColor, Qr as DATA_TYPE_EXTENSIONS, Qt as TextAnimatorBuilder, R as inputStore, Ra as SineSignalOptions, Ri as MAX_GRADIENT_STOPS, Rn as evaluateCubicBezierDerivative, Ro as getFingerprint, Rr as BaseMediaOperationPropsSchema, Rt as SelectorMode, S as Renderer2D, Sa as Rgba, Si as FrameContext, Sn as VariableFontAxes, So as checkNodeResultCache, Sr as Path3D, St as GlyphAnchorGrouping, T as SSAOPipeline, Ta as SignalBuilderConfig, Ti as GateSignalOptions, Tn as Vec2Schema, To as cosineSignal, Tr as ResolvedEnvironment, Tt as GlyphAnchorPointSchema, U as parseFBX, Ua as TEXT_LAYER_DEFAULTS, Ui as MediaOperationSchema, Un as evaluateSpringProgress, Uo as hasOnlySingleSource, Ur as COMPOSITOR_DEFAULTS, Ut as SelectorUnitsSchema, V as loadOBJ, Va as SourceOperationSchema, Vi as MediaMetadataSchema, Vn as evaluateSelectorCombination, Vo as getRenderFingerprint, Vr as CAPTION_LAYER_DEFAULTS, Vt as SelectorShapeSchema, W as parseMTL, Wa as TensorData, Wi as MediaService, Wn as evaluateTypewriterState, Wo as isCssGradient, Wr as CannyOptions, Wt as SkewProperties, X as AETextAnimatorSchema, Xa as TextSpan, Xi as ModerationUnrefundableError, Xn as parseSvgPathToCubicBeziers, Xo as normalizeColorStops, Xr as ConnectedInput, Xt as TextAnchorConfig, Y as AETextAnimator, Ya as TextOperationSchema, Yi as ModerationError, Yn as getShuffledOrder, Yo as mixColors, Yr as ConfigSchemaRegistry, Yt as SpringPhysicsSchema, Z as AdvancedTextAnimator, Za as TextSpanMark, Zi as MultiOutputGeneric, Zn as sampleAudioSpectrumScale, Zo as oklabToRgb, Zr as ControlNetConditioningOutputs, Zt as TextAnchorConfigSchema, _ as Mesh3DData, _a as ParsedGradientStop, _i as FaceLandmarksOptions, _n as TextWigglySelectorSchema, _o as VisionTask, _r as LightKind, _s as timeSignal, _t as ExpressionEvaluationContext, a as AudioMeshDeformPipeline, aa as NodeRunFunction, ai as DataTypeVal, an as TextPathOptionsSchema, ao as VideoAnimation, ar as CatmullRomOptions, as as resolveMediaMimeType, at as AnimatableGlyphPropsSchema, b as NodeAnimationTrack3D, ba as ProgrammaticSignalOptions, bi as FileData, bn as TypingCadence, bo as XYPosition, br as Mat4, bt as ExtendedGlyphProperties, c as BlendMode, ca as NodeVisualConfigSchema, ci as DepthNormalsOptions, cn as TextRangeSelector, co as VideoLayerTypeSchema, cr as Environment3DFog, cs as resolveString, ct as AudioSpectrumTypographySchema, d as EffectPipeline, da as ObjectBoundingBox, di as EffectConfig, dn as TextScrambleConfigSchema, do as VideoTextPropsSchema, dr as FrustumPlanes, ds as serializeSignalData, dt as CubicBezierSegment, ea as NodeMetadataSchema, ei as DEFAULT_FPS, en as TextCursorConfigSchema, eo as TimelineTransformSchema, er as waveToCubicBeziers, es as programmaticSignal, et as AnchorGrouping, f as GlassPipeline, fa as OpticalFlowOptions, fi as EffectConfigValue, fn as TextSelector, fo as VideoTimingPropsSchema, fr as GPULightData, fs as signal, ft as CubicBezierSegmentSchema, g as Material3D, ga as ParsedGradient, gi as ExtendedLayerSchema, gn as TextWigglySelector, go as VisionNodeSpec, gr as Light3DOptions, gs as takeRenderDiagnostics, gt as EnhancedTextNodeSchema, ha as OutputItemSchema, hi as ExtendedLayer, hn as TextSignalSelectorSchema, ho as VisionConfig, hr as Light3D, hs as stampResult, ht as EnhancedTextNode, i as AudioLatentTrackCache, ia as NodeResultSchema, ii as DataTypeEnum, in as TextPathOptions, io as TransitionTypeSchema, ir as CameraShakeOptions, is as resolveBoolean, it as AnimatableGlyphProps, j as SlugPipeline, ja as SignalGateData, ji as HandleType, jn as computeAnchorPivotOffset, jo as findSourceAsset, jr as AnimationType, jt as LongShadowConfigSchema, k as Skeleton3D, ka as SignalData, ki as Gradient, kn as VolumetricFormationModeSchema, ko as deserializeSignalData, kr as parseColorToRgb, kt as LineSpacingDynamicsSchema, l as Bone3D, la as NormalRelightingOptions, li as DetectedObject, ln as TextRangeSelectorSchema, lo as VideoSpatialPropsSchema, lr as Environment3DOptions, ls as rgbToOklab, lt as ChromaticGlitchConfig, m as LoadModelOptions, ma as OutputItem, mi as ExportResultSchema, mn as TextSignalSelector, mo as VirtualMediaDataSchema, mr as LIGHT_UNIFORM_SIZE_BYTES, ms as sineSignal, mt as DynamicStrokePropertiesSchema, n as AudioLatentData, na as NodeProcessorParams, ni as DataForType, nn as TextCursorStyleSchema, no as TransitionSchema, nr as Camera3D, ns as registerSignalDependency, nt as AnchorPreset, oa as NodeValidationFn, oi as DataTypes, on as TextPathSource, oo as VideoAnimationSchema, or as CirclePathOptions, os as resolveNumber, ot as ArcLengthLUTEntry, p as GpuAdapterDescription, pa as Output, pi as ExportResult, pn as TextSelectorSchema, po as VirtualMediaData, pr as HelixOptions, ps as signalBuilder, pt as DynamicStrokeProperties, q as signalRegistry, qa as TensorNode, qi as MediaSourceSchema, qn as generatePathSegments, qo as isVirtualMediaData, qr as ConfigHandle, qt as Spatial3DPropertiesSchema, r as AudioLatentEngine, ra as NodeResult, ri as DataType, rn as TextPathBuilder, ro as TransitionType, rr as Camera3DPose, rs as reportRenderDiagnostic, rt as AnchorPresetSchema, sa as NodeVisualConfig, si as DeflickerOptions, sn as TextPathSourceSchema, so as VideoLayerType, sr as ENVIRONMENT_PRESETS, ss as resolveParam, st as AudioSpectrumTypography, t as AnimationClip3D, ta as NodeProcessorContext, ti as DEFAULT_MEDIA_DIMENSION, tn as TextCursorStyle, to as TrackedObject, tr as BezierSegment3D, ts as progressSignal, tt as AnchorGroupingSchema, u as CylinderGeometryOptions, ua as NormalizedLandmarkList, ui as Effect$1, un as TextScrambleConfig, uo as VideoStylePropsSchema, ur as FrustumPlane, us as sampleColorStops, ut as ChromaticGlitchConfigSchema, v as Model3DData, va as PoseSkeletonOptions, vi as FileAsset, vn as TypewriterAnimator, vo as VisionVariant, vr as LightsUniformData, vs as updateClockSignals, vt as ExpressionSelector, w as RoundedBoxGeometryOptions, wa as Signal, wi as GPUTextureBinding, wn as Vec2, wo as computed, wr as Path3DSample, wt as GlyphAnchorPoint, x as RenderContextValue, xa as RenderDiagnostic, xi as FileDataSchema, xn as TypingCadenceSchema, xo as appendOperation, xr as Matrix4Math, xt as ExtendedGlyphPropertiesSchema, y as MotionBlurPipeline, ya as ProgrammaticSignal, yi as FileAssetSchema, yn as TypewriterAnimatorSchema, yo as WritableSignal, yr as MAX_LIGHTS, yt as ExpressionSelectorSchema, z as loadFBX, za as SingleOutputGeneric, zi as MIME_TYPES, zn as evaluateExpressionSelector, zo as getLeafMediaType, zr as BaseVideoLayerProps, zt as SelectorModeSchema } from "./index-B-oUlLoO.mjs";
-import { a as SfxTrigger, c as softLimit, g as mixAudioTracks, i as SfxRenderContext, n as encodeStereoWav, o as mixSfxInto, r as RenderedSfx, s as renderSfx } from "./index-XdQPNJnq.mjs";
-import "./index-DXfp_T-3.mjs";
-import "./renderer-BT-_EoXw.mjs";
-import { $ as Blur, $n as CannyComputePipeline, $t as NoiseGeneratorProps, A as MotionBlur, An as ObjectAnchorName, At as Flip, B as SelectiveColorProps, Bn as PoseResult, C as HighPass, Cn as COCO17_BONES, Ct as CornerPin, D as LevelsProps, Dn as InstanceMask, Dt as DisplacementMapProps, E as Levels, En as COCO_CLASSES, Et as DisplacementMap, F as Relight3DProps, Fn as ObjectTrackSignals, Ft as LayerStyle, G as TileOffsetEdgeMode, Gn as TemporalObjectTracker, H as ShadowsHighlightsProps, Hn as SegmentationResult, Ht as LayerStyleProps, I as SSAO, In as PersonMatte, J as UnsharpMaskProps, Jn as VisionNode, Jt as MaskMathProps, K as TileOffsetProps, Kn as VisionAnalysisReport, Kt as LiquifyProps, L as SSAOProps, Ln as PinToLandmarkOptions, M as PBRGlass, Mn as ObjectBoundingBoxSignals, Mt as KenBurns, N as PBRGlassProps, Nn as ObjectCollectionSignals, O as Modulate, On as LandmarkCoordinateSignals, Ot as ExtractLUT, P as Relight3D, Pn as ObjectKinematicsSignals, Pt as KenBurnsProps, Q as effectMeta, Qn as pinNodeToObject, Qt as NoiseGenerator, R as SelectiveColor, Rn as PinToObjectOptions, S as HalftoneScreenProps, Sn as VignetteProps, St as ColorKeyProps, T as LevelChannel, Tn as COCO17_KEYPOINT_NAMES, Tt as CornerPinProps, U as TemporalDeflicker, Un as SegmentationTexturePool, V as ShadowsHighlights, Vn as PoseSkeletonRenderer, W as TileOffset, Wn as SpatialLandmarkTransformer, Wt as Liquify, X as VisionProps, Xn as analyzeSequence, Y as Vision, Yn as VisionRunner, Yt as MeshWarp, Z as effectFactories, Zn as pinNodeToLandmark, Zt as MeshWarpProps, _ as GradientMapProps, _n as RotateProps, _t as ChannelSplitter, a as Crop, an as PatchHeal, ar as TensorSource, at as AudioFade, b as HalftoneMode, bt as ColorBalanceProps, c as CurvesChannelPoint, cn as ProceduralVFX, ct as AudioNoiseGateProps, d as DeflickerProps, dn as RefineEdgeProps, dt as AudioReverb, en as Paint, er as ControlNetMultiplexer, et as BlurProps, f as DepthOfField, fn as RefractionCaustics3D, ft as AudioReverbProps, g as GradientMap, gn as Rotate, gt as ChannelMergerProps, h as FilmGrainProps, hn as ResizerScalerProps, ht as ChannelMerger, i as AudioSignalExtractorProps, ir as TensorPipeline, it as AudioDelayProps, j as MotionBlurProps, jn as ObjectAnchorsSignals, jt as FlipProps, k as ModulateProps, kn as MaskTrackSignals, kt as ExtractLUTProps, l as CurvesProps, ln as ProceduralVFXProps, lt as AudioParametricEq, m as FilmGrain, mn as ResizerScaler, mt as CameraParallax3DProps, n as ApplyLUTProps, nr as OpticalFlowComputePipeline, nt as AudioCompressorProps, o as CropProps, or as TensorViewExport, ot as AudioFadeProps, p as DepthOfFieldProps, pn as RefractionCaustics3DProps, pt as CameraParallax3D, q as UnsharpMask, qn as VisionBundle, qt as MaskMath, r as AudioSignalExtractor, rr as TemporalDeflickerPipeline, rt as AudioDelay, s as Curves, sn as PatchHealProps, st as AudioNoiseGate, t as ApplyLUT, tn as PaintProps, tr as DepthNormalsComputePipeline, tt as AudioCompressor, u as CustomEffect, un as RefineEdge, ut as AudioParametricEqProps, v as GradientMapStop, vn as StereoPanning, vt as ChannelSplitterProps, w as HighPassProps, wn as COCO17_KEYPOINTS, x as HalftoneScreen, xn as Vignette, xt as ColorKey, y as HalftoneDotShape, yn as StereoPanningProps, yt as ColorBalance, z as SelectiveColorAdjustment, zn as PoseLandmarkSignals } from "./index-CwbszPDG.mjs";
-import { n as AudioSignalOptions, r as ExtractedAudioSignalsBundle, t as AudioSignal } from "./audio-BvYmTu5T.mjs";
-import { a as RegisteredFont, i as RegisterFontOptions, n as MeasureTextOptions, o as TextMetrics, r as MeasuredGlyph, t as FontManager } from "./index-BcA8rep0.mjs";
-import "./index-D-Iek5sq.mjs";
-import { _ as renderSemaphore, a as renderFrameGrid, c as HeadlessMediaRenderer, d as QaSegment, f as RenderProgress, g as formatQaReport, h as VideoQaStats, i as computeGridLayout, l as HeadlessWebGPURenderer, m as VideoQaReport, n as FrameGridRenderable, o as resolveSamplePoints, p as VideoQaOptions, r as FrameSamplePoint, s as AudioQaStats, t as FrameGridOptions, u as QaIssue, v as resetRenderCaches } from "./index-CdyE1tst.mjs";
+import { $ as AdvancedTextAnimatorSchema, $a as TimelineTransform, $i as NodeMetadata, $n as samplePathChainGeometry, $o as parseCssGradient, $r as DEFAULT_DURATION_MS, $t as TextCursorConfig, A as SlugFontCache, Aa as SignalDataSchema, Ai as GradientType, An as buildPathLUT, Ao as extractSvgDimensions, Ar as resolveEnvironment, At as LongShadowConfig, B as loadModel3D, Ba as SingleOutputGenericSchema, Bi as MediaMetadata, Bn as evaluateMarqueeOffset, Bo as getMediaType, Br as BaseVideoLayerPropsSchema, Bt as SelectorShape, C as Renderer3D, Ca as SegmentationOptions, Ci as FrameSignal, Cn as VariableFontAxesSchema, Co as computeVideoCropRenderProps, Cr as Path3DPoint, Ct as GlyphAnchorGroupingSchema, Da as SignalChannelMetaSchema, Di as GeneratorSignalDataSchema, Dn as VolumetricFormationConfigSchema, Do as createVirtualMedia, Dr as Vec3, Dt as KineticMarqueeConfigSchema, E as ShadowPipeline, Ea as SignalChannelMeta, Ei as GeneratorSignalData, En as VolumetricFormationConfig, Eo as createOutputItemSchema, Er as ShadowUniformInfo, Et as KineticMarqueeConfig, F as describeGpu, Fa as SignalStats, Fi as JsonValue, Fn as distanceToCurveParameter, Fo as generateId, Fr as AudioExtractorSignalData, Ft as PathChainLUTEntry, G as parseOBJ, Ga as TensorDimensions, Gi as MediaSourceDescriptor, Gn as evaluateVolumetricFormation, Go as isEqual, Gr as Color, Gt as SkewPropertiesSchema, H as lutStore, Ha as StorageService, Hi as MediaOperation, Hn as evaluateSkewMatrix, Ho as gradientStopsToOklab, Hr as COMPOSITE_OPERATIONS, Ht as SelectorUnits, I as ensureDevice, Ia as SignalStatsSchema, Ii as JsonValueSchema, In as ellipseToCubicBeziers, Io as getActiveMediaMetadata, Ir as AudioExtractorSignalDataSchema, It as SelectorBasedOn, J as textureCache, Ja as TensorPipelineConfig, Ji as MeshAudioDeformConfig, Jn as getScramblePool, Jo as limitGradientStops, Jr as ConfigHandleSchema, Jt as SpringPhysics, K as shaderStore, Ka as TensorFormat, Ki as MediaSourceInput, Kn as generateArcLengthLUT, Ko as isSignal, Kr as ColorStopLike, Kt as Spatial3DProperties, La as SignalValue, Li as Landmark3D, Ln as evaluateCubicBezier, Lo as getFileDataMetadata, Lr as BaseMediaOperationProps, Lt as SelectorBasedOnSchema, M as SphereGeometryOptions, Ma as SignalGateDataSchema, Mi as HandleTypeVal, Mn as computeLineLeadingDisplacement, Mo as formatHex, Mr as AnimationTypeSchema, Mt as ParticleDissolveConfig, Na as SignalMathData, Ni as JsonArray, Nn as computeRangeSelectorWeight, No as frameArraySignal, Nr as AnyOutputUnion, Nt as ParticleDissolveConfigSchema, Oa as SignalContext, Oi as GlobalCompositeOperation, On as VolumetricFormationMode, Oo as dataTypeColors, Or as Vector3Math, Ot as LineSpacingDynamics, Pa as SignalMathDataSchema, Pi as JsonObject, Pn as deterministicWigglyNoise, Po as frameSignal, Pr as AnyOutputUnionSchema, Pt as PathChainLUT, Q as AdvancedTextAnimatorBuilder, Qa as TimelineSegmentSchema, Qi as MultiOutputGenericSchema, Qn as sampleCurveGeometry, Qo as parseCssColor, Qr as DATA_TYPE_EXTENSIONS, Qt as TextAnimatorBuilder, R as inputStore, Ra as SineSignalOptions, Ri as MAX_GRADIENT_STOPS, Rn as evaluateCubicBezierDerivative, Ro as getFingerprint, Rr as BaseMediaOperationPropsSchema, Rt as SelectorMode, S as Renderer2D, Sa as Rgba, Si as FrameContext, Sn as VariableFontAxes, So as checkNodeResultCache, Sr as Path3D, St as GlyphAnchorGrouping, T as SSAOPipeline, Ta as SignalBuilderConfig, Ti as GateSignalOptions, Tn as Vec2Schema, To as cosineSignal, Tr as ResolvedEnvironment, Tt as GlyphAnchorPointSchema, U as parseFBX, Ua as TEXT_LAYER_DEFAULTS, Ui as MediaOperationSchema, Un as evaluateSpringProgress, Uo as hasOnlySingleSource, Ur as COMPOSITOR_DEFAULTS, Ut as SelectorUnitsSchema, V as loadOBJ, Va as SourceOperationSchema, Vi as MediaMetadataSchema, Vn as evaluateSelectorCombination, Vo as getRenderFingerprint, Vr as CAPTION_LAYER_DEFAULTS, Vt as SelectorShapeSchema, W as parseMTL, Wa as TensorData, Wi as MediaService, Wn as evaluateTypewriterState, Wo as isCssGradient, Wr as CannyOptions, Wt as SkewProperties, X as AETextAnimatorSchema, Xa as TextSpan, Xi as ModerationUnrefundableError, Xn as parseSvgPathToCubicBeziers, Xo as normalizeColorStops, Xr as ConnectedInput, Xt as TextAnchorConfig, Y as AETextAnimator, Ya as TextOperationSchema, Yi as ModerationError, Yn as getShuffledOrder, Yo as mixColors, Yr as ConfigSchemaRegistry, Yt as SpringPhysicsSchema, Z as AdvancedTextAnimator, Za as TextSpanMark, Zi as MultiOutputGeneric, Zn as sampleAudioSpectrumScale, Zo as oklabToRgb, Zr as ControlNetConditioningOutputs, Zt as TextAnchorConfigSchema, _ as Mesh3DData, _a as ParsedGradientStop, _i as FaceLandmarksOptions, _n as TextWigglySelectorSchema, _o as VisionTask, _r as LightKind, _s as timeSignal, _t as ExpressionEvaluationContext, a as AudioMeshDeformPipeline, aa as NodeRunFunction, ai as DataTypeVal, an as TextPathOptionsSchema, ao as VideoAnimation, ar as CatmullRomOptions, as as resolveMediaMimeType, at as AnimatableGlyphPropsSchema, b as NodeAnimationTrack3D, ba as ProgrammaticSignalOptions, bi as FileData, bn as TypingCadence, bo as XYPosition, br as Mat4, bt as ExtendedGlyphProperties, c as BlendMode, ca as NodeVisualConfigSchema, ci as DepthNormalsOptions, cn as TextRangeSelector, co as VideoLayerTypeSchema, cr as Environment3DFog, cs as resolveString, ct as AudioSpectrumTypographySchema, d as EffectPipeline, da as ObjectBoundingBox, di as EffectConfig, dn as TextScrambleConfigSchema, do as VideoTextPropsSchema, dr as FrustumPlanes, ds as serializeSignalData, dt as CubicBezierSegment, ea as NodeMetadataSchema, ei as DEFAULT_FPS, en as TextCursorConfigSchema, eo as TimelineTransformSchema, er as waveToCubicBeziers, es as programmaticSignal, et as AnchorGrouping, f as GlassPipeline, fa as OpticalFlowOptions, fi as EffectConfigValue, fn as TextSelector, fo as VideoTimingPropsSchema, fr as GPULightData, fs as signal, ft as CubicBezierSegmentSchema, g as Material3D, ga as ParsedGradient, gi as ExtendedLayerSchema, gn as TextWigglySelector, go as VisionNodeSpec, gr as Light3DOptions, gs as takeRenderDiagnostics, gt as EnhancedTextNodeSchema, ha as OutputItemSchema, hi as ExtendedLayer, hn as TextSignalSelectorSchema, ho as VisionConfig, hr as Light3D, hs as stampResult, ht as EnhancedTextNode, i as AudioLatentTrackCache, ia as NodeResultSchema, ii as DataTypeEnum, in as TextPathOptions, io as TransitionTypeSchema, ir as CameraShakeOptions, is as resolveBoolean, it as AnimatableGlyphProps, j as SlugPipeline, ja as SignalGateData, ji as HandleType, jn as computeAnchorPivotOffset, jo as findSourceAsset, jr as AnimationType, jt as LongShadowConfigSchema, k as Skeleton3D, ka as SignalData, ki as Gradient, kn as VolumetricFormationModeSchema, ko as deserializeSignalData, kr as parseColorToRgb, kt as LineSpacingDynamicsSchema, l as Bone3D, la as NormalRelightingOptions, li as DetectedObject, ln as TextRangeSelectorSchema, lo as VideoSpatialPropsSchema, lr as Environment3DOptions, ls as rgbToOklab, lt as ChromaticGlitchConfig, m as LoadModelOptions, ma as OutputItem, mi as ExportResultSchema, mn as TextSignalSelector, mo as VirtualMediaDataSchema, mr as LIGHT_UNIFORM_SIZE_BYTES, ms as sineSignal, mt as DynamicStrokePropertiesSchema, n as AudioLatentData, na as NodeProcessorParams, ni as DataForType, nn as TextCursorStyleSchema, no as TransitionSchema, nr as Camera3D, ns as registerSignalDependency, nt as AnchorPreset, oa as NodeValidationFn, oi as DataTypes, on as TextPathSource, oo as VideoAnimationSchema, or as CirclePathOptions, os as resolveNumber, ot as ArcLengthLUTEntry, p as GpuAdapterDescription, pa as Output, pi as ExportResult, pn as TextSelectorSchema, po as VirtualMediaData, pr as HelixOptions, ps as signalBuilder, pt as DynamicStrokeProperties, q as signalRegistry, qa as TensorNode, qi as MediaSourceSchema, qn as generatePathSegments, qo as isVirtualMediaData, qr as ConfigHandle, qt as Spatial3DPropertiesSchema, r as AudioLatentEngine, ra as NodeResult, ri as DataType, rn as TextPathBuilder, ro as TransitionType, rr as Camera3DPose, rs as reportRenderDiagnostic, rt as AnchorPresetSchema, sa as NodeVisualConfig, si as DeflickerOptions, sn as TextPathSourceSchema, so as VideoLayerType, sr as ENVIRONMENT_PRESETS, ss as resolveParam, st as AudioSpectrumTypography, t as AnimationClip3D, ta as NodeProcessorContext, ti as DEFAULT_MEDIA_DIMENSION, tn as TextCursorStyle, to as TrackedObject, tr as BezierSegment3D, ts as progressSignal, tt as AnchorGroupingSchema, u as CylinderGeometryOptions, ua as NormalizedLandmarkList, ui as Effect$1, un as TextScrambleConfig, uo as VideoStylePropsSchema, ur as FrustumPlane, us as sampleColorStops, ut as ChromaticGlitchConfigSchema, v as Model3DData, va as PoseSkeletonOptions, vi as FileAsset, vn as TypewriterAnimator, vo as VisionVariant, vr as LightsUniformData, vs as updateClockSignals, vt as ExpressionSelector, w as RoundedBoxGeometryOptions, wa as Signal, wi as GPUTextureBinding, wn as Vec2, wo as computed, wr as Path3DSample, wt as GlyphAnchorPoint, x as RenderContextValue, xa as RenderDiagnostic, xi as FileDataSchema, xn as TypingCadenceSchema, xo as appendOperation, xr as Matrix4Math, xt as ExtendedGlyphPropertiesSchema, y as MotionBlurPipeline, ya as ProgrammaticSignal, yi as FileAssetSchema, yn as TypewriterAnimatorSchema, yo as WritableSignal, yr as MAX_LIGHTS, yt as ExpressionSelectorSchema, z as loadFBX, za as SingleOutputGeneric, zi as MIME_TYPES, zn as evaluateExpressionSelector, zo as getLeafMediaType, zr as BaseVideoLayerProps, zt as SelectorModeSchema } from "./index-AdrZIWT0.mjs";
+import { a as SfxTrigger, c as softLimit, g as mixAudioTracks, i as SfxRenderContext, n as encodeStereoWav, o as mixSfxInto, r as RenderedSfx, s as renderSfx } from "./index-CeRv1KC0.mjs";
+import "./index-Cg2ptXcs.mjs";
+import "./renderer-DlESyfg7.mjs";
+import { $ as Blur, $n as COCO17_BONES, A as MotionBlur, An as Posterize, Ar as CannyComputePipeline, B as SelectiveColorProps, Bn as ResizerScaler, Bt as Flip, C as HighPass, Cn as Painterly, Cr as VisionAnalysisReport, Ct as ColorBalance, D as LevelsProps, Dn as PatchHealProps, Dr as analyzeSequence, Dt as Contour, E as Levels, Er as VisionRunner, Et as ColorKeyProps, F as Relight3DProps, Fn as RGBSplitProps, Fr as TensorPipeline, Ft as DisplacementMapProps, G as TileOffsetEdgeMode, Gn as StereoPanningProps, Gt as IridescenceProps, H as ShadowsHighlightsProps, Hn as Rotate, Ht as Gooey, I as SSAO, In as RefineEdge, Ir as TensorSource, It as Dither, J as UnsharpMaskProps, Jn as ToonProps, Jt as KenBurns, K as TileOffsetProps, Kt as Kaleidoscope, L as SSAOProps, Ln as RefineEdgeProps, Lr as TensorViewExport, Lt as DitherProps, M as PBRGlass, Mn as ProceduralVFX, Mr as DepthNormalsComputePipeline, Mt as Datamosh, N as PBRGlassProps, Nn as ProceduralVFXProps, Nr as OpticalFlowComputePipeline, Nt as DatamoshProps, O as Modulate, On as Pixelate, Or as pinNodeToLandmark, Ot as ContourProps, P as Relight3D, Pn as RGBSplit, Pr as TemporalDeflickerPipeline, Pt as DisplacementMap, Q as effectMeta, Qn as VignetteProps, R as SelectiveColor, Rn as RefractionCaustics3D, Rt as ExtractLUT, S as HalftoneScreenProps, Sr as TemporalObjectTracker, St as ChannelSplitterProps, T as LevelChannel, Tn as PatchHeal, Tr as VisionNode, Tt as ColorKey, U as TemporalDeflicker, Un as RotateProps, Ut as GooeyProps, V as ShadowsHighlights, Vn as ResizerScalerProps, Vt as FlipProps, W as TileOffset, Wn as StereoPanning, Wt as Iridescence, X as VisionProps, Xn as TrailsProps, Xt as KenBurnsProps, Y as Vision, Yn as Trails, Z as effectFactories, Zn as Vignette, Zt as LayerStyle, _ as GradientMapProps, _n as OpArtProps, _r as PoseResult, _t as CameraParallax3D, a as Crop, ar as LandmarkCoordinateSignals, at as AudioDelay, b as HalftoneMode, br as SegmentationTexturePool, bt as ChannelMergerProps, c as CurvesChannelPoint, cn as LiquifyProps, cr as ObjectAnchorsSignals, ct as AudioFadeProps, d as DeflickerProps, dn as MeshWarp, dr as ObjectKinematicsSignals, dt as AudioParametricEq, er as COCO17_KEYPOINTS, et as BlurProps, f as DepthOfField, fr as ObjectTrackSignals, ft as AudioParametricEqProps, g as GradientMap, gn as OpArt, gr as PoseLandmarkSignals, gt as CRTProps, h as FilmGrainProps, hn as NoiseGeneratorProps, hr as PinToObjectOptions, ht as CRT, i as AudioSignalExtractorProps, in as LayerStyleProps, ir as InstanceMask, it as AudioCompressorProps, j as MotionBlurProps, jn as PosterizeProps, jr as ControlNetMultiplexer, jt as CornerPinProps, k as ModulateProps, kn as PixelateProps, kr as pinNodeToObject, kt as CornerPin, l as CurvesProps, ln as MaskMath, lr as ObjectBoundingBoxSignals, lt as AudioNoiseGate, m as FilmGrain, mn as NoiseGenerator, mr as PinToLandmarkOptions, mt as AudioReverbProps, n as ApplyLUTProps, nr as COCO_CLASSES, nt as AsciiProps, o as CropProps, on as Liquify, or as MaskTrackSignals, ot as AudioDelayProps, p as DepthOfFieldProps, pn as MeshWarpProps, pr as PersonMatte, pt as AudioReverb, q as UnsharpMask, qn as Toon, qt as KaleidoscopeProps, r as AudioSignalExtractor, rr as ClipSubjectSource, rt as AudioCompressor, s as Curves, sr as ObjectAnchorName, st as AudioFade, t as ApplyLUT, tr as COCO17_KEYPOINT_NAMES, tt as Ascii, u as CustomEffect, un as MaskMathProps, ur as ObjectCollectionSignals, ut as AudioNoiseGateProps, v as GradientMapStop, vn as Paint, vr as PoseSkeletonRenderer, vt as CameraParallax3DProps, w as HighPassProps, wn as PainterlyProps, wr as VisionBundle, wt as ColorBalanceProps, x as HalftoneScreen, xr as SpatialLandmarkTransformer, xt as ChannelSplitter, y as HalftoneDotShape, yn as PaintProps, yr as SegmentationResult, yt as ChannelMerger, z as SelectiveColorAdjustment, zn as RefractionCaustics3DProps, zt as ExtractLUTProps } from "./index-BU51pxZO.mjs";
+import { n as AudioSignalOptions, r as ExtractedAudioSignalsBundle, t as AudioSignal } from "./audio-BNnEclHU.mjs";
+import { a as RegisteredFont, i as RegisterFontOptions, n as MeasureTextOptions, o as TextMetrics, r as MeasuredGlyph, t as FontManager } from "./index-B-55dXDu.mjs";
+import "./index-B3BwLHa6.mjs";
+import { _ as renderSemaphore, a as renderFrameGrid, c as HeadlessMediaRenderer, d as QaSegment, f as RenderProgress, g as formatQaReport, h as VideoQaStats, i as computeGridLayout, l as HeadlessWebGPURenderer, m as VideoQaReport, n as FrameGridRenderable, o as resolveSamplePoints, p as VideoQaOptions, r as FrameSamplePoint, s as AudioQaStats, t as FrameGridOptions, u as QaIssue, v as resetRenderCaches } from "./index-QmkcUL3W.mjs";
 import { PreviewCloseReason, PreviewOptions, PreviewSession, PreviewSource, startPreview } from "./preview/index.mjs";
 import { z } from "zod";
 import { Yoga } from "yoga-layout/load";
@@ -61,9 +61,9 @@ declare function parseMarkup(markup: string): TextSpan[];
 
 /** number px | "auto" (intrinsic) | "fit" (shrink-wrap) | "fill" (parent extent). */
 declare const SizeSpecSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+  fill: "fill";
   auto: "auto";
   fit: "fit";
-  fill: "fill";
 }>, z.ZodCustom<unknown, unknown>]>;
 type SizeSpec = z.infer<typeof SizeSpecSchema>;
 declare const ShapeTypeSchema: z.ZodEnum<{
@@ -77,39 +77,40 @@ declare const ShapeTypeSchema: z.ZodEnum<{
 }>;
 type ShapeType = z.infer<typeof ShapeTypeSchema>;
 declare const AnimatablePropSchema: z.ZodEnum<{
-  fill: "fill";
   x: "x";
   y: "y";
-  scale: "scale";
-  rotation: "rotation";
-  opacity: "opacity";
   width: "width";
   height: "height";
+  rotation: "rotation";
+  scale: "scale";
+  opacity: "opacity";
+  trimStart: "trimStart";
+  trimEnd: "trimEnd";
+  text: "text";
+  fontSize: "fontSize";
+  fill: "fill";
+  letterSpacing: "letterSpacing";
+  padding: "padding";
+  strokeWidth: "strokeWidth";
+  borderColor: "borderColor";
+  borderWidth: "borderWidth";
   volume: "volume";
+  color: "color";
+  offset: "offset";
   hidden: "hidden";
   muted: "muted";
   gap: "gap";
-  padding: "padding";
   borderRadius: "borderRadius";
-  fontSize: "fontSize";
-  text: "text";
-  color: "color";
-  letterSpacing: "letterSpacing";
-  trimStart: "trimStart";
-  trimEnd: "trimEnd";
+  d: "d";
   trimOffset: "trimOffset";
-  strokeWidth: "strokeWidth";
   strokeDashOffset: "strokeDashOffset";
   cornerRadius: "cornerRadius";
   starInnerRadiusRatio: "starInnerRadiusRatio";
   fillColor: "fillColor";
   strokeColor: "strokeColor";
-  borderColor: "borderColor";
-  borderWidth: "borderWidth";
   motionBlurShutter: "motionBlurShutter";
   rangeStart: "rangeStart";
   rangeEnd: "rangeEnd";
-  offset: "offset";
   animatorRangeStart: "animatorRangeStart";
   animatorRangeEnd: "animatorRangeEnd";
   animatorOffset: "animatorOffset";
@@ -190,6 +191,7 @@ declare const MaterialTypeSchema: z.ZodEnum<{
 type MaterialType = z.infer<typeof MaterialTypeSchema>;
 declare const EaseRefSchema: z.ZodObject<{
   name: z.ZodEnum<{
+    bounce: "bounce";
     none: "none";
     power1: "power1";
     power2: "power2";
@@ -199,14 +201,13 @@ declare const EaseRefSchema: z.ZodObject<{
     expo: "expo";
     back: "back";
     elastic: "elastic";
-    bounce: "bounce";
     spring: "spring";
     cubic: "cubic";
     hold: "hold";
   }>;
   dir: z.ZodEnum<{
-    in: "in";
     out: "out";
+    in: "in";
     inOut: "inOut";
   }>;
   params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -218,6 +219,7 @@ declare const KeyframeSchema: z.ZodObject<{
   value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
   ease: z.ZodOptional<z.ZodObject<{
     name: z.ZodEnum<{
+      bounce: "bounce";
       none: "none";
       power1: "power1";
       power2: "power2";
@@ -227,14 +229,13 @@ declare const KeyframeSchema: z.ZodObject<{
       expo: "expo";
       back: "back";
       elastic: "elastic";
-      bounce: "bounce";
       spring: "spring";
       cubic: "cubic";
       hold: "hold";
     }>;
     dir: z.ZodEnum<{
-      in: "in";
       out: "out";
+      in: "in";
       inOut: "inOut";
     }>;
     params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -291,39 +292,40 @@ type TrackSource = z.infer<typeof RawTrackSourceSchema>;
 declare const AnimationTrackSchema: z.ZodObject<{
   id: z.ZodString;
   prop: z.ZodEnum<{
-    fill: "fill";
     x: "x";
     y: "y";
-    scale: "scale";
-    rotation: "rotation";
-    opacity: "opacity";
     width: "width";
     height: "height";
+    rotation: "rotation";
+    scale: "scale";
+    opacity: "opacity";
+    trimStart: "trimStart";
+    trimEnd: "trimEnd";
+    text: "text";
+    fontSize: "fontSize";
+    fill: "fill";
+    letterSpacing: "letterSpacing";
+    padding: "padding";
+    strokeWidth: "strokeWidth";
+    borderColor: "borderColor";
+    borderWidth: "borderWidth";
     volume: "volume";
+    color: "color";
+    offset: "offset";
     hidden: "hidden";
     muted: "muted";
     gap: "gap";
-    padding: "padding";
     borderRadius: "borderRadius";
-    fontSize: "fontSize";
-    text: "text";
-    color: "color";
-    letterSpacing: "letterSpacing";
-    trimStart: "trimStart";
-    trimEnd: "trimEnd";
+    d: "d";
     trimOffset: "trimOffset";
-    strokeWidth: "strokeWidth";
     strokeDashOffset: "strokeDashOffset";
     cornerRadius: "cornerRadius";
     starInnerRadiusRatio: "starInnerRadiusRatio";
     fillColor: "fillColor";
     strokeColor: "strokeColor";
-    borderColor: "borderColor";
-    borderWidth: "borderWidth";
     motionBlurShutter: "motionBlurShutter";
     rangeStart: "rangeStart";
     rangeEnd: "rangeEnd";
-    offset: "offset";
     animatorRangeStart: "animatorRangeStart";
     animatorRangeEnd: "animatorRangeEnd";
     animatorOffset: "animatorOffset";
@@ -426,6 +428,7 @@ declare const AnimationTrackSchema: z.ZodObject<{
     value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
     ease: z.ZodOptional<z.ZodObject<{
       name: z.ZodEnum<{
+        bounce: "bounce";
         none: "none";
         power1: "power1";
         power2: "power2";
@@ -435,14 +438,13 @@ declare const AnimationTrackSchema: z.ZodObject<{
         expo: "expo";
         back: "back";
         elastic: "elastic";
-        bounce: "bounce";
         spring: "spring";
         cubic: "cubic";
         hold: "hold";
       }>;
       dir: z.ZodEnum<{
-        in: "in";
         out: "out";
+        in: "in";
         inOut: "inOut";
       }>;
       params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -467,39 +469,40 @@ declare const LayerAnimationSchema: z.ZodObject<{
   tracks: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     prop: z.ZodEnum<{
-      fill: "fill";
       x: "x";
       y: "y";
-      scale: "scale";
-      rotation: "rotation";
-      opacity: "opacity";
       width: "width";
       height: "height";
+      rotation: "rotation";
+      scale: "scale";
+      opacity: "opacity";
+      trimStart: "trimStart";
+      trimEnd: "trimEnd";
+      text: "text";
+      fontSize: "fontSize";
+      fill: "fill";
+      letterSpacing: "letterSpacing";
+      padding: "padding";
+      strokeWidth: "strokeWidth";
+      borderColor: "borderColor";
+      borderWidth: "borderWidth";
       volume: "volume";
+      color: "color";
+      offset: "offset";
       hidden: "hidden";
       muted: "muted";
       gap: "gap";
-      padding: "padding";
       borderRadius: "borderRadius";
-      fontSize: "fontSize";
-      text: "text";
-      color: "color";
-      letterSpacing: "letterSpacing";
-      trimStart: "trimStart";
-      trimEnd: "trimEnd";
+      d: "d";
       trimOffset: "trimOffset";
-      strokeWidth: "strokeWidth";
       strokeDashOffset: "strokeDashOffset";
       cornerRadius: "cornerRadius";
       starInnerRadiusRatio: "starInnerRadiusRatio";
       fillColor: "fillColor";
       strokeColor: "strokeColor";
-      borderColor: "borderColor";
-      borderWidth: "borderWidth";
       motionBlurShutter: "motionBlurShutter";
       rangeStart: "rangeStart";
       rangeEnd: "rangeEnd";
-      offset: "offset";
       animatorRangeStart: "animatorRangeStart";
       animatorRangeEnd: "animatorRangeEnd";
       animatorOffset: "animatorOffset";
@@ -602,6 +605,7 @@ declare const LayerAnimationSchema: z.ZodObject<{
       value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
       ease: z.ZodOptional<z.ZodObject<{
         name: z.ZodEnum<{
+          bounce: "bounce";
           none: "none";
           power1: "power1";
           power2: "power2";
@@ -611,14 +615,13 @@ declare const LayerAnimationSchema: z.ZodObject<{
           expo: "expo";
           back: "back";
           elastic: "elastic";
-          bounce: "bounce";
           spring: "spring";
           cubic: "cubic";
           hold: "hold";
         }>;
         dir: z.ZodEnum<{
-          in: "in";
           out: "out";
+          in: "in";
           inOut: "inOut";
         }>;
         params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -638,6 +641,7 @@ declare const LayerAnimationSchema: z.ZodObject<{
     yoyo: z.ZodOptional<z.ZodBoolean>;
     durationFrames: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>>;
+  frameStep: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 type LayerAnimationSpec = z.infer<typeof LayerAnimationSchema>;
 interface CompositionNodeBase {
@@ -1169,8 +1173,8 @@ declare const CompositorProgramSchema: z.ZodObject<{
   volume: z.ZodDefault<z.ZodNumber>;
   fps: z.ZodDefault<z.ZodNumber>;
   mode: z.ZodDefault<z.ZodEnum<{
-    Video: "Video";
     Image: "Image";
+    Video: "Video";
   }>>;
   antialias3d: z.ZodOptional<z.ZodBoolean>;
   layout: z.ZodDefault<z.ZodArray<z.ZodType<LayoutNode, unknown, z.core.$ZodTypeInternals<LayoutNode, unknown>>>>;
@@ -1275,6 +1279,10 @@ interface SignalTrackOptions {
 interface ColorSignalOptions {
   colorA: string;
   colorB: string;
+  /** Scales the signal before it picks a color (e.g. `1 / 900` for a speed in px/s). Default 1. */
+  multiplier?: number;
+  /** Added after `multiplier`. Default 0. */
+  offset?: number;
   colorMode?: "interpolate" | "hueRotate" | "threshold";
   threshold?: number;
   smoothing?: number;
@@ -1346,8 +1354,19 @@ declare function mergeAnimationTracks(tracks: readonly AnimationTrack[]): Animat
  */
 declare class LayerAnimation implements LayerAnimationSpec {
   tracks: AnimationTrack[];
+  /** Hold each value for this many frames (see {@link LayerAnimation.stepped}). */
+  frameStep?: number;
   constructor(tracks?: AnimationTrack[]);
   static create(): LayerAnimation;
+  /**
+   * Stepped timing for the whole layer: every animated value is held for
+   * `frames` frames ("on twos" = 2, "on threes" = 3), the choppy, hand-made
+   * look of stop motion and cel animation. Applies to all of the layer's
+   * tracks, including ones added by other `.animate()` calls.
+   */
+  static stepped(frames?: number): LayerAnimation;
+  /** See {@link LayerAnimation.stepped}. */
+  stepped(frames?: number): this;
   static fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): LayerAnimation;
   /** A track from a list of `[frame, value, ease?]` keyframes; see {@link LayerAnimation.keys}. */
   static keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[]): LayerAnimation;
@@ -1593,6 +1612,18 @@ declare function lintComposition(config: Pick<CompositorProgramConfig, "width" |
 //#region src/program/mattes.d.ts
 /** Returns the tree with every `matte` turned into a sibling matte layer. */
 declare function hoistMattes<T extends LayoutNode>(nodes: readonly T[]): T[];
+//#endregion
+//#region src/program/path-morph.d.ts
+/**
+ * Shape morphing: interpolates between two SVG path strings.
+ *
+ * Both paths are flattened to polylines, resampled to the same number of
+ * points by arc length, and the second is rotated (and reversed if it winds
+ * the other way) so its points line up with the first's. Subpaths pair up in
+ * order; a subpath with no partner grows from (or shrinks to) the center of
+ * the one it pairs with. The result is a polygon path string.
+ */
+
 //#endregion
 //#region src/program/sequence.d.ts
 /**
@@ -1882,6 +1913,760 @@ interface ChartOptions {
 }
 declare const DEFAULT_CHART_COLORS: readonly ["#6366f1", "#22d3ee", "#f59e0b", "#ec4899", "#10b981", "#8b5cf6", "#f97316", "#3b82f6"];
 //#endregion
+//#region src/clip-vision.d.ts
+type PoseKeypointName = (typeof COCO17_KEYPOINT_NAMES)[number];
+interface ClipVisionOptions {
+  /** Composition frame the clip's first frame plays on (default 0). */
+  startFrame?: number;
+  /** Seconds trimmed off the clip's start, as on its media layer (default 0). */
+  trimStartSec?: number;
+  /** Analysis frame rate (default: the composition's). */
+  fps?: number;
+  /** Track 17 COCO keypoints (default true). */
+  pose?: boolean;
+  /** Track the person's silhouette, dress and held things included (default true). */
+  mask?: boolean;
+  /** Silhouette cell size in source pixels (default 8: a 1920×1080 clip gives a 240×135 grid). */
+  maskCell?: number;
+  /** Keypoints are averaged over ±`smoothing` frames, weighted by confidence (default 2; 0 = raw). */
+  smoothing?: number;
+  variant?: VisionProps["variant"];
+  confidence?: number;
+  modelsDir?: string;
+  baseUrl?: string;
+  /**
+   * Node: where results persist between runs. Default
+   * `$FRAMEFIELDS_VISION_CACHE_DIR` or `~/.cache/framefields/vision`;
+   * `false` keeps them in memory only. Browsers always keep them in memory.
+   */
+  cacheDir?: string | false;
+}
+/** Where the clip sits in the composition, like a media layer's box and `fit`. */
+interface PersonPlacement {
+  x?: number;
+  y?: number;
+  width: number;
+  height: number;
+  fit?: "cover" | "contain" | "fill";
+}
+interface FrameResult {
+  /** 17 × [x, y, visibility], source px; null when no person was found. */
+  kp: Float32Array | null;
+  /** cellW × cellH, 0–255; null when no person was found. */
+  mask: Uint8Array | null;
+}
+interface Transform {
+  sx: number;
+  sy: number;
+  ox: number;
+  oy: number;
+}
+/**
+ * Vision results for one clip, computed per frame on demand and shared by
+ * everything that reads the clip: physics, layout, signals. Unlike the
+ * render-time `withVision`, which analyses a layer's previous rendered frame,
+ * this analyses the clip's own frames, so a result exists before its frame
+ * renders. The composition analyses what each frame needs just before
+ * drawing it (and a live physics world before stepping), so preview and
+ * export fill the cache as they play; nothing has to be analysed up front.
+ *
+ * Results depend only on the clip and settings, so they persist on disk in
+ * Node: a second run, or a render after a preview, reuses them. A matte-mode
+ * `withVision` layer of the same clip reuses them too (`keepSubjects`).
+ */
+declare class ClipVision implements ClipSubjectSource {
+  readonly source: string;
+  readonly fps: number;
+  readonly startFrame: number;
+  readonly trimStartSec: number;
+  readonly smoothing: number;
+  /** @internal */
+  readonly options: ClipVisionOptions;
+  private readonly results;
+  private sourceWidth;
+  private sourceHeight;
+  private cellW;
+  private cellH;
+  private readonly cell;
+  private queue;
+  private runner?;
+  private cacheLoaded?;
+  private unsaved;
+  private unsavedSubjects;
+  private readonly blurred;
+  private readonly smoothed;
+  private personView?;
+  /** Full-resolution subject masks for render-time mattes (see `keepSubjects`). */
+  private readonly subjects;
+  private wantSubjects;
+  private subjectsLoaded?;
+  /** @internal Use `comp.vision(source, options)`. */
+  constructor(source: string, fps: number, options?: ClipVisionOptions);
+  /** The tracked person in source pixels; `.place()` maps it into the composition. */
+  get person(): PersonTrack;
+  /**
+   * Analyses what reading composition frame `frame` needs (it and a few
+   * neighbours for smoothing). Pass a second frame to analyse a whole range.
+   * Calls queue, so the clip is decoded once, in order.
+   */
+  ready(frame: number, toFrame?: number): Promise<void>;
+  /** True when composition frame `frame` can be read synchronously. */
+  isReady(frame: number): boolean;
+  /**
+   * @internal Also keep each frame's full-resolution subject mask, merged
+   * like the Vision effect's matte, so a matte layer of this clip reuses it
+   * instead of segmenting the frame again (framefields links them).
+   */
+  keepSubjects(): void;
+  /**
+   * @internal The subject at a source frame of the clip (`frame` at `fps`),
+   * for a render-time matte: undefined until that frame is analysed with
+   * subjects kept, null when it holds no subject.
+   */
+  subject(frame: number, fps: number): InstanceMask | null | undefined;
+  /** Composition frame → clip frame (fractional). */
+  clipFrame(frame: number): number;
+  private window;
+  private analysed;
+  private compute;
+  private setSize;
+  /** @internal */
+  size(): {
+    width: number;
+    height: number;
+  };
+  /** @internal Raw result for a clip frame, or throws when it was never analysed. */
+  result(c: number): FrameResult | undefined;
+  /** @internal Confidence-weighted keypoint over the smoothing window, in source px. */
+  keypoint(k: number, c: number): [number, number, number];
+  /** @internal Softened silhouette grid for a clip frame (null: no person). */
+  blurredMask(c: number): Float32Array | null;
+  /** @internal */
+  grid(): {
+    cell: number;
+    width: number;
+    height: number;
+  };
+  private mustHave;
+  private cacheFile?;
+  private cachePath;
+  private loadCache;
+  private saveCache;
+  /** Subjects live beside the results: large, and only matte layers read them. */
+  private subjectsPath;
+  private loadSubjects;
+  private saveSubjects;
+}
+/**
+ * The person in a {@link ClipVision}: pose keypoints and silhouette at any
+ * composition frame, in source pixels or, after `place()`, composition
+ * pixels. Reads are synchronous; the frame must be analysed (it is while
+ * rendering, inside a live physics world, or after `await clip.ready(frame)`).
+ */
+declare class PersonTrack {
+  readonly clip: ClipVision;
+  private readonly t?;
+  private readonly placement?;
+  /** @internal */
+  constructor(clip: ClipVision, t?: Transform | undefined, placement?: PersonPlacement | undefined);
+  /** The same person in composition pixels for a clip laid out at `placement`. */
+  place(placement: PersonPlacement): PersonTrack;
+  private transform;
+  /** A keypoint at a composition frame (fractional frames interpolate). */
+  point(name: PoseKeypointName, frame: number): {
+    x: number;
+    y: number;
+    visibility: number;
+  };
+  /** Signals for a keypoint, for `.signal("x", …)`; read while rendering. */
+  signals(name: PoseKeypointName): {
+    x: FrameSignal<number>;
+    y: FrameSignal<number>;
+    visibility: FrameSignal<number>;
+  };
+  /**
+   * @internal The softened silhouette grid at a composition frame and how
+   * placed px map onto it (`cell = (px − origin) / scale − 0.5`), for GPU
+   * consumers such as particles. Null when no person was found.
+   */
+  silhouetteGrid(frame: number): {
+    data: Float32Array;
+    width: number;
+    height: number;
+    originX: number;
+    originY: number;
+    scaleX: number;
+    scaleY: number;
+  } | null;
+  /**
+   * The silhouette near a point at a composition frame: `alpha` 0–1 (softened
+   * over a few cells; inside > 0.5) and its gradient `gx`, `gy` per px,
+   * pointing into the body. Push things out with `-gradient`.
+   */
+  sample(frame: number, x: number, y: number): {
+    alpha: number;
+    gx: number;
+    gy: number;
+  };
+}
+//#endregion
+//#region ../../nodes/node-particles/dist/index-CGwIc9Nx.d.mts
+//#region src/shared/program.d.ts
+
+/**
+ * The contract between a particle system's authoring object (framefields'
+ * `Particles` effect, carried on the op as `effect`) and this renderer.
+ * Static settings are read once per system; per-frame inputs (driven values,
+ * a performer's silhouette) are asked for each simulated frame.
+ */
+type EmitterShape = "point" | "line" | "rect" | "circle" | "ring";
+type ParticleShape = "circle" | "soft" | "square" | "spark";
+type ParticleBlend = "normal" | "add" | "screen";
+type ParticleBounds = "none" | "kill" | "bounce" | "wrap";
+interface ParticleStatic {
+  /** Capacity: the most particles alive at once. */
+  max: number;
+  seed: number;
+  /** Layer box in composition px (sampling silhouettes needs the origin). */
+  layer: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  emitter: {
+    shape: EmitterShape;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    /** Aim away from the emitter's center instead of along `direction`. */
+    radial: boolean;
+  };
+  /** Seconds. */
+  lifetime: [number, number];
+  /** px/s. */
+  speed: [number, number];
+  /** Degrees, 0 = right, -90 = up. */
+  direction: number;
+  /** Degrees around `direction`. */
+  spread: number;
+  bounds: ParticleBounds;
+  /** Floor line in layer px, or null. */
+  floor: number | null;
+  bounce: number;
+  /** px at birth and death. */
+  size: [number, number];
+  /** 0–1 random scale per particle. */
+  sizeJitter: number;
+  /** Fractions of life spent fading in and out. */
+  fade: [number, number];
+  shape: ParticleShape;
+  /** Spark length per px/s of speed. */
+  stretch: number;
+  blend: ParticleBlend;
+  /** Up to 8 colors, evenly spaced over life (or speed). */
+  colors: Array<[number, number, number, number]>;
+  /** Color by speed instead of age: speed (px/s) that reaches the last color. */
+  colorBySpeed: number | null;
+  opacity: number;
+  substeps: number;
+  /** Seconds simulated before the first frame, so it starts full. */
+  prewarm: number;
+}
+interface ParticleAttractor {
+  x: number;
+  y: number;
+  /** px/s² at the center; negative repels. */
+  strength: number;
+  /** Falloff radius, px. */
+  radius: number;
+}
+/** A silhouette grid (0–1 per cell) and how composition px map onto it. */
+interface ParticleMask {
+  data: Float32Array;
+  width: number;
+  height: number;
+  /** cell = (px − origin) / scale − 0.5 */
+  originX: number;
+  originY: number;
+  scaleX: number;
+  scaleY: number;
+}
+interface ParticleFrame {
+  /** Emitter position this frame, when it moves (layer px); births spread back toward `previous`. */
+  emitter?: {
+    x: number;
+    y: number;
+    previousX: number;
+    previousY: number;
+  };
+  /** Particles per second this frame. */
+  rate: number;
+  /** Extra particles born this frame. */
+  burst: number;
+  gravity: [number, number];
+  /** Velocity damping per second. */
+  drag: number;
+  noise: {
+    strength: number;
+    scale: number;
+    speed: number;
+  };
+  attractors: ParticleAttractor[];
+  push: {
+    strength: number;
+    /** Extra push where the silhouette just arrived. */
+    sweep: number;
+    mask: ParticleMask | null;
+    previous: ParticleMask | null;
+  } | null;
+}
+interface ParticleProgram {
+  readonly particleStatic: ParticleStatic;
+  /** Inputs for composition frame `frame` (layer-local frames are the effect's concern). */
+  particleFrame(frame: number, fps: number): ParticleFrame;
+  /** Renderer-owned state, kept on the authoring object so it lives as long as the system. */
+  particleState?: unknown;
+}
+//#endregion
+//#region src/physics/backend.d.ts
+type Vec2$1 = [number, number];
+type Vec3$1 = [number, number, number];
+/** Quaternion as [x, y, z, w]. */
+type Quat = [number, number, number, number];
+type BodyType = "dynamic" | "fixed" | "kinematic";
+interface MaterialSpec {
+  density: number;
+  friction: number;
+  restitution: number;
+}
+type Shape2D = {
+  kind: "box";
+  hx: number;
+  hy: number;
+  radius?: number;
+} | {
+  kind: "ball";
+  radius: number;
+}
+/** Flat [x0, y0, x1, y1, …] around the body origin. */ | {
+  kind: "hull";
+  points: number[];
+};
+type Shape3D = {
+  kind: "box";
+  hx: number;
+  hy: number;
+  hz: number;
+  radius?: number;
+} | {
+  kind: "ball";
+  radius: number;
+}
+/** Axis along y. */ | {
+  kind: "cylinder";
+  halfHeight: number;
+  radius: number;
+}
+/** Flat [x0, y0, z0, …] around the body origin. */ | {
+  kind: "hull";
+  points: number[];
+};
+interface BodySpecBase extends MaterialSpec {
+  type: BodyType;
+  linearDamping: number;
+  angularDamping: number;
+  gravityScale: number;
+  lockRotation: boolean;
+  ccd: boolean;
+  enabled: boolean;
+  /** Touches nothing (joint anchors). */
+  sensor?: boolean;
+}
+interface BodySpec2D extends BodySpecBase {
+  position: Vec2$1;
+  angle: number;
+  velocity: Vec2$1;
+  angularVelocity: number;
+  shape: Shape2D;
+}
+interface BodySpec3D extends BodySpecBase {
+  /** Per-axis rotation, when only some axes are locked: [x, y, z] allowed. */
+  enabledRotations?: [boolean, boolean, boolean];
+  position: Vec3$1;
+  rotation: Quat;
+  velocity: Vec3$1;
+  angularVelocity: Vec3$1;
+  shape: Shape3D;
+}
+type JointSpec<V> = {
+  type: "revolute";
+  anchorA: V;
+  anchorB: V;
+  axis?: Vec3$1;
+} | {
+  type: "spherical";
+  anchorA: V;
+  anchorB: V;
+} | {
+  type: "fixed";
+  anchorA: V;
+  anchorB: V;
+} | {
+  type: "rope";
+  anchorA: V;
+  anchorB: V;
+  length: number;
+} | {
+  type: "spring";
+  anchorA: V;
+  anchorB: V;
+  restLength: number;
+  stiffness: number;
+  damping: number;
+};
+interface SimBody<V, R> {
+  position(): V;
+  rotation(): R;
+  velocity(): V;
+  /** 2D: rad/s; 3D: rad/s per axis. */
+  angularVelocity(): R extends number ? number : Vec3$1;
+  sleeping(): boolean;
+  mass(): number;
+  setEnabled(enabled: boolean): void;
+  applyImpulse(impulse: V): void;
+  setKinematicTarget(position: V, rotation: R): void;
+}
+type SimBody2D = SimBody<Vec2$1, number>;
+type SimBody3D = SimBody<Vec3$1, Quat>;
+interface SimWorld<V, B, S> {
+  addBody(spec: S): B;
+  addJoint(a: B, b: B, spec: JointSpec<V>): void;
+  step(dt: number): void;
+  /** Pairs that started touching during the last step. */
+  drainCollisionStarts(): Array<[B, B]>;
+  free(): void;
+}
+type SimWorld2D = SimWorld<Vec2$1, SimBody2D, BodySpec2D>;
+type SimWorld3D = SimWorld<Vec3$1, SimBody3D, BodySpec3D>;
+interface PhysicsBackend {
+  createWorld2D(gravity: Vec2$1): SimWorld2D;
+  createWorld3D(gravity: Vec3$1): SimWorld3D;
+}
+//#endregion
+//#region src/physics/core.d.ts
+/**
+ * A value read every simulated frame: a number, a signal (sampled at the
+ * composition frame, like `.signal()` tracks), or `(frame) => value` where
+ * `frame` is the composition frame.
+ */
+type PhysicsDriver = number | ((frame: number) => number) | {
+  get(ctx?: FrameContext): number;
+};
+interface PhysicsWorldOptions {
+  /** Composition frame rate. */
+  fps: number;
+  /** How many frames to simulate. Signals hold the last frame afterwards. */
+  frames: number;
+  /**
+   * Composition frame the simulation's frame 0 lands on (default 0). Set it
+   * to a scene's start so a world inside that scene starts with it.
+   */
+  startFrame?: number;
+  /** Pixels per physics meter (default 100). Only changes how stiff and heavy things feel. */
+  pixelsPerMeter?: number;
+  /** Solver steps per frame (default 4). Raise for fast, thin or stacked bodies. */
+  substeps?: number;
+  /** Frames an impact envelope takes to fall to ~37% (default 8). */
+  impactDecay?: number;
+  /** Velocity change, px/s, that reads as impact 1 (default 1500). */
+  impactReference?: number;
+}
+interface BodyCommonOptions {
+  /** `"dynamic"` (default) falls and collides; `"fixed"` never moves; `"kinematic"` follows `follow` and pushes others. */
+  type?: "dynamic" | "fixed" | "kinematic";
+  /** Bounciness, 0–1 (default 0.3). */
+  restitution?: number;
+  /** Default 0.6. */
+  friction?: number;
+  /** Mass per area/volume (default 1). Heavier bodies push lighter ones. */
+  density?: number;
+  /** Velocity damping per second (default 0). */
+  linearDamping?: number;
+  /** Spin damping per second (default 0). */
+  angularDamping?: number;
+  /** Multiplies world gravity for this body (default 1; 0 floats). */
+  gravityScale?: number;
+  /** Never rotates. */
+  lockRotation?: boolean;
+  /** Continuous collision detection for very fast bodies (default false). */
+  ccd?: boolean;
+  /** Collides with nothing; still moves, still reports contacts (triggers). */
+  sensor?: boolean;
+  /** Simulation frame the body wakes up; it holds its place before (default 0). */
+  startFrame?: number;
+  /**
+   * How the result reaches the layer: `"signals"` (default) binds the
+   * body's signals, `"keyframes"` writes plain keyframes, `"none"` leaves
+   * the layer alone (read the signals yourself).
+   */
+  output?: "signals" | "keyframes" | "none";
+}
+/** What `world.live()` needs from a composition. */
+interface LiveHost {
+  onPrepareFrame(callback: (ctx: {
+    frame: number;
+  }) => Promise<void> | void): unknown;
+  prepareVision?(frame: number): Promise<void>;
+}
+interface PhysicsCollision<B> {
+  /** Composition frame of first contact. */
+  frame: number;
+  /** The other body. */
+  with: B;
+  /** Velocity change of the harder-hit body, px/s. */
+  speed: number;
+}
+interface PhysicsBakeOptions {
+  /** Largest error a dropped keyframe may leave, px (default 0.25). Degrees use a fifth of it. */
+  tolerance?: number;
+}
+/**
+ * Per-frame recordings of one body, indexed by composition frame. Arrays are
+ * filled when the world simulates; reading a signal before that simulates.
+ */
+declare class Recording {
+  readonly length: number;
+  private readonly fps;
+  private readonly ensure;
+  readonly channels: Map<string, Float32Array<ArrayBufferLike>>;
+  private readonly signals;
+  constructor(length: number, fps: number, ensure: () => void);
+  channel(name: string): Float32Array;
+  /**
+   * A per-frame signal over a channel. Creating it does nothing; the first
+   * value read runs the simulation (offline worlds), so signals can be bound
+   * while bodies are still being added.
+   */
+  signal(name: string): FrameSignal<number>;
+}
+/** What the shared stepping loop needs from a 2D or 3D body. */
+interface CoreBody<V extends number[], R> {
+  readonly sim: SimBody<V, R>;
+  readonly type: "dynamic" | "fixed" | "kinematic";
+  readonly startFrame: number;
+  readonly gravityScale: number;
+  /** Unset: signals, or keyframes under `bakeKeyframes()`. */
+  readonly output?: "signals" | "keyframes" | "none";
+  readonly recording: Recording;
+  readonly collisions: PhysicsCollision<unknown>[];
+  readonly layer?: Record<string, unknown>;
+  /** Kinematic pose (backend units) at a composition frame, if it follows drivers. */
+  kinematicTarget?(frame: number): {
+    position: V;
+    rotation: R;
+  } | undefined;
+  /** Writes the body's state for one composition frame into its recording. */
+  record(index: number, previousIndex: number): void;
+  /** Props bound to the layer, with the recording channel each one reads. */
+  boundChannels(): Array<[AnimatableProp, string]>;
+}
+interface ForceEntry<V> {
+  body: CoreBody<number[], unknown>;
+  accel: (frame: number) => V;
+}
+interface ImpulseEntry<V> {
+  body: CoreBody<number[], unknown>;
+  frame: number;
+  dv: V;
+}
+/**
+ * Stepping, recording, impacts and output shared by `PhysicsWorld2D` and
+ * `PhysicsWorld3D`. V is a vector in backend units (meters).
+ */
+declare abstract class WorldCore<V extends number[], R, B extends CoreBody<V, R>> {
+  protected readonly sim: SimWorld<V, SimBody<V, R>, unknown>;
+  protected readonly gravity: V;
+  readonly fps: number;
+  readonly frames: number;
+  readonly startFrame: number;
+  readonly pixelsPerMeter: number;
+  protected readonly substeps: number;
+  protected readonly impactDecay: number;
+  protected readonly impactReference: number;
+  protected readonly bodies: B[];
+  protected readonly forces: ForceEntry<V>[];
+  protected readonly impulses: ImpulseEntry<V>[];
+  protected readonly fields: Array<{
+    targets?: Set<B>;
+    accel: (body: B, frame: number) => V | null | undefined;
+  }>;
+  private readonly worldRecording;
+  private readonly allCollisions;
+  /** No more bodies, joints or forces: the world has started (or finished). */
+  private locked;
+  private liveMode;
+  private stepper?;
+  private chain;
+  protected constructor(sim: SimWorld<V, SimBody<V, R>, unknown>, gravity: V, options: PhysicsWorldOptions);
+  /** First contacts so far (all of them once simulated), in frame order. */
+  get collisions(): ReadonlyArray<PhysicsCollision<B> & {
+    body: B;
+  }>;
+  /** Loudest impact envelope of any body each frame: camera shake, flashes, hit sounds. */
+  get impact(): FrameSignal<number>;
+  /** Runs the whole simulation now (once) and binds every body's layer per its `output`. */
+  simulate(): this;
+  /** Like {@link simulate}, but writes keyframes for every body whose `output` was left at its default. */
+  bakeKeyframes(options?: PhysicsBakeOptions): this;
+  /**
+   * Steps the world as the composition renders instead of all at once: before
+   * each frame draws, the world advances to it, after the composition's
+   * vision clips (`comp.vision`) and any `inputs` have that frame ready. Use
+   * it when bodies follow a performer, so nothing is analysed up front and a
+   * preview starts at once. Frames already simulated are kept, so scrubbing
+   * back costs nothing; jumping ahead simulates the frames in between.
+   * Signals only; `bakeKeyframes()` needs the whole run up front.
+   */
+  live(comp: LiveHost, options?: {
+    inputs?: ReadonlyArray<{
+      ready(frame: number): Promise<void>;
+    }>;
+  }): this;
+  /**
+   * Live worlds: simulates up to composition frame `frame` (no-op when it
+   * already has). Calls queue, so frames are stepped once, in order.
+   */
+  advanceTo(frame: number): Promise<void>;
+  private prepareInputs?;
+  private bakeDefault?;
+  protected newRecording(): Recording;
+  protected assertOpen(): void;
+  protected addBody(body: B): B;
+  protected addForce(body: B, accel: (frame: number) => V): void;
+  protected addField(accel: (body: B, frame: number) => V | null | undefined, targets?: readonly B[]): void;
+  protected addImpulse(body: B, frame: number, dv: V): void;
+  protected ensureSimulated(): void;
+  /** Records frame 0 and sets every channel to it, so frames not simulated yet hold the start pose. */
+  private begin;
+  private stepFrame;
+  protected abstract lerpRotation(a: R, b: R, t: number): R;
+  private bind;
+}
+//#endregion
+//#region src/particles.d.ts
+type Range = number | [number, number];
+interface ParticlesOptions {
+  /** Particle layer box in composition px (the particles' own space; default the whole canvas). */
+  x?: number;
+  y?: number;
+  width: number;
+  height: number;
+  id?: string;
+  startFrame?: number;
+  durationFrames?: number;
+  zIndex?: number;
+  /** Most particles alive at once (default 20000). Costs GPU memory, not time when idle. */
+  max?: number;
+  seed?: number;
+  emitter?: {
+    /** `"rect"` (default, the whole layer), `"point"`, `"line"`, `"circle"` (area) or `"ring"` (edge). Layer px. */
+    shape?: EmitterShape;
+    /** Emitter position (layer px). A driver moves it: `(f) => person.point("rightWrist", f).x` paints with light. */
+    x?: PhysicsDriver;
+    y?: PhysicsDriver;
+    width?: number;
+    height?: number;
+    radius?: number;
+    /** Aim away from the emitter's center instead of along `direction`. */
+    radial?: boolean;
+    /** Particles per second (default 1000); a driver for bursts of activity. */
+    rate?: PhysicsDriver;
+    /** Extra particles at given layer frames. */
+    bursts?: Array<{
+      frame: number;
+      count: number;
+    }>;
+  };
+  /** Seconds each particle lives (default [2, 4]). */
+  lifetime?: Range;
+  /** Launch speed, px/s (default [40, 160]). */
+  speed?: Range;
+  /** Launch direction, degrees (0 = right, -90 = up; default -90). */
+  direction?: number;
+  /** Spread around `direction`, degrees (default 360). */
+  spread?: number;
+  /** px/s². A single driver pulls down. */
+  gravity?: PhysicsDriver | [PhysicsDriver, PhysicsDriver];
+  /** Velocity damping per second (default 0.4). Higher reads as thicker air or liquid. */
+  drag?: PhysicsDriver;
+  /** Swirling, divergence-free flow (curl noise): smoke, ink, flow fields. */
+  noise?: {
+    strength?: PhysicsDriver;
+    scale?: number;
+    speed?: number;
+  };
+  /** Points that pull (positive) or push (negative), px/s² at the center, falling off over `radius`. Layer px. Up to 8. */
+  attractors?: Array<{
+    x: PhysicsDriver;
+    y: PhysicsDriver;
+    strength: PhysicsDriver;
+    radius?: number;
+  }>;
+  /**
+   * A performer pushes particles out of their silhouette, harder where it
+   * is sweeping in: `person` from `comp.vision(clip).person.place(…)`.
+   */
+  push?: {
+    person: PersonTrack;
+    strength?: PhysicsDriver;
+    sweep?: PhysicsDriver;
+  };
+  /** What happens at the layer's edges: `"none"` (default), `"kill"`, `"bounce"`, `"wrap"`. */
+  bounds?: ParticleBounds;
+  /** A floor line in layer px that particles bounce on. */
+  floor?: number;
+  /** Bounciness at the floor and bounced edges (default 0.3). */
+  bounce?: number;
+  /** px at birth → death (default [6, 0]). */
+  size?: Range;
+  /** Random size variation, 0–1 (default 0.5). */
+  sizeJitter?: number;
+  /** Fractions of life to fade in and out (default [0.1, 0.3]). */
+  fade?: [number, number];
+  /** `"circle"` (default), `"soft"` (glow), `"square"`, `"spark"` (streaks along motion). */
+  shape?: ParticleShape;
+  /** Spark length per px/s (default 0.04). */
+  stretch?: number;
+  /** `"normal"` (default), `"add"` (glows build up), `"screen"`. */
+  blend?: ParticleBlend;
+  /** One color, or up to 8 spread over each particle's life (default white). */
+  color?: string | string[];
+  /** Color by speed instead of age: the px/s that reaches the last color. */
+  colorBySpeed?: number;
+  opacity?: number;
+  /** Solver steps per frame (default 2). */
+  substeps?: number;
+  /** Seconds simulated before the first frame, so it starts already full. */
+  prewarm?: number;
+}
+/**
+ * A GPU particle system: tens of thousands of particles simulated in a
+ * compute shader and drawn in one call. Used through `Layer.particles()`.
+ * It steps as the composition renders (snapshots make scrubbing back
+ * cheap), and its drivers are read every frame.
+ */
+declare class Particles extends Effect$1<Record<string, never>> implements ParticleProgram {
+  readonly op = "Particles";
+  readonly particleStatic: ParticleStatic;
+  particleState?: unknown;
+  private readonly options;
+  constructor(options: ParticlesOptions);
+  particleFrame(frame: number, fps: number): ParticleFrame;
+}
+//#endregion
 //#region src/shapes3d.d.ts
 /** Physically based surface options every 3D builder accepts. */
 interface Surface3DOptions {
@@ -2542,6 +3327,524 @@ declare const Lighting: {
   dramatic: (options?: LightingRigOptions) => AnimatableNode<LightNode>[];
 };
 //#endregion
+//#region src/physics/world2d.d.ts
+interface World2DOptions extends PhysicsWorldOptions {
+  /** px/s², y down. A number pulls straight down. Default 2400. */
+  gravity?: number | [number, number];
+}
+/** A plain rectangle for bodies with no layer (invisible obstacles, funnels). */
+interface PhysicsRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  rotation?: number;
+  borderRadius?: number;
+}
+interface Body2DOptions extends BodyCommonOptions {
+  /**
+   * Collider: `"auto"` (default) reads the layer — circles stay circles,
+   * rounded boxes keep their radius, polygons/stars/paths use their convex
+   * hull. Force `"box"`, `"circle"` or `"hull"` (the shape's outline).
+   */
+  shape?: "auto" | "box" | "circle" | "hull";
+  /** Collider size override `[width, height]`, px. Text layers are measured when they have no size. */
+  size?: [number, number];
+  /** px/s. */
+  velocity?: [number, number];
+  /** Degrees per second, clockwise. */
+  angularVelocity?: number;
+  /**
+   * Kinematic bodies: where the layer is each frame, as its own `x` / `y`
+   * (top-left) and `rotation` (degrees). Missing ones keep the start pose.
+   */
+  follow?: {
+    x?: PhysicsDriver;
+    y?: PhysicsDriver;
+    rotation?: PhysicsDriver;
+  };
+}
+type LayerLike$1 = Record<string, unknown> & {
+  kind?: string;
+  animate?: (...a: unknown[]) => unknown;
+};
+/**
+ * A simulated body. Its signals hold one value per composition frame; bind
+ * them to any prop or effect uniform (`.signal("opacity", body.impact)`).
+ * Reading a signal runs the simulation if it has not run yet.
+ */
+declare class PhysicsBody2D implements CoreBody<Vec2$1, number> {
+  /** @internal */readonly world: PhysicsWorld2D;
+  readonly type: "dynamic" | "fixed" | "kinematic";
+  readonly layer: LayerLike$1 | undefined;
+  /** Layer box size (unscaled), scale and pivot, to turn the center back into x/y. */
+  private readonly frame;
+  private readonly options;
+  readonly collisions: PhysicsCollision<PhysicsBody2D>[];
+  /** @internal */
+  readonly recording: Recording;
+  /** @internal */
+  readonly sim: SimBody2D;
+  /** @internal */
+  constructor(/** @internal */world: PhysicsWorld2D, sim: SimBody2D, type: "dynamic" | "fixed" | "kinematic", layer: LayerLike$1 | undefined, /** Layer box size (unscaled), scale and pivot, to turn the center back into x/y. */
+  frame: {
+    width: number;
+    height: number;
+    scale: number;
+    anchorX: number;
+    anchorY: number;
+    rotation: number;
+  }, options: Body2DOptions, recording: Recording);
+  get startFrame(): number;
+  get gravityScale(): number;
+  get output(): Body2DOptions["output"];
+  /** The layer's `x` (top-left) every frame. */
+  get x(): FrameSignal<number>;
+  /** The layer's `y` (top-left) every frame. */
+  get y(): FrameSignal<number>;
+  /** Degrees, clockwise, continuous (no jump at 360). */
+  get rotation(): FrameSignal<number>;
+  /** Body center, px. */
+  get centerX(): FrameSignal<number>;
+  get centerY(): FrameSignal<number>;
+  /** px/s. */
+  get vx(): FrameSignal<number>;
+  get vy(): FrameSignal<number>;
+  /** px/s. */
+  get speed(): FrameSignal<number>;
+  /** Degrees per second. */
+  get angularVelocity(): FrameSignal<number>;
+  /**
+   * Hit envelope: jumps on each new contact (1 ≈ a 1500 px/s velocity
+   * change, see `impactReference`) and decays over `impactDecay` frames.
+   */
+  get impact(): FrameSignal<number>;
+  /** 1 while the body is at rest, else 0. */
+  get sleeping(): FrameSignal<number>;
+  /** @internal */
+  kinematicTarget(frame: number): {
+    position: Vec2$1;
+    rotation: number;
+  } | undefined;
+  private initialLayerXY;
+  /** @internal */
+  record(index: number, previous: number): void;
+  /** @internal */
+  boundChannels(): Array<[AnimatableProp, string]>;
+  /** @internal World-space point (px) → this body's local frame (meters), at the start pose. */
+  localAnchor(point: Vec2$1 | undefined): Vec2$1;
+  /** @internal Start-pose center in px. */
+  center(): Vec2$1;
+}
+/** What a {@link PhysicsWorld2D.field} sees for one body. */
+interface FieldSample2D {
+  /** Body center, px. */
+  x: number;
+  y: number;
+  /** px/s. */
+  vx: number;
+  vy: number;
+  /** Composition frame. */
+  frame: number;
+  body: PhysicsBody2D;
+}
+interface PhysicsSpringOptions {
+  /** Rest length, px (default: the distance at the start). */
+  length?: number;
+  /** Oscillations per second (default 2). Higher is stiffer. */
+  frequency?: number;
+  /** 0 bounces forever, 1 settles without overshoot (default 0.2). */
+  dampingRatio?: number;
+  /** Attachment point on body A, world px at the start (default its center). */
+  anchorA?: [number, number];
+  /** Attachment point on body B (or the world point), world px. */
+  anchorB?: [number, number];
+}
+interface PhysicsRopeOptions {
+  /** Maximum length, px (default: the distance at the start). */
+  length?: number;
+  anchorA?: [number, number];
+  anchorB?: [number, number];
+}
+interface PhysicsGroundOptions {
+  /** Top edge of the ground, px. */
+  y: number;
+  friction?: number;
+  restitution?: number;
+}
+interface PhysicsWallsOptions {
+  x?: number;
+  y?: number;
+  width: number;
+  height: number;
+  /** Close the top too (default false: things can fall in). */
+  ceiling?: boolean;
+  /** Wall thickness outside the box, px (default 400). */
+  thickness?: number;
+  friction?: number;
+  restitution?: number;
+}
+/**
+ * A deterministic 2D rigid-body world (Rapier) in layer pixels. Build it,
+ * add bodies from layers, then `simulate()`: each body's layer is bound to
+ * its simulated `x` / `y` / `rotation`, and every body exposes signals
+ * (`impact`, `speed`, …) for driving anything else. The simulation runs
+ * once while the composition is built, so frames render in any order and
+ * identically on every machine.
+ */
+declare class PhysicsWorld2D extends WorldCore<Vec2$1, number, PhysicsBody2D> {
+  /** @internal */
+  constructor(backend: PhysicsBackend, options: World2DOptions);
+  /**
+   * Adds a body for a layer (absolutely positioned: `x`, `y`, and a size)
+   * or for a plain rectangle. The layer's current pose is the start pose.
+   */
+  body(target: LayoutNode | PhysicsRect, options?: Body2DOptions): PhysicsBody2D;
+  /** A fixed, very wide floor whose top edge sits at `y`. */
+  ground(options: PhysicsGroundOptions): PhysicsBody2D;
+  /** Fixed floor, left and right walls (and optionally a ceiling) around a box, e.g. the canvas. */
+  walls(options: PhysicsWallsOptions): {
+    floor: PhysicsBody2D;
+    left: PhysicsBody2D;
+    right: PhysicsBody2D;
+    ceiling?: PhysicsBody2D;
+  };
+  /** Pins a body to the world at a point (default its center); it can still swing around it. */
+  pin(body: PhysicsBody2D, at?: [number, number]): this;
+  /** Joins two bodies at a world point so they swing around it (a hinge). */
+  hinge(a: PhysicsBody2D, b: PhysicsBody2D, at: [number, number]): this;
+  /** Glues two bodies together rigidly. */
+  weld(a: PhysicsBody2D, b: PhysicsBody2D): this;
+  /** A damped spring between two bodies, or from a body to a world point. */
+  spring(a: PhysicsBody2D, b: PhysicsBody2D | [number, number], options?: PhysicsSpringOptions): this;
+  /** A rope: never longer than `length`, slack when closer. */
+  rope(a: PhysicsBody2D, b: PhysicsBody2D | [number, number], options?: PhysicsRopeOptions): this;
+  /** A steady push, px/s² (mass-independent): wind, magnets, audio. Drivers are read every frame. */
+  force(body: PhysicsBody2D, accel: {
+    x?: PhysicsDriver;
+    y?: PhysicsDriver;
+  }): this;
+  /**
+   * A force field: called for every awake dynamic body (or just `bodies`)
+   * each solver step with its center and velocity in px, px/s; returns an
+   * acceleration `[ax, ay]` px/s² (or nothing). Wind, vortices, magnets,
+   * flow fields, a dancer's silhouette pushing particles.
+   */
+  field(accel: (sample: FieldSample2D) => [number, number] | null | undefined, options?: {
+    bodies?: readonly PhysicsBody2D[];
+  }): this;
+  /** An instant kick at a simulation frame: adds `[vx, vy]` px/s to the body's velocity. */
+  impulse(body: PhysicsBody2D, frame: number, velocity: [number, number]): this;
+  protected lerpRotation(a: number, b: number, t: number): number;
+  private joint;
+  private anchorBody;
+  private endpoints;
+}
+//#endregion
+//#region src/physics/world3d.d.ts
+interface World3DOptions extends PhysicsWorldOptions {
+  /** px/s², y down. A number pulls straight down. Default 2400. */
+  gravity?: number | [number, number, number];
+}
+/** A plain box for bodies with no layer (invisible obstacles). Centered on x/y/z like Layer3D. */
+interface PhysicsBox3D {
+  x: number;
+  y: number;
+  z: number;
+  width: number;
+  height: number;
+  depth: number;
+  rotateX?: number;
+  rotateY?: number;
+  rotateZ?: number;
+}
+interface Body3DOptions extends Omit<BodyCommonOptions, "lockRotation"> {
+  /**
+   * Never rotates (`true`), or only around some axes: `{ x: true, y: true }`
+   * keeps a card facing the camera while it still spins in the picture plane.
+   */
+  lockRotation?: boolean | {
+    x?: boolean;
+    y?: boolean;
+    z?: boolean;
+  };
+  /**
+   * Collider: `"auto"` (default) reads the Layer3D primitive (box, sphere,
+   * cylinder) and falls back to the mesh's convex hull for models and
+   * tapered or uneven shapes. Force `"box"`, `"sphere"`, `"cylinder"` or `"hull"`.
+   */
+  shape?: "auto" | "box" | "sphere" | "cylinder" | "hull";
+  /** Collider size override `[width, height, depth]`, px (before the layer's scale). */
+  size?: [number, number, number];
+  /** px/s. */
+  velocity?: [number, number, number];
+  /** Degrees per second around x, y, z. */
+  angularVelocity?: [number, number, number];
+  /** Kinematic bodies: the layer's `x` / `y` / `z` and `rotateX/Y/Z` each frame. */
+  follow?: {
+    x?: PhysicsDriver;
+    y?: PhysicsDriver;
+    z?: PhysicsDriver;
+    rotateX?: PhysicsDriver;
+    rotateY?: PhysicsDriver;
+    rotateZ?: PhysicsDriver;
+  };
+}
+type LayerLike = Record<string, unknown> & {
+  kind?: string;
+};
+/** Quaternion of the renderer's Euler order: R = Rz · Ry · Rx (degrees). */
+
+/**
+ * A simulated 3D body. Like {@link PhysicsBody2D}, its signals hold one
+ * value per composition frame and reading one runs the simulation.
+ */
+declare class PhysicsBody3D implements CoreBody<Vec3$1, Quat> {
+  /** @internal */readonly world: PhysicsWorld3D;
+  readonly type: "dynamic" | "fixed" | "kinematic";
+  readonly layer: LayerLike | undefined;
+  private readonly start;
+  private readonly options;
+  readonly collisions: PhysicsCollision<PhysicsBody3D>[];
+  /** @internal */
+  readonly recording: Recording;
+  /** @internal */
+  readonly sim: SimBody3D;
+  /** @internal */
+  constructor(/** @internal */world: PhysicsWorld3D, sim: SimBody3D, type: "dynamic" | "fixed" | "kinematic", layer: LayerLike | undefined, start: {
+    position: Vec3$1;
+    rotation: Vec3$1;
+  }, options: Body3DOptions, recording: Recording);
+  get startFrame(): number;
+  get gravityScale(): number;
+  get output(): Body3DOptions["output"];
+  /** Center, px (what Layer3D's `x` / `y` / `z` mean). */
+  get x(): FrameSignal<number>;
+  get y(): FrameSignal<number>;
+  get z(): FrameSignal<number>;
+  /** Degrees, continuous. */
+  get rotateX(): FrameSignal<number>;
+  get rotateY(): FrameSignal<number>;
+  get rotateZ(): FrameSignal<number>;
+  /** px/s. */
+  get vx(): FrameSignal<number>;
+  get vy(): FrameSignal<number>;
+  get vz(): FrameSignal<number>;
+  get speed(): FrameSignal<number>;
+  /** Hit envelope, as on 2D bodies. */
+  get impact(): FrameSignal<number>;
+  /** 1 while the body is at rest, else 0. */
+  get sleeping(): FrameSignal<number>;
+  /** @internal */
+  kinematicTarget(frame: number): {
+    position: Vec3$1;
+    rotation: Quat;
+  } | undefined;
+  /** @internal */
+  record(index: number, previous: number): void;
+  /** @internal */
+  boundChannels(): Array<[AnimatableProp, string]>;
+  /** @internal World point (px) → local frame (meters) at the start pose. */
+  localAnchor(point: Vec3$1 | undefined): Vec3$1;
+  /** @internal Start-pose center, px. */
+  center(): Vec3$1;
+}
+/** What a {@link PhysicsWorld3D.field} sees for one body. */
+interface FieldSample3D {
+  x: number;
+  y: number;
+  z: number;
+  vx: number;
+  vy: number;
+  vz: number;
+  frame: number;
+  body: PhysicsBody3D;
+}
+interface PhysicsSpring3DOptions {
+  length?: number;
+  frequency?: number;
+  dampingRatio?: number;
+  anchorA?: Vec3$1;
+  anchorB?: Vec3$1;
+}
+interface PhysicsRope3DOptions {
+  length?: number;
+  anchorA?: Vec3$1;
+  anchorB?: Vec3$1;
+}
+/**
+ * A deterministic 3D rigid-body world (Rapier) for Layer3D primitives and
+ * models, in the 3D scene's pixels (y down). Same flow as 2D: add bodies,
+ * `simulate()`, and each layer's `x/y/z` and `rotateX/Y/Z` follow the
+ * simulation; bodies expose signals for everything else.
+ */
+declare class PhysicsWorld3D extends WorldCore<Vec3$1, Quat, PhysicsBody3D> {
+  /** @internal */
+  constructor(backend: PhysicsBackend, options: World3DOptions);
+  /** Adds a body for a Layer3D primitive or model (centered on its `x/y/z`), or a plain box. */
+  body(target: LayoutNode | PhysicsBox3D, options?: Body3DOptions): PhysicsBody3D;
+  /** A fixed, very large floor whose top face sits at `y`. */
+  ground(options: {
+    y: number;
+    friction?: number;
+    restitution?: number;
+  }): PhysicsBody3D;
+  /** Fixed floor and four walls around a box centered on `x`/`z`, floor at `y + height/2`. */
+  walls(options: {
+    x?: number;
+    y?: number;
+    z?: number;
+    width: number;
+    height: number;
+    depth: number;
+    thickness?: number;
+    friction?: number;
+    restitution?: number;
+  }): PhysicsBody3D[];
+  /** Pins a body to the world at a point (default its center); it can still turn around it. */
+  pin(body: PhysicsBody3D, at?: Vec3$1): this;
+  /** Joins two bodies at a world point, turning only around `axis` (default z, facing the camera). */
+  hinge(a: PhysicsBody3D, b: PhysicsBody3D, at: Vec3$1, axis?: Vec3$1): this;
+  /** Glues two bodies together rigidly. */
+  weld(a: PhysicsBody3D, b: PhysicsBody3D): this;
+  spring(a: PhysicsBody3D, b: PhysicsBody3D | Vec3$1, options?: PhysicsSpring3DOptions): this;
+  rope(a: PhysicsBody3D, b: PhysicsBody3D | Vec3$1, options?: PhysicsRope3DOptions): this;
+  /** A steady push, px/s² (mass-independent). Drivers are read every frame. */
+  force(body: PhysicsBody3D, accel: {
+    x?: PhysicsDriver;
+    y?: PhysicsDriver;
+    z?: PhysicsDriver;
+  }): this;
+  /** A force field, as in 2D: returns `[ax, ay, az]` px/s² for a body at `x/y/z` px. */
+  field(accel: (sample: FieldSample3D) => Vec3$1 | null | undefined, options?: {
+    bodies?: readonly PhysicsBody3D[];
+  }): this;
+  /** An instant kick at a simulation frame: adds `[vx, vy, vz]` px/s. */
+  impulse(body: PhysicsBody3D, frame: number, velocity: Vec3$1): this;
+  protected lerpRotation(a: Quat, b: Quat, t: number): Quat;
+  private joint;
+  private anchorBody;
+  private endpoints;
+}
+//#endregion
+//#region src/physics/index.d.ts
+/**
+ * Rigid-body physics baked into signals. A world simulates once, while the
+ * composition is built (Rapier's deterministic build, so every machine gets
+ * the same motion), and replays as per-frame signals: layers follow their
+ * bodies, and `impact`, `speed`, … drive any other prop or effect.
+ *
+ * ```ts
+ * const world = await Physics.world2d({ fps: 30, frames: 150 });
+ * world.walls({ width: W, height: H });
+ * const card = world.body(cardLayer, { restitution: 0.4 });
+ * world.simulate();
+ * flash.animate(LayerAnimation.create().signal("opacity", card.impact));
+ * ```
+ */
+declare const Physics: {
+  /** A 2D world in layer pixels (y down). Loads the physics engine on first use. */
+  world2d(options: World2DOptions): Promise<PhysicsWorld2D>;
+  /** A 3D world for Layer3D primitives and models, in scene pixels (y down). */
+  world3d(options: World3DOptions): Promise<PhysicsWorld3D>;
+};
+//#endregion
+//#region src/styles.d.ts
+type Look = Effect$1<object>[];
+declare const Styles: {
+  /** 8-bit game: PICO-8 palette, chunky pixels, light dithering. */
+  pixelArt: (o?: {
+    pixelSize?: number;
+    palette?: "pico8" | "c64" | "cga";
+  }) => Look;
+  /** Original Game Boy: four greens, dithered, big pixels. */
+  gameBoy: (o?: {
+    pixelSize?: number;
+  }) => Look;
+  /** Teletext / Ceefax: eight flat colors in big blocks. */
+  teletext: (o?: {
+    pixelSize?: number;
+  }) => Look;
+  /** LED wall: round lit pixels with gaps. */
+  ledWall: (o?: {
+    size?: number;
+  }) => Look;
+  /** Text-mode art: the clip drawn in characters. `matrix` makes it green phosphor. */
+  ascii: (o?: {
+    cellSize?: number;
+    matrix?: boolean;
+  }) => Look;
+  /** 1-bit print: ordered dither in two inks. */
+  oneBit: (o?: {
+    dark?: string;
+    light?: string;
+    scale?: number;
+  }) => Look;
+  /** Riso print: two inks on paper, ordered dither, grain. */
+  risograph: (o?: {
+    inkA?: string;
+    inkB?: string;
+    paper?: string;
+  }) => Look;
+  /** Cartoon / cel shading with ink outlines. */
+  cartoon: (o?: {
+    levels?: number;
+    ink?: string;
+  }) => Look;
+  /** Comic book: cel shading, ink lines and a halftone dot screen. */
+  comic: (o?: {
+    dotFrequency?: number;
+  }) => Look;
+  /** Thermal camera: brightness mapped to the ironbow palette. */
+  thermal: () => Look;
+  /** VHS tape: wobble, colour bleed, soft scanlines, grain. */
+  vhs: (o?: {
+    tracking?: number;
+  }) => Look;
+  /** An old CRT monitor: curved glass, scanlines, RGB mask. */
+  crt: (o?: {
+    curvature?: number;
+  }) => Look;
+  /** Glitch: hard RGB split plus tracking errors. Animate `amount` for hits. */
+  glitch: (o?: {
+    amount?: number;
+  }) => Look;
+  /** Oil painting. */
+  oilPainting: (o?: {
+    brush?: number;
+  }) => Look;
+  /** Watercolour: soft patches, pigment edges, paper. */
+  watercolor: (o?: {
+    brush?: number;
+  }) => Look;
+  /** Topographic map lines on paper. */
+  topographic: (o?: {
+    levels?: number;
+    ink?: string;
+    paper?: string;
+  }) => Look;
+  /** Kaleidoscope. Animate `rotation` on the returned effect, or pass a fixed angle. */
+  kaleidoscope: (o?: {
+    segments?: number;
+    rotation?: number;
+  }) => Look;
+  /** Op art / line portrait: stripes bent by the image. */
+  opArt: (o?: {
+    pattern?: "stripes" | "rings" | "checker" | "waves";
+    frequency?: number;
+  }) => Look;
+  /** Holographic foil sheen. Animate `shift` to make it move. */
+  holographic: (o?: {
+    strength?: number;
+    shift?: number;
+  }) => Look;
+  /** Black-and-white film noir: crushed tones, grain, vignette. */
+  noir: () => Look;
+  /** Analog film: grain and a soft vignette. */
+  film: () => Look;
+};
+type StyleName = keyof typeof Styles;
+//#endregion
 //#region src/index.d.ts
 interface SectionOptions {
   readonly id?: string;
@@ -2725,6 +4028,8 @@ declare class Composition {
   audioTracks: MediaNode[];
   signals: Record<string, unknown>;
   private _frameHooks;
+  private _prepareHooks;
+  private readonly _clipVision;
   private _visionConfig?;
   private _visionBundle?;
   private _effects;
@@ -2739,6 +4044,28 @@ declare class Composition {
    * Returns the reactive VisionBundle (objects / masks / pose / classes signals).
    */
   withVision(config?: VisionProps | Vision): VisionBundle;
+  /**
+   * Vision for a clip, analysed per frame on demand and shared by everything
+   * that reads it (see {@link ClipVision}): `comp.vision("dancer.mp4").person`
+   * gives pose keypoints and a silhouette at any frame. Each frame is
+   * analysed just before it renders, so nothing runs up front. Results
+   * persist on disk in Node. The same clip and options return one instance.
+   */
+  vision(source: string, options?: ClipVisionOptions): ClipVision;
+  /**
+   * @internal Analyses every `comp.vision` clip up to a composition frame
+   * (frames already analysed are skipped), so consumers that step frame by
+   * frame — physics, particles — always find every frame before it.
+   */
+  prepareVision(frame: number): Promise<void>;
+  /**
+   * Points matte-family `withVision` layers at the `comp.vision` clip they
+   * show, so the cutout reuses that clip's per-frame subject instead of
+   * segmenting the frame again during render. Only layers whose settings
+   * would give the same subject are linked; the rest keep their own pass.
+   */
+  private linkClipMattes;
+  private clipForMatte;
   /**
    * One-shot, ffmpeg-free vision analysis of a media source.
    *
@@ -2765,7 +4092,14 @@ declare class Composition {
    * Invoked before rendering each frame so scripts or agents can mutate properties and signals.
    */
   onRequestFrame(callback: (ctx: FrameContext) => void): this;
-  notifyFrame(ctx: FrameContext): void;
+  /**
+   * Async work a frame needs before it is evaluated (vision, a live physics
+   * world). Every render path awaits these, in order, before drawing the
+   * frame; they may run more than once per frame, so keep them idempotent.
+   */
+  onPrepareFrame(callback: (ctx: FrameContext) => Promise<void> | void): this;
+  notifyFrame(ctx: FrameContext): Promise<void> | undefined;
+  private hasFrameHooks;
   constructor(options: CompositionOptions);
   static create(options: CompositionOptions): Composition;
   addSignal(name: string, signal: unknown): this;
@@ -2916,6 +4250,29 @@ declare const Layer: {
   }) => AnimatableNode<ShapeNode>;
   flex: (options?: Partial<FlexNode>) => AnimatableNode<FlexNode>;
   box: (options?: Partial<BoxNode>) => AnimatableNode<BoxNode>;
+  /**
+   * A GPU particle system as a layer: tens of thousands of particles
+   * simulated in a compute shader and drawn in one call (see
+   * {@link ParticlesOptions}). Positions are in the layer's own px; drivers
+   * (rate, gravity, noise, attractors) are read every frame, and a
+   * performer can push particles with `push: { person }`.
+   */
+  particles: (options: ParticlesOptions) => AnimatableNode<MediaNode>;
+  /**
+   * A procedural VFX layer (smoke, fire, rain, snow, aurora, …) drawn by
+   * the GPU, transparent where there is no effect. Put it above or below
+   * other layers like any clip.
+   */
+  vfx: (options: Partial<ProceduralVFXProps> & {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    id?: string;
+    startFrame?: number;
+    durationFrames?: number;
+    zIndex?: number;
+  }) => AnimatableNode<MediaNode>;
   section: (source: string | MediaNode | Composition, targetOrOptions?: ObjectTrackSignals | SectionOptions, options?: SectionOptions) => SectionNode;
   trackedRegion: (source: string | MediaNode, target: ObjectTrackSignals, options?: TrackedRegionOptions) => SectionNode;
   blurTrackedRegion: (source: string | MediaNode, target: ObjectTrackSignals, options?: Partial<BlurProps> & {
@@ -2985,6 +4342,7 @@ declare function blurRegion(sourceOrLayer: string | AnimatableNode<MediaNode>, t
 }): AnimatableNode<MediaNode> | AnimatableNode<BoxNode>;
 declare function editTrackedRegion(source: string | MediaNode, target: ObjectTrackSignals, options?: TrackedRegionOptions): SectionNode;
 declare const Effect: typeof Effect$1 & {
+  readonly ascii: (config?: AsciiProps) => Ascii;
   readonly audioCompressor: (config?: AudioCompressorProps) => AudioCompressor;
   readonly audioDelay: (config?: AudioDelayProps) => AudioDelay;
   readonly audioFade: (config?: AudioFadeProps) => AudioFade;
@@ -2997,24 +4355,38 @@ declare const Effect: typeof Effect$1 & {
   readonly channelSplitter: (config?: ChannelSplitterProps) => ChannelSplitter;
   readonly colorBalance: (config?: ColorBalanceProps) => ColorBalance;
   readonly colorKey: (config?: ColorKeyProps) => ColorKey;
+  readonly contour: (config?: ContourProps) => Contour;
   readonly cornerPin: (config?: CornerPinProps) => CornerPin;
+  readonly cRT: (config?: CRTProps) => CRT;
+  readonly datamosh: (config?: DatamoshProps) => Datamosh;
   readonly displacementMap: (config?: DisplacementMapProps) => DisplacementMap;
+  readonly dither: (config?: DitherProps) => Dither;
   readonly extractLUT: (config?: ExtractLUTProps) => ExtractLUT;
   readonly flip: (config?: FlipProps) => Flip;
+  readonly gooey: (config?: GooeyProps) => Gooey;
+  readonly iridescence: (config?: IridescenceProps) => Iridescence;
+  readonly kaleidoscope: (config?: KaleidoscopeProps) => Kaleidoscope;
   readonly kenBurns: (config?: KenBurnsProps) => KenBurns;
   readonly layerStyle: (config?: LayerStyleProps) => LayerStyle;
   readonly liquify: (config?: LiquifyProps) => Liquify;
   readonly maskMath: (config?: MaskMathProps) => MaskMath;
   readonly meshWarp: (config?: MeshWarpProps) => MeshWarp;
   readonly noiseGenerator: (config?: NoiseGeneratorProps) => NoiseGenerator;
+  readonly opArt: (config?: OpArtProps) => OpArt;
   readonly paint: (config?: PaintProps) => Paint;
+  readonly painterly: (config?: PainterlyProps) => Painterly;
   readonly patchHeal: (config?: PatchHealProps) => PatchHeal;
+  readonly pixelate: (config?: PixelateProps) => Pixelate;
+  readonly posterize: (config?: PosterizeProps) => Posterize;
   readonly proceduralVFX: (config?: ProceduralVFXProps) => ProceduralVFX;
   readonly refineEdge: (config?: RefineEdgeProps) => RefineEdge;
   readonly refractionCaustics3D: (config?: RefractionCaustics3DProps) => RefractionCaustics3D;
   readonly resizerScaler: (config?: ResizerScalerProps) => ResizerScaler;
+  readonly rGBSplit: (config?: RGBSplitProps) => RGBSplit;
   readonly rotate: (config?: RotateProps) => Rotate;
   readonly stereoPanning: (config?: StereoPanningProps) => StereoPanning;
+  readonly toon: (config?: ToonProps) => Toon;
+  readonly trails: (config?: TrailsProps) => Trails;
   readonly vignette: (config?: VignetteProps) => Vignette;
 } & {
   blur: (config?: BlurProps) => Blur;
@@ -3045,5 +4417,5 @@ declare const Effect: typeof Effect$1 & {
 };
 type Effect<TConfig extends object = Record<string, unknown>> = Effect$1<TConfig>;
 //#endregion
-export { type AETextAnimator, AETextAnimatorSchema, type AdvancedTextAnimator, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, type AnchorGrouping, AnchorGroupingSchema, type AnchorPreset, AnchorPresetSchema, type AnimatableGlyphProps, AnimatableGlyphPropsSchema, AnimatableNode, type AnimatableProp, type AnimationClip3D, type AnimationTrack, AnimationType, AnimationTypeSchema, AnyOutputUnion, AnyOutputUnionSchema, ApplyLUT, type ApplyLUTProps, type ArcLengthLUTEntry, AudioCompressor, type AudioCompressorProps, AudioDelay, type AudioDelayProps, AudioExtractorSignalData, AudioExtractorSignalDataSchema, AudioFade, type AudioFadeProps, type AudioLatentData, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, AudioNoiseGate, type AudioNoiseGateProps, AudioParametricEq, type AudioParametricEqProps, type AudioQaStats, AudioReverb, type AudioReverbProps, AudioSignal, AudioSignalExtractor, type AudioSignalExtractorProps, type AudioSignalOptions, type AudioSpectrumTypography, AudioSpectrumTypographySchema, BaseMediaOperationProps, BaseMediaOperationPropsSchema, BaseVideoLayerProps, BaseVideoLayerPropsSchema, BezierSegment3D, type BlendMode, type BlockNode, type BloomConfig, BloomConfigSchema, Blur, type BlurProps, type Bone3D, type BoxNode, BoxNodeSchema, CAPTION_LAYER_DEFAULTS, COCO17_BONES, COCO17_KEYPOINTS, COCO17_KEYPOINT_NAMES, COCO_CLASSES, COMPOSITE_OPERATIONS, COMPOSITOR_DEFAULTS, Camera3D, Camera3DPose, CameraAnimation, type CameraDoF, type CameraLens, type CameraNode, CameraNodeSchema, CameraParallax3D, type CameraParallax3DProps, type CameraShake, CameraShakeOptions, CannyComputePipeline, type CannyOptions, type Carousel3DOptions, type CarrierHandoffConfig, CarrierHandoffConfigSchema, type CarrierState, CatmullRomOptions, ChannelMerger, type ChannelMergerProps, ChannelSplitter, type ChannelSplitterProps, type ChartAnimationOptions, type ChartAxisOptions, type ChartCandle, type ChartDatum, type ChartOptions, type ChartPadding, type ChartSeries, type ChartSlice, type ChartType, type ChartX, type ChromaticGlitchConfig, ChromaticGlitchConfigSchema, CirclePathOptions, Color, ColorBalance, type ColorBalanceProps, ColorKey, type ColorKeyProps, type ColorSignalOptions, type ColorStop, ColorStopLike, ColorStopSchema, Composition, CompositionOptions, type CompositorProgramConfig, CompositorProgramSchema, type CompositorToProgramOptions, ConfigHandle, ConfigHandleSchema, ConfigSchemaRegistry, ConnectedInput, type ControlNetConditioningOutputs, ControlNetMultiplexer, CornerPin, type CornerPinProps, Crop, type CropProps, type Cube3DOptions, type CubeFaceConfig, type CubeFaceInput, type CubicBezierSegment, CubicBezierSegmentSchema, Curves, type CurvesChannelPoint, type CurvesProps, CustomEffect, type Cylinder3DOptions, DATA_TYPE_EXTENSIONS, DEFAULT_CHART_COLORS, DEFAULT_DURATION_MS, DEFAULT_FPS, DEFAULT_MEDIA_DIMENSION, DataForType, DataType, DataTypeEnum, DataTypeVal, DataTypes, type DeflickerOptions, type DeflickerProps, DepthNormalsComputePipeline, type DepthNormalsOptions, DepthOfField, type DepthOfFieldProps, type DetectedObject, DisplacementMap, type DisplacementMapProps, type DynamicStrokeProperties, DynamicStrokePropertiesSchema, ENVIRONMENT_PRESETS, type EaseRef, Easing, EditableObjectTrack, Effect, EffectConfig, EffectConfigValue, EffectPipeline, type EnhancedTextNode, EnhancedTextNodeSchema, Environment3DFog, Environment3DOptions, type EnvironmentFog, EnvironmentFogSchema, EnvironmentOptions, type EnvironmentPreset, EnvironmentPresetSchema, ExportResult, ExportResultSchema, type ExpressionEvaluationContext, type ExpressionSelector, ExpressionSelectorSchema, type ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, ExtendedLayer, ExtendedLayerSchema, ExtractLUT, type ExtractLUTProps, type ExtractedAudioSignalsBundle, type ExtrudedText3DOptions, FaceLandmarksOptions, FileAsset, FileAssetSchema, FileData, FileDataSchema, FilmGrain, type FilmGrainProps, type FlexNode, FlexNodeSchema, Flip, type FlipProps, FontManager, FrameContext, type FrameGridOptions, type FrameGridRenderable, type FrameSamplePoint, type FrameSignal, type FromToOptions, FrustumPlane, FrustumPlanes, type GPULightData, GPUTextureBinding, GateSignalOptions, GeneratorSignalData, GeneratorSignalDataSchema, GlassPipeline, GlobalCompositeOperation, type GlyphAnchorGrouping, GlyphAnchorGroupingSchema, type GlyphAnchorPoint, GlyphAnchorPointSchema, type GpuAdapterDescription, Gradient, GradientMap, type GradientMapProps, type GradientMapStop, GradientType, type Grid3DOptions, type HalftoneDotShape, type HalftoneMode, HalftoneScreen, type HalftoneScreenProps, HandleType, HandleTypeVal, HeadlessMediaRenderer, HeadlessWebGPURenderer, HelixOptions, HighPass, type HighPassProps, type InstanceMask, InterpolateOptions, JsonArray, JsonObject, JsonValue, JsonValueSchema, KenBurns, type KenBurnsProps, type Keyframe, type KeyframeTuple, type KineticMarqueeConfig, KineticMarqueeConfigSchema, LIGHT_UNIFORM_SIZE_BYTES, type Landmark3D, type LandmarkCoordinateSignals, Layer, Layer3D, LayerAnimation, LayerStyle, type LayerStyleProps, type LayoutNode, LayoutNodeSchema, type LevelChannel, Levels, type LevelsProps, Light, Light3D, type Light3DOptions, LightKind, type LightNode, LightNodeSchema, type LightType, LightTypeSchema, Lighting, type LightingRig, type LightingRigOptions, LightsUniformData, type LineSpacingDynamics, LineSpacingDynamicsSchema, Liquify, type LiquifyProps, type LoadModelOptions, type LongShadowConfig, LongShadowConfigSchema, MAX_GRADIENT_STOPS, MAX_LIGHTS, MIME_TYPES, type MarkOptions, MaskMath, type MaskMathProps, type MaskTrackSignals, Mat4, type Material3D, type MaterialType, MaterialTypeSchema, Matrix4Math, type MatteMode, MatteModeSchema, type MeasureTextOptions, type MeasuredGlyph, Media, MediaMetadata, MediaMetadataSchema, type MediaNode, MediaNodeSchema, MediaOperation, MediaOperationSchema, MediaService, MediaSourceDescriptor, MediaSourceInput, MediaSourceSchema, type Mesh3DData, MeshAudioDeformConfig, MeshWarp, type MeshWarpProps, type Model3DData, type Model3DNode, Model3DNodeSchema, ModerationError, ModerationUnrefundableError, Modulate, type ModulateProps, MotionBlur, MotionBlurPipeline, type MotionBlurProps, MultiOutputGeneric, MultiOutputGenericSchema, type NodeAnimationTrack3D, NodeMetadata, NodeMetadataSchema, NodeProcessorContext, NodeProcessorParams, NodeResult, NodeResultSchema, NodeRunFunction, NodeValidationFn, NodeVisualConfig, NodeVisualConfigSchema, NoiseGenerator, type NoiseGeneratorProps, type NormalRelightingOptions, type NormalizedLandmarkList, type ObjectAnchorName, type ObjectAnchorsSignals, type ObjectBoundingBox, type ObjectBoundingBoxSignals, type ObjectCollectionSignals, type ObjectKinematicsSignals, type ObjectTrackSignals, OpticalFlowComputePipeline, type OpticalFlowOptions, Output, OutputItem, OutputItemSchema, PBRGlass, type PBRGlassProps, Paint, type PaintProps, ParsedGradient, ParsedGradientStop, type ParticleDissolveConfig, ParticleDissolveConfigSchema, PatchHeal, type PatchHealProps, Path3D, Path3DPoint, Path3DSample, type PathChainLUT, type PathChainLUTEntry, type PersonMatte, type PinToLandmarkOptions, type PinToObjectOptions, type Plane3DOptions, type PoseLandmarkSignals, type PoseResult, PoseSkeletonOptions, PoseSkeletonRenderer, type PreviewCloseReason, type PreviewOptions, type PreviewSession, type PreviewSource, type Primitive3DNodeOptions, type Prism3DOptions, ProceduralVFX, type ProceduralVFXProps, ProgrammaticSignal, ProgrammaticSignalOptions, type QaIssue, type QaSegment, RefineEdge, type RefineEdgeProps, RefractionCaustics3D, type RefractionCaustics3DProps, type RegisterFontOptions, type RegisteredFont, Relight3D, type Relight3DProps, type RenderContextValue, RenderDiagnostic, type RenderProgress, RenderVideoOptions, RenderVideoResult, type RenderedSfx, Renderer2D, Renderer3D, ResizerScaler, type ResizerScalerProps, ResolvedEnvironment, Rgba, Rotate, type RotateProps, type RoundedBox3DOptions, SSAO, SSAOPipeline, type SSAOProps, Scene, type SceneDefinition, SceneDefinitionSchema, type SceneOptions, type SceneSequenceOptions, type SceneTransitionType, SceneTransitionTypeSchema, SectionNode, SectionOptions, SegmentationOptions, type SegmentationResult, SegmentationTexturePool, SelectiveColor, type SelectiveColorAdjustment, type SelectiveColorProps, type SelectorBasedOn, SelectorBasedOnSchema, type SelectorMode, SelectorModeSchema, type SelectorShape, SelectorShapeSchema, type SelectorUnits, SelectorUnitsSchema, Sequence, type SequenceEntry, type SequenceNode, type SequenceOptions, type SequenceTimelineResult, type SfxRenderContext, type SfxTrigger, ShadowPipeline, ShadowUniformInfo, ShadowsHighlights, type ShadowsHighlightsProps, type Shape3DContainer, type ShapeNode, ShapeNodeSchema, Signal, SignalBuilderConfig, SignalChannelMeta, SignalChannelMetaSchema, type SignalContext, SignalData, SignalDataSchema, SignalGateData, SignalGateDataSchema, SignalMathData, SignalMathDataSchema, SignalStats, SignalStatsSchema, type SignalTrackOptions, type SignalValue, type SineSignalOptions, SingleOutputGeneric, SingleOutputGenericSchema, type Skeleton3D, type SkewProperties, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SmartFramingOptions, SourceOperationSchema, type Spatial3DProperties, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, type Sphere3DOptions, SpringConfig, type SpringOptions, type SpringPhysics, SpringPhysicsSchema, StereoPanning, type StereoPanningProps, StorageService, StrokeRect, SubjectOutlineOptions, SubjectSandwichOptions, type Surface3DOptions, TEXT_LAYER_DEFAULTS, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, TensorData, type TensorDimensions, type TensorFormat, type TensorNode, TensorPipeline, type TensorPipelineConfig, type TensorSource, type TensorViewExport, type Text3DOptions, type TextAnchorConfig, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, type TextCursorConfig, TextCursorConfigSchema, type TextCursorStyle, TextCursorStyleSchema, TextMeasureResult, TextMeasureStyle, type TextMetrics, type TextNode, TextNodeSchema, TextOperationSchema, TextPathBuilder, type TextPathOptions, TextPathOptionsSchema, type TextPathSource, TextPathSourceSchema, type TextRangeSelector, TextRangeSelectorSchema, type TextScrambleConfig, TextScrambleConfigSchema, type TextSelector, TextSelectorSchema, type TextSignalSelector, TextSignalSelectorSchema, type TextSpan, type TextSpanItem, type TextSpanMark, TextSpanMarkSchema, TextSpanSchema, type TextWigglySelector, TextWigglySelectorSchema, TileOffset, type TileOffsetEdgeMode, type TileOffsetProps, TimelineSegmentSchema, TimelineTransform, TimelineTransformSchema, type ToneMapping, ToneMappingSchema, TrackEditing, type TrackSource, type TrackedObject, TrackedRegionOptions, Transition, type TransitionDirection, TransitionSchema, type TransitionSpec, TransitionType, TransitionTypeSchema, type TypewriterAnimator, TypewriterAnimatorSchema, type TypingCadence, TypingCadenceSchema, UnsharpMask, type UnsharpMaskProps, type VariableFontAxes, VariableFontAxesSchema, type Vec2, Vec2Schema, Vec3, Vector3Math, VideoAnimation, VideoAnimationSchema, VideoLayerType, VideoLayerTypeSchema, type VideoQaOptions, type VideoQaReport, type VideoQaStats, VideoSpatialPropsSchema, VideoStylePropsSchema, VideoTextPropsSchema, VideoTimingPropsSchema, Vignette, type VignetteProps, VirtualMediaData, VirtualMediaDataSchema, Vision, type VisionAnalysisReport, VisionBundle, type VisionConfig, VisionNode, VisionNodeSpec, type VisionProps, VisionRunner, type VisionTask, type VisionVariant, type VolumetricFormationConfig, VolumetricFormationConfigSchema, type VolumetricFormationMode, VolumetricFormationModeSchema, type WiggleOptions, WritableSignal, XYPosition, accent, analyzeSequence, appendOperation, applyStaggerToChildren, bezier, blurRegion, bold, buildPathLUT, calculateSequenceTimeline, checkNodeResultCache, code, collectNodeOps, color, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeGridLayout, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, computeStrokeRect, computeVideoCropRenderProps, computed, cosineSignal, createOutputItemSchema, createVirtualMedia, dataTypeColors, describeGpu, deserializeSignalData, deterministicWigglyNoise, distanceToCurveParameter, editTrackedRegion, effectFactories, effectMeta, ellipseToCubicBeziers, encodeStereoWav, ensureDevice, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSkewMatrix, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, extractSvgDimensions, findSourceAsset, formatHex, formatQaReport, frameArraySignal, frameSignal, generateArcLengthLUT, generateId, generatePathSegments, getActiveMediaMetadata, getFileDataMetadata, getFingerprint, getLeafMediaType, getMediaType, getRenderFingerprint, getScramblePool, getShuffledOrder, gradientStopsToOklab, hasOnlySingleSource, hoistMattes, inputStore, interpolate, isCssGradient, isEqual, isSignal, isVirtualMediaData, italic, limitGradientStops, lintComposition, loadFBX, loadModel3D, loadOBJ, lutStore, mapBlendModeToSkia, mark, measureSpring, measureText, measureTextAsync, mergeAnimationTracks, mixAudioTracks, mixColors, mixSfxInto, normalizeColorStops, normalizeTextSpans, oklabToRgb, parseColorToRgb, parseCssColor, parseCssGradient, parseFBX, parseMTL, parseMarkup, parseOBJ, parseSvgPathToCubicBeziers, pinNodeToLandmark, pinNodeToObject, preloadCompositionFonts, preloadFont, programmaticSignal, progressSignal, registerSignalDependency, renderFrameGrid, renderSemaphore, renderSfx, reportRenderDiagnostic, requiresIsolation, resetRenderCaches, resolveBoolean, resolveEnvironment, resolveMediaMimeType, resolveNumber, resolveParam, resolveSamplePoints, resolveString, rgbToOklab, rich, sampleAudioSpectrumScale, sampleColorStops, sampleCurveGeometry, samplePathChainGeometry, section, serializeSignalData, shaderStore, signal, signalBuilder, signalRegistry, sineSignal, size, softLimit, span, spring, springCalculation, stampResult, startPreview, sub, sup, takeRenderDiagnostics, textureCache, timeSignal, updateClockSignals, waveToCubicBeziers };
+export { type AETextAnimator, AETextAnimatorSchema, type AdvancedTextAnimator, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, type AnchorGrouping, AnchorGroupingSchema, type AnchorPreset, AnchorPresetSchema, type AnimatableGlyphProps, AnimatableGlyphPropsSchema, AnimatableNode, type AnimatableProp, type AnimationClip3D, type AnimationTrack, AnimationType, AnimationTypeSchema, AnyOutputUnion, AnyOutputUnionSchema, ApplyLUT, type ApplyLUTProps, type ArcLengthLUTEntry, Ascii, type AsciiProps, AudioCompressor, type AudioCompressorProps, AudioDelay, type AudioDelayProps, AudioExtractorSignalData, AudioExtractorSignalDataSchema, AudioFade, type AudioFadeProps, type AudioLatentData, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, AudioNoiseGate, type AudioNoiseGateProps, AudioParametricEq, type AudioParametricEqProps, type AudioQaStats, AudioReverb, type AudioReverbProps, AudioSignal, AudioSignalExtractor, type AudioSignalExtractorProps, type AudioSignalOptions, type AudioSpectrumTypography, AudioSpectrumTypographySchema, BaseMediaOperationProps, BaseMediaOperationPropsSchema, BaseVideoLayerProps, BaseVideoLayerPropsSchema, BezierSegment3D, type BlendMode, type BlockNode, type BloomConfig, BloomConfigSchema, Blur, type BlurProps, type Body2DOptions, type Body3DOptions, type BodyCommonOptions, type Bone3D, type BoxNode, BoxNodeSchema, CAPTION_LAYER_DEFAULTS, COCO17_BONES, COCO17_KEYPOINTS, COCO17_KEYPOINT_NAMES, COCO_CLASSES, COMPOSITE_OPERATIONS, COMPOSITOR_DEFAULTS, CRT, type CRTProps, Camera3D, Camera3DPose, CameraAnimation, type CameraDoF, type CameraLens, type CameraNode, CameraNodeSchema, CameraParallax3D, type CameraParallax3DProps, type CameraShake, CameraShakeOptions, CannyComputePipeline, type CannyOptions, type Carousel3DOptions, type CarrierHandoffConfig, CarrierHandoffConfigSchema, type CarrierState, CatmullRomOptions, ChannelMerger, type ChannelMergerProps, ChannelSplitter, type ChannelSplitterProps, type ChartAnimationOptions, type ChartAxisOptions, type ChartCandle, type ChartDatum, type ChartOptions, type ChartPadding, type ChartSeries, type ChartSlice, type ChartType, type ChartX, type ChromaticGlitchConfig, ChromaticGlitchConfigSchema, CirclePathOptions, ClipVision, type ClipVisionOptions, Color, ColorBalance, type ColorBalanceProps, ColorKey, type ColorKeyProps, type ColorSignalOptions, type ColorStop, ColorStopLike, ColorStopSchema, Composition, CompositionOptions, type CompositorProgramConfig, CompositorProgramSchema, type CompositorToProgramOptions, ConfigHandle, ConfigHandleSchema, ConfigSchemaRegistry, ConnectedInput, Contour, type ContourProps, type ControlNetConditioningOutputs, ControlNetMultiplexer, CornerPin, type CornerPinProps, Crop, type CropProps, type Cube3DOptions, type CubeFaceConfig, type CubeFaceInput, type CubicBezierSegment, CubicBezierSegmentSchema, Curves, type CurvesChannelPoint, type CurvesProps, CustomEffect, type Cylinder3DOptions, DATA_TYPE_EXTENSIONS, DEFAULT_CHART_COLORS, DEFAULT_DURATION_MS, DEFAULT_FPS, DEFAULT_MEDIA_DIMENSION, DataForType, DataType, DataTypeEnum, DataTypeVal, DataTypes, Datamosh, type DatamoshProps, type DeflickerOptions, type DeflickerProps, DepthNormalsComputePipeline, type DepthNormalsOptions, DepthOfField, type DepthOfFieldProps, type DetectedObject, DisplacementMap, type DisplacementMapProps, Dither, type DitherProps, type DynamicStrokeProperties, DynamicStrokePropertiesSchema, ENVIRONMENT_PRESETS, type EaseRef, Easing, EditableObjectTrack, Effect, EffectConfig, EffectConfigValue, EffectPipeline, type EmitterShape, type EnhancedTextNode, EnhancedTextNodeSchema, Environment3DFog, Environment3DOptions, type EnvironmentFog, EnvironmentFogSchema, EnvironmentOptions, type EnvironmentPreset, EnvironmentPresetSchema, ExportResult, ExportResultSchema, type ExpressionEvaluationContext, type ExpressionSelector, ExpressionSelectorSchema, type ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, ExtendedLayer, ExtendedLayerSchema, ExtractLUT, type ExtractLUTProps, type ExtractedAudioSignalsBundle, type ExtrudedText3DOptions, FaceLandmarksOptions, type FieldSample2D, type FieldSample3D, FileAsset, FileAssetSchema, FileData, FileDataSchema, FilmGrain, type FilmGrainProps, type FlexNode, FlexNodeSchema, Flip, type FlipProps, FontManager, FrameContext, type FrameGridOptions, type FrameGridRenderable, type FrameSamplePoint, type FrameSignal, type FromToOptions, FrustumPlane, FrustumPlanes, type GPULightData, GPUTextureBinding, GateSignalOptions, GeneratorSignalData, GeneratorSignalDataSchema, GlassPipeline, GlobalCompositeOperation, type GlyphAnchorGrouping, GlyphAnchorGroupingSchema, type GlyphAnchorPoint, GlyphAnchorPointSchema, Gooey, type GooeyProps, type GpuAdapterDescription, Gradient, GradientMap, type GradientMapProps, type GradientMapStop, GradientType, type Grid3DOptions, type HalftoneDotShape, type HalftoneMode, HalftoneScreen, type HalftoneScreenProps, HandleType, HandleTypeVal, HeadlessMediaRenderer, HeadlessWebGPURenderer, HelixOptions, HighPass, type HighPassProps, type InstanceMask, InterpolateOptions, Iridescence, type IridescenceProps, JsonArray, JsonObject, JsonValue, JsonValueSchema, Kaleidoscope, type KaleidoscopeProps, KenBurns, type KenBurnsProps, type Keyframe, type KeyframeTuple, type KineticMarqueeConfig, KineticMarqueeConfigSchema, LIGHT_UNIFORM_SIZE_BYTES, type Landmark3D, type LandmarkCoordinateSignals, Layer, Layer3D, LayerAnimation, LayerStyle, type LayerStyleProps, type LayoutNode, LayoutNodeSchema, type LevelChannel, Levels, type LevelsProps, Light, Light3D, type Light3DOptions, LightKind, type LightNode, LightNodeSchema, type LightType, LightTypeSchema, Lighting, type LightingRig, type LightingRigOptions, LightsUniformData, type LineSpacingDynamics, LineSpacingDynamicsSchema, Liquify, type LiquifyProps, type LoadModelOptions, type LongShadowConfig, LongShadowConfigSchema, MAX_GRADIENT_STOPS, MAX_LIGHTS, MIME_TYPES, type MarkOptions, MaskMath, type MaskMathProps, type MaskTrackSignals, Mat4, type Material3D, type MaterialType, MaterialTypeSchema, Matrix4Math, type MatteMode, MatteModeSchema, type MeasureTextOptions, type MeasuredGlyph, Media, MediaMetadata, MediaMetadataSchema, type MediaNode, MediaNodeSchema, MediaOperation, MediaOperationSchema, MediaService, MediaSourceDescriptor, MediaSourceInput, MediaSourceSchema, type Mesh3DData, MeshAudioDeformConfig, MeshWarp, type MeshWarpProps, type Model3DData, type Model3DNode, Model3DNodeSchema, ModerationError, ModerationUnrefundableError, Modulate, type ModulateProps, MotionBlur, MotionBlurPipeline, type MotionBlurProps, MultiOutputGeneric, MultiOutputGenericSchema, type NodeAnimationTrack3D, NodeMetadata, NodeMetadataSchema, NodeProcessorContext, NodeProcessorParams, NodeResult, NodeResultSchema, NodeRunFunction, NodeValidationFn, NodeVisualConfig, NodeVisualConfigSchema, NoiseGenerator, type NoiseGeneratorProps, type NormalRelightingOptions, type NormalizedLandmarkList, type ObjectAnchorName, type ObjectAnchorsSignals, type ObjectBoundingBox, type ObjectBoundingBoxSignals, type ObjectCollectionSignals, type ObjectKinematicsSignals, type ObjectTrackSignals, OpArt, type OpArtProps, OpticalFlowComputePipeline, type OpticalFlowOptions, Output, OutputItem, OutputItemSchema, PBRGlass, type PBRGlassProps, Paint, type PaintProps, Painterly, type PainterlyProps, ParsedGradient, ParsedGradientStop, type ParticleBlend, type ParticleBounds, type ParticleDissolveConfig, ParticleDissolveConfigSchema, type ParticleShape, Particles, type ParticlesOptions, PatchHeal, type PatchHealProps, Path3D, Path3DPoint, Path3DSample, type PathChainLUT, type PathChainLUTEntry, type PersonMatte, type PersonPlacement, PersonTrack, Physics, type PhysicsBakeOptions, PhysicsBody2D, PhysicsBody3D, type PhysicsBox3D, type PhysicsCollision, type PhysicsDriver, type PhysicsGroundOptions, type PhysicsRect, type PhysicsRope3DOptions, type PhysicsRopeOptions, type PhysicsSpring3DOptions, type PhysicsSpringOptions, type PhysicsWallsOptions, PhysicsWorld2D, PhysicsWorld3D, type PhysicsWorldOptions, type PinToLandmarkOptions, type PinToObjectOptions, Pixelate, type PixelateProps, type Plane3DOptions, type PoseKeypointName, type PoseLandmarkSignals, type PoseResult, PoseSkeletonOptions, PoseSkeletonRenderer, Posterize, type PosterizeProps, type PreviewCloseReason, type PreviewOptions, type PreviewSession, type PreviewSource, type Primitive3DNodeOptions, type Prism3DOptions, ProceduralVFX, type ProceduralVFXProps, ProgrammaticSignal, ProgrammaticSignalOptions, type QaIssue, type QaSegment, RGBSplit, type RGBSplitProps, RefineEdge, type RefineEdgeProps, RefractionCaustics3D, type RefractionCaustics3DProps, type RegisterFontOptions, type RegisteredFont, Relight3D, type Relight3DProps, type RenderContextValue, RenderDiagnostic, type RenderProgress, RenderVideoOptions, RenderVideoResult, type RenderedSfx, Renderer2D, Renderer3D, ResizerScaler, type ResizerScalerProps, ResolvedEnvironment, Rgba, Rotate, type RotateProps, type RoundedBox3DOptions, SSAO, SSAOPipeline, type SSAOProps, Scene, type SceneDefinition, SceneDefinitionSchema, type SceneOptions, type SceneSequenceOptions, type SceneTransitionType, SceneTransitionTypeSchema, SectionNode, SectionOptions, SegmentationOptions, type SegmentationResult, SegmentationTexturePool, SelectiveColor, type SelectiveColorAdjustment, type SelectiveColorProps, type SelectorBasedOn, SelectorBasedOnSchema, type SelectorMode, SelectorModeSchema, type SelectorShape, SelectorShapeSchema, type SelectorUnits, SelectorUnitsSchema, Sequence, type SequenceEntry, type SequenceNode, type SequenceOptions, type SequenceTimelineResult, type SfxRenderContext, type SfxTrigger, ShadowPipeline, ShadowUniformInfo, ShadowsHighlights, type ShadowsHighlightsProps, type Shape3DContainer, type ShapeNode, ShapeNodeSchema, Signal, SignalBuilderConfig, SignalChannelMeta, SignalChannelMetaSchema, type SignalContext, SignalData, SignalDataSchema, SignalGateData, SignalGateDataSchema, SignalMathData, SignalMathDataSchema, SignalStats, SignalStatsSchema, type SignalTrackOptions, type SignalValue, type SineSignalOptions, SingleOutputGeneric, SingleOutputGenericSchema, type Skeleton3D, type SkewProperties, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SmartFramingOptions, SourceOperationSchema, type Spatial3DProperties, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, type Sphere3DOptions, SpringConfig, type SpringOptions, type SpringPhysics, SpringPhysicsSchema, StereoPanning, type StereoPanningProps, StorageService, StrokeRect, type StyleName, Styles, SubjectOutlineOptions, SubjectSandwichOptions, type Surface3DOptions, TEXT_LAYER_DEFAULTS, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, TensorData, type TensorDimensions, type TensorFormat, type TensorNode, TensorPipeline, type TensorPipelineConfig, type TensorSource, type TensorViewExport, type Text3DOptions, type TextAnchorConfig, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, type TextCursorConfig, TextCursorConfigSchema, type TextCursorStyle, TextCursorStyleSchema, TextMeasureResult, TextMeasureStyle, type TextMetrics, type TextNode, TextNodeSchema, TextOperationSchema, TextPathBuilder, type TextPathOptions, TextPathOptionsSchema, type TextPathSource, TextPathSourceSchema, type TextRangeSelector, TextRangeSelectorSchema, type TextScrambleConfig, TextScrambleConfigSchema, type TextSelector, TextSelectorSchema, type TextSignalSelector, TextSignalSelectorSchema, type TextSpan, type TextSpanItem, type TextSpanMark, TextSpanMarkSchema, TextSpanSchema, type TextWigglySelector, TextWigglySelectorSchema, TileOffset, type TileOffsetEdgeMode, type TileOffsetProps, TimelineSegmentSchema, TimelineTransform, TimelineTransformSchema, type ToneMapping, ToneMappingSchema, Toon, type ToonProps, TrackEditing, type TrackSource, type TrackedObject, TrackedRegionOptions, Trails, type TrailsProps, Transition, type TransitionDirection, TransitionSchema, type TransitionSpec, TransitionType, TransitionTypeSchema, type TypewriterAnimator, TypewriterAnimatorSchema, type TypingCadence, TypingCadenceSchema, UnsharpMask, type UnsharpMaskProps, type VariableFontAxes, VariableFontAxesSchema, type Vec2, Vec2Schema, Vec3, Vector3Math, VideoAnimation, VideoAnimationSchema, VideoLayerType, VideoLayerTypeSchema, type VideoQaOptions, type VideoQaReport, type VideoQaStats, VideoSpatialPropsSchema, VideoStylePropsSchema, VideoTextPropsSchema, VideoTimingPropsSchema, Vignette, type VignetteProps, VirtualMediaData, VirtualMediaDataSchema, Vision, type VisionAnalysisReport, VisionBundle, type VisionConfig, VisionNode, VisionNodeSpec, type VisionProps, VisionRunner, type VisionTask, type VisionVariant, type VolumetricFormationConfig, VolumetricFormationConfigSchema, type VolumetricFormationMode, VolumetricFormationModeSchema, type WiggleOptions, type World2DOptions, type World3DOptions, WritableSignal, XYPosition, accent, analyzeSequence, appendOperation, applyStaggerToChildren, bezier, blurRegion, bold, buildPathLUT, calculateSequenceTimeline, checkNodeResultCache, code, collectNodeOps, color, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeGridLayout, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, computeStrokeRect, computeVideoCropRenderProps, computed, cosineSignal, createOutputItemSchema, createVirtualMedia, dataTypeColors, describeGpu, deserializeSignalData, deterministicWigglyNoise, distanceToCurveParameter, editTrackedRegion, effectFactories, effectMeta, ellipseToCubicBeziers, encodeStereoWav, ensureDevice, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSkewMatrix, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, extractSvgDimensions, findSourceAsset, formatHex, formatQaReport, frameArraySignal, frameSignal, generateArcLengthLUT, generateId, generatePathSegments, getActiveMediaMetadata, getFileDataMetadata, getFingerprint, getLeafMediaType, getMediaType, getRenderFingerprint, getScramblePool, getShuffledOrder, gradientStopsToOklab, hasOnlySingleSource, hoistMattes, inputStore, interpolate, isCssGradient, isEqual, isSignal, isVirtualMediaData, italic, limitGradientStops, lintComposition, loadFBX, loadModel3D, loadOBJ, lutStore, mapBlendModeToSkia, mark, measureSpring, measureText, measureTextAsync, mergeAnimationTracks, mixAudioTracks, mixColors, mixSfxInto, normalizeColorStops, normalizeTextSpans, oklabToRgb, parseColorToRgb, parseCssColor, parseCssGradient, parseFBX, parseMTL, parseMarkup, parseOBJ, parseSvgPathToCubicBeziers, pinNodeToLandmark, pinNodeToObject, preloadCompositionFonts, preloadFont, programmaticSignal, progressSignal, registerSignalDependency, renderFrameGrid, renderSemaphore, renderSfx, reportRenderDiagnostic, requiresIsolation, resetRenderCaches, resolveBoolean, resolveEnvironment, resolveMediaMimeType, resolveNumber, resolveParam, resolveSamplePoints, resolveString, rgbToOklab, rich, sampleAudioSpectrumScale, sampleColorStops, sampleCurveGeometry, samplePathChainGeometry, section, serializeSignalData, shaderStore, signal, signalBuilder, signalRegistry, sineSignal, size, softLimit, span, spring, springCalculation, stampResult, startPreview, sub, sup, takeRenderDiagnostics, textureCache, timeSignal, updateClockSignals, waveToCubicBeziers };
 //# sourceMappingURL=index.d.mts.map