framefields 2.2.0 → 2.3.1

package/dist/index.mjs

@@ -1,59 +1,59 @@
 import "./chunk-GBe2k3y8.mjs";
 import { $ as TimelineTransformSchema, $t as serializeSignalData, A as MIME_TYPES, At as gradientStopsToOklab, B as OutputItemSchema, Bt as parseCssColor, C as FileDataSchema, Ct as generateId, D as HandleTypeVal, Dt as getLeafMediaType, E as Gradient, Et as getFingerprint, F as ModerationUnrefundableError, Ft as isVirtualMediaData, G as SignalGateDataSchema, Gt as reportRenderDiagnostic, H as Signal, Ht as programmaticSignal, I as MultiOutputGenericSchema, It as limitGradientStops, J as SingleOutputGenericSchema, Jt as resolveNumber, K as SignalMathDataSchema, Kt as resolveBoolean, L as NodeMetadataSchema, Lt as mixColors, M as MediaOperationSchema, Mt as isCssGradient, N as MediaSourceSchema, Nt as isEqual, O as JsonValueSchema, Ot as getMediaType, P as ModerationError, Pt as isSignal, Q as TimelineSegmentSchema, Qt as sampleColorStops, R as NodeResultSchema, Rt as normalizeColorStops, S as FileAssetSchema, St as frameSignal, T as GlobalCompositeOperation, Tt as getFileDataMetadata, U as SignalChannelMetaSchema, Ut as progressSignal, V as ProgrammaticSignal, Vt as parseCssGradient, W as SignalDataSchema, Wt as registerSignalDependency, X as TEXT_LAYER_DEFAULTS, Xt as resolveString, Y as SourceOperationSchema, Yt as resolveParam, Z as TextOperationSchema, Zt as rgbToOklab, _ as DataTypeVal, _t as deserializeSignalData, a as BaseVideoLayerPropsSchema, an as timeSignal, at as VideoStylePropsSchema, b as ExportResultSchema, bt as formatHex, c as COMPOSITOR_DEFAULTS, ct as VirtualMediaDataSchema, d as ConfigSchemaRegistry, dt as computeVideoCropRenderProps, en as signal, et as TransitionSchema, f as DATA_TYPE_EXTENSIONS, ft as computed, g as DataType, gt as dataTypeColors, h as DEFAULT_MEDIA_DIMENSION, ht as createVirtualMedia, i as BaseMediaOperationPropsSchema, in as takeRenderDiagnostics, it as VideoSpatialPropsSchema, j as MediaMetadataSchema, jt as hasOnlySingleSource, k as MAX_GRADIENT_STOPS, kt as getRenderFingerprint, l as Color, lt as appendOperation, m as DEFAULT_FPS, mt as createOutputItemSchema, n as AnyOutputUnionSchema, nn as sineSignal, nt as VideoAnimationSchema, o as CAPTION_LAYER_DEFAULTS, on as updateClockSignals, ot as VideoTextPropsSchema, p as DEFAULT_DURATION_MS, pt as cosineSignal, q as SignalStatsSchema, qt as resolveMediaMimeType, r as AudioExtractorSignalDataSchema, rn as stampResult, rt as VideoLayerTypeSchema, s as COMPOSITE_OPERATIONS, st as VideoTimingPropsSchema, t as AnimationTypeSchema, tn as signalBuilder, tt as TransitionTypeSchema, u as ConfigHandleSchema, ut as checkNodeResultCache, v as DataTypes, vt as extractSvgDimensions, w as GeneratorSignalDataSchema, wt as getActiveMediaMetadata, x as ExtendedLayerSchema, xt as frameArraySignal, y as Effect$1, yt as findSourceAsset, z as NodeVisualConfigSchema, zt as oklabToRgb } from "./dist-fjKpBYkc.mjs";
-import { $t as TextWigglySelectorSchema, An as samplePathChainGeometry, At as KineticMarqueeConfigSchema, B as loadOBJ, Bt as Spatial3DPropertiesSchema, Cn as generateArcLengthLUT, Ct as CubicBezierSegmentSchema, Dn as parseSvgPathToCubicBeziers, Dt as ExtendedGlyphPropertiesSchema, En as getShuffledOrder, Et as ExpressionSelectorSchema, Ft as SelectorModeSchema, G as parseFBX, Gt as TextCursorStyleSchema, Ht as TextAnchorConfigSchema, I as inputStore, It as SelectorShapeSchema, Jt as TextPathSourceSchema, K as parseMTL, Kt as TextPathBuilder, Lt as SelectorUnitsSchema, Mn as waveToCubicBeziers, Mt as LongShadowConfigSchema, N as getPrimitiveGeometry, Nt as ParticleDissolveConfigSchema, On as sampleAudioSpectrumScale, Ot as GlyphAnchorGroupingSchema, Pt as SelectorBasedOnSchema, Q as shaderStore, Qt as TextSignalSelectorSchema, R as loadFBX, Sn as evaluateVolumetricFormation, St as ChromaticGlitchConfigSchema, Tn as getScramblePool, Tt as EnhancedTextNodeSchema, U as mediaDecoderCache, Ut as TextAnimatorBuilder, V as lutStore, Vt as SpringPhysicsSchema, Wt as TextCursorConfigSchema, Xt as TextScrambleConfigSchema, Yt as TextRangeSelectorSchema, Zt as TextSelectorSchema, _n as evaluateMarqueeOffset, _t as AnchorGroupingSchema, a as GlassPipeline, an as VolumetricFormationModeSchema, at as ENVIRONMENT_PRESETS, b as describeGpu, bn as evaluateSpringProgress, c as Renderer2D, cn as computeAnchorPivotOffset, ct as MAX_LIGHTS, dn as deterministicWigglyNoise, dt as Vector3Math, en as TypewriterAnimatorSchema, f as ShadowPipeline, fn as distanceToCurveParameter, ft as parseColorToRgb, gn as evaluateExpressionSelector, gt as AdvancedTextAnimatorSchema, h as SlugPipeline, hn as evaluateCubicBezierDerivative, ht as AdvancedTextAnimatorBuilder, i as EffectPipeline, in as VolumetricFormationConfigSchema, it as Camera3D, j as generateExtrudedTextGeometry, jn as signalRegistry, jt as LineSpacingDynamicsSchema, k as ensureDevice, kn as sampleCurveGeometry, kt as GlyphAnchorPointSchema, l as Renderer3D, ln as computeLineLeadingDisplacement, lt as Matrix4Math, mn as evaluateCubicBezier, mt as AETextAnimatorSchema, n as AudioLatentTrackCache, nn as VariableFontAxesSchema, o as MotionBlurPipeline, on as buildPathLUT, ot as LIGHT_UNIFORM_SIZE_BYTES, p as SlugFontCache, pn as ellipseToCubicBeziers, pt as resolveEnvironment, q as parseOBJ, qt as TextPathOptionsSchema, r as AudioMeshDeformPipeline, rn as Vec2Schema, st as Light3D, t as AudioLatentEngine, tn as TypingCadenceSchema, tt as textureCache, u as SSAOPipeline, un as computeRangeSelectorWeight, ut as Path3D, vn as evaluateSelectorCombination, vt as AnchorPresetSchema, wn as generatePathSegments, wt as DynamicStrokePropertiesSchema, xn as evaluateTypewriterState, xt as AudioSpectrumTypographySchema, yn as evaluateSkewMatrix, yt as AnimatableGlyphPropsSchema, z as loadModel3D, zt as SkewPropertiesSchema } from "./dist-cjxDXQdx.mjs";
-import "./renderers-CP8CFWDs-BA-4l6By.mjs";
+import { $t as TextSelectorSchema, A as ensureDevice, An as sampleAudioSpectrumScale, At as GlyphAnchorGroupingSchema, B as loadModel3D, Cn as evaluateTypewriterState, Ct as AudioSpectrumTypographySchema, Dn as getScramblePool, Dt as EnhancedTextNodeSchema, En as generatePathSegments, Et as DynamicStrokePropertiesSchema, Ft as ParticleDissolveConfigSchema, G as parseColor, Gt as TextAnimatorBuilder, H as lutStore, Ht as Spatial3DPropertiesSchema, It as SelectorBasedOnSchema, J as parseOBJ, Jt as TextPathBuilder, K as parseFBX, Kt as TextCursorConfigSchema, L as inputStore, Lt as SelectorModeSchema, M as generateExtrudedTextGeometry, Mn as samplePathChainGeometry, Mt as KineticMarqueeConfigSchema, Nn as signalRegistry, Nt as LineSpacingDynamicsSchema, On as getShuffledOrder, Ot as ExpressionSelectorSchema, P as getPrimitiveGeometry, Pn as waveToCubicBeziers, Pt as LongShadowConfigSchema, Qt as TextScrambleConfigSchema, Rt as SelectorShapeSchema, Sn as evaluateSpringProgress, Tn as generateArcLengthLUT, Tt as CubicBezierSegmentSchema, Ut as SpringPhysicsSchema, V as loadOBJ, Vt as SkewPropertiesSchema, W as mediaDecoderCache, Wt as TextAnchorConfigSchema, Xt as TextPathSourceSchema, Y as parseSvgPathToSegments, Yt as TextPathOptionsSchema, Zt as TextRangeSelectorSchema, _ as buildShapeSvgPath, _n as evaluateCubicBezierDerivative, _t as AdvancedTextAnimatorBuilder, a as GlassPipeline, an as Vec2Schema, bn as evaluateSelectorCombination, bt as AnchorPresetSchema, c as Renderer2D, cn as buildPathLUT, ct as LIGHT_UNIFORM_SIZE_BYTES, dn as computeLineLeadingDisplacement, dt as Matrix4Math, en as TextSignalSelectorSchema, et as shaderStore, f as ShadowPipeline, fn as computeRangeSelectorWeight, ft as Path3D, gn as evaluateCubicBezier, gt as AETextAnimatorSchema, h as SlugPipeline, hn as ellipseToCubicBeziers, ht as resolveEnvironment, i as EffectPipeline, in as VariableFontAxesSchema, jn as sampleCurveGeometry, jt as GlyphAnchorPointSchema, kn as parseSvgPathToCubicBeziers, kt as ExtendedGlyphPropertiesSchema, l as Renderer3D, lt as Light3D, mn as distanceToCurveParameter, mt as parseColorToRgb, n as AudioLatentTrackCache, nn as TypewriterAnimatorSchema, o as MotionBlurPipeline, on as VolumetricFormationConfigSchema, ot as Camera3D, p as SlugFontCache, pn as deterministicWigglyNoise, pt as Vector3Math, q as parseMTL, qt as TextCursorStyleSchema, r as AudioMeshDeformPipeline, rn as TypingCadenceSchema, rt as textureCache, sn as VolumetricFormationModeSchema, st as ENVIRONMENT_PRESETS, t as AudioLatentEngine, tn as TextWigglySelectorSchema, u as SSAOPipeline, un as computeAnchorPivotOffset, ut as MAX_LIGHTS, vn as evaluateExpressionSelector, vt as AdvancedTextAnimatorSchema, wn as evaluateVolumetricFormation, wt as ChromaticGlitchConfigSchema, x as describeGpu, xn as evaluateSkewMatrix, xt as AnimatableGlyphPropsSchema, yn as evaluateMarqueeOffset, yt as AnchorGroupingSchema, z as loadFBX, zt as SelectorUnitsSchema } from "./dist-jU289ehm.mjs";
+import "./renderers-CP8CFWDs-CVHwMTiz.mjs";
 import "./signals-DGRs6ddH.mjs";
-import "./renderer-BmGPTWwV.mjs";
+import "./renderer-D7ss6fLB.mjs";
 import "./renderer-BajIOuZH.mjs";
-import { _ as spring, c as computeStrokeRect, d as measureSpring, f as measureText, g as requiresIsolation, h as preloadFont, i as mixAudioTracks, l as interpolate, m as preloadCompositionFonts, o as Easing, p as measureTextAsync, s as bezier, u as mapBlendModeToSkia, v as springCalculation } from "./dist-CT___nEU.mjs";
-import { t as AudioSignal } from "./audio-DMUr01vS.mjs";
-import { t as FontManager } from "./fonts-C0UuLQvr.mjs";
-import "./renderer-CWBHVCvA.mjs";
-import "./renderer-CebB0v1y.mjs";
-import "./renderer-DtgMsjyL.mjs";
-import "./renderer-DvFaC_-7.mjs";
-import "./renderer-Bvx56GR6.mjs";
-import "./renderer-u8ynJtAC.mjs";
+import { _ as spring, c as computeStrokeRect, d as measureSpring, f as measureText, g as requiresIsolation, h as preloadFont, i as mixAudioTracks, l as interpolate, m as preloadCompositionFonts, o as Easing, p as measureTextAsync, s as bezier, u as mapBlendModeToSkia, v as springCalculation } from "./dist-BOdxAhOT.mjs";
+import { t as AudioSignal } from "./audio-CS104aUj.mjs";
+import { t as FontManager } from "./fonts-BhlV_3Qt.mjs";
+import "./renderer-CdOy3EBJ.mjs";
+import "./renderer-C6cF5seJ.mjs";
+import "./renderer-BI4OMlEx.mjs";
+import "./renderer-Dq4aO7az.mjs";
+import "./renderer-CLdwOhST.mjs";
+import "./renderer-BVUTOGHs.mjs";
 import "./renderer-B-BcgA6d.mjs";
-import "./renderer-D1Cm21eq.mjs";
+import "./renderer-DcAfp1Er.mjs";
 import { i as softLimit, n as mixSfxInto, r as renderSfx, t as encodeStereoWav } from "./audio-DJeVoE8b.mjs";
 import { i as OpticalFlowComputePipeline, n as ControlNetMultiplexer, o as TemporalDeflickerPipeline, r as DepthNormalsComputePipeline, s as TensorPipeline, t as CannyComputePipeline } from "./dist-0QGroRYZ.mjs";
-import { a as PoseSkeletonRenderer, c as TemporalObjectTracker, d as VisionRunner, f as analyzeSequence, h as COCO_CLASSES, i as COCO17_KEYPOINT_NAMES, l as VisionBundle, m as pinNodeToObject, n as COCO17_BONES, o as SegmentationTexturePool, p as pinNodeToLandmark, r as COCO17_KEYPOINTS, s as SpatialLandmarkTransformer, u as VisionNode } from "./renderer-CE7fwGgw.mjs";
-import { A as applyStaggerToChildren, B as hoistMattes, C as ShapeNodeSchema, D as TextSpanMarkSchema, E as TextNodeSchema, F as computeLayout, H as lintComposition, I as computeLayoutSync, L as computeStaggerDelay, M as collectNodeOps, N as compositorToProgram, O as TextSpanSchema, P as computeCarrierContinuity, R as evaluateAnimationAtFrame, S as Sequence, T as TextAnimatorSchema, U as mergeAnimationTracks, _ as MediaNodeSchema, a as CarrierHandoffConfigSchema, b as SceneDefinitionSchema, c as EnvironmentFogSchema, d as LayerAnimation, f as LayoutNodeSchema, g as MatteModeSchema, h as MaterialTypeSchema, i as CameraNodeSchema, j as calculateSequenceTimeline, k as ToneMappingSchema, l as EnvironmentPresetSchema, m as LightTypeSchema, n as BoxNodeSchema, o as ColorStopSchema, p as LightNodeSchema, r as CameraAnimation, s as CompositorProgramSchema, t as BloomConfigSchema, u as FlexNodeSchema, v as Model3DNodeSchema, w as TextAnimator, x as SceneTransitionTypeSchema, y as Scene, z as evaluateTrackAtFrame } from "./program-DzknMiY0.mjs";
-import "./renderer-CJB9nU1x.mjs";
-import "./renderer-BeIUgp1r.mjs";
-import "./renderer-DpW_LxLO.mjs";
-import "./renderer-id8TbKBY.mjs";
-import "./renderer-DEuIwr-t.mjs";
-import "./renderer-DqdhsSwS.mjs";
-import "./renderer-0gY4IQhM.mjs";
-import "./renderer-EemDpvv3.mjs";
-import "./renderer-BbdZ0YHR.mjs";
-import "./renderer-CursFKUf.mjs";
-import "./renderer-D8thCpS7.mjs";
-import "./renderer-Br6KyRO_.mjs";
-import "./renderer-jqByPgkD.mjs";
-import "./renderer-C8uKdelk.mjs";
-import "./renderer-p_C_T9Kn.mjs";
-import "./renderer-BiwIh_w4.mjs";
-import "./renderer-BzDjy1_x.mjs";
-import "./renderer-Bn2eQE-t.mjs";
-import "./renderer-CrABA3lB.mjs";
-import "./renderer-D-vRKssW.mjs";
-import "./renderer-aArb4RwJ.mjs";
-import "./renderer-DD8napek.mjs";
-import "./renderer-DHGTzype.mjs";
-import "./renderer-Db3JIF1K.mjs";
-import "./renderer-Cce2fgpX.mjs";
-import "./renderer-BteUC_7n.mjs";
-import "./renderer-C6md3msE.mjs";
-import "./renderer-57ATc_mQ.mjs";
-import "./renderer-BNqwn0gZ.mjs";
-import "./renderer-BerD3T-X.mjs";
-import "./renderer-DXqIslFk.mjs";
-import { $ as StereoPanning, A as AudioReverb, B as KenBurns, C as effectFactories, D as AudioFade, E as AudioDelay, F as ColorKey, G as NoiseGenerator, H as Liquify, I as CornerPin, J as ProceduralVFX, K as Paint, L as DisplacementMap, M as ChannelMerger, N as ChannelSplitter, O as AudioNoiseGate, P as ColorBalance, Q as Rotate, R as ExtractLUT, S as Vision, T as AudioCompressor, U as MaskMath, V as LayerStyle, W as MeshWarp, X as RefractionCaustics3D, Y as RefineEdge, Z as ResizerScaler, _ as SelectiveColor, a as CustomEffect, b as TileOffset, c as GradientMap, d as Levels, et as Vignette, f as Modulate, g as SSAO, h as Relight3D, i as Curves, j as CameraParallax3D, k as AudioParametricEq, l as HalftoneScreen, m as PBRGlass, n as AudioSignalExtractor, o as DepthOfField, p as MotionBlur, q as PatchHeal, r as Crop, s as FilmGrain, t as ApplyLUT, tt as effectMeta, u as HighPass, v as ShadowsHighlights, w as Blur, x as UnsharpMask, y as TemporalDeflicker, z as Flip } from "./effects-C06-AOge.mjs";
-import { a as HeadlessMediaRenderer, c as renderSemaphore, i as resetRenderCaches, n as renderFrameGrid, o as HeadlessWebGPURenderer, r as resolveSamplePoints, s as formatQaReport, t as computeGridLayout } from "./renderer-1vhaKMeg.mjs";
-import { t as startPreview } from "./preview-M0TsUzC6.mjs";
+import { _ as COCO_CLASSES, a as COCO17_KEYPOINT_NAMES, c as SpatialLandmarkTransformer, d as VisionNode, f as VisionRunner, g as pinNodeToObject, h as pinNodeToLandmark, i as COCO17_KEYPOINTS, l as TemporalObjectTracker, m as mergeSubjectMask, n as CLIP_SUBJECT, o as PoseSkeletonRenderer, p as analyzeSequence, r as COCO17_BONES, s as SegmentationTexturePool, u as VisionBundle } from "./renderer-DQtk282o.mjs";
+import { A as applyStaggerToChildren, B as evaluateTrackAtFrame, C as ShapeNodeSchema, D as TextSpanMarkSchema, E as TextNodeSchema, F as computeLayout, I as computeLayoutSync, L as computeStaggerDelay, M as collectNodeOps, N as compositorToProgram, O as TextSpanSchema, P as computeCarrierContinuity, R as evaluateAnimationAtFrame, S as Sequence, T as TextAnimatorSchema, U as lintComposition, V as hoistMattes, W as mergeAnimationTracks, _ as MediaNodeSchema, a as CarrierHandoffConfigSchema, b as SceneDefinitionSchema, c as EnvironmentFogSchema, d as LayerAnimation, f as LayoutNodeSchema, g as MatteModeSchema, h as MaterialTypeSchema, i as CameraNodeSchema, j as calculateSequenceTimeline, k as ToneMappingSchema, l as EnvironmentPresetSchema, m as LightTypeSchema, n as BoxNodeSchema, o as ColorStopSchema, p as LightNodeSchema, r as CameraAnimation, s as CompositorProgramSchema, t as BloomConfigSchema, u as FlexNodeSchema, v as Model3DNodeSchema, w as TextAnimator, x as SceneTransitionTypeSchema, y as Scene } from "./program-CCSfHMfh.mjs";
+import "./renderer-BD7Lmb8h.mjs";
+import "./renderer-DukD7S3w.mjs";
+import "./renderer-BmDpyiII.mjs";
+import "./renderer-CuphUktB.mjs";
+import "./renderer-Bzl0s07U.mjs";
+import "./renderer-CiMpdh0s.mjs";
+import "./renderer-AtLlZMQ9.mjs";
+import "./renderer-FXUCKps6.mjs";
+import "./renderer-CWx3Kg79.mjs";
+import "./renderer-CMdtUn5o.mjs";
+import "./renderer-wL-ly4fT.mjs";
+import "./renderer-C3lPwajT.mjs";
+import "./renderer-D26S5hUh.mjs";
+import "./renderer-DdlaBsk_.mjs";
+import "./renderer-YdLL2o6d.mjs";
+import "./renderer-BG5sbTXt.mjs";
+import "./renderer-D1Jt-c3F.mjs";
+import "./renderer-DaCsT-XU.mjs";
+import "./renderer-DCYabwlC.mjs";
+import "./renderer-c-bwxMde.mjs";
+import "./renderer-BvBIHi6N.mjs";
+import "./renderer-DMZ5aLU1.mjs";
+import "./renderer-Dh-OF6aH.mjs";
+import "./renderer-BvvuGfZk.mjs";
+import "./renderer-DPWeKe_x.mjs";
+import "./renderer-BonWt8jF.mjs";
+import "./renderer-Cu5k5D9N.mjs";
+import "./renderer-B93zd3sx.mjs";
+import "./renderer-8BM6sJUR.mjs";
+import "./renderer-4VpA7LfU.mjs";
+import "./renderer-CNYfB5cC.mjs";
+import { $ as NoiseGenerator, A as AudioParametricEq, B as Datamosh, C as effectFactories, D as AudioDelay, E as AudioCompressor, F as ChannelSplitter, G as Gooey, H as Dither, I as ColorBalance, J as KenBurns, K as Iridescence, L as ColorKey, M as CRT, N as CameraParallax3D, O as AudioFade, P as ChannelMerger, Q as MeshWarp, R as Contour, S as Vision, T as Ascii, U as ExtractLUT, V as DisplacementMap, W as Flip, X as Liquify, Y as LayerStyle, Z as MaskMath, _ as SelectiveColor, a as CustomEffect, at as Posterize, b as TileOffset, c as GradientMap, ct as RefineEdge, d as Levels, dt as Rotate, et as OpArt, f as Modulate, ft as StereoPanning, g as SSAO, gt as effectMeta, h as Relight3D, ht as Vignette, i as Curves, it as Pixelate, j as AudioReverb, k as AudioNoiseGate, l as HalftoneScreen, lt as RefractionCaustics3D, m as PBRGlass, mt as Trails, n as AudioSignalExtractor, nt as Painterly, o as DepthOfField, ot as ProceduralVFX, p as MotionBlur, pt as Toon, q as Kaleidoscope, r as Crop, rt as PatchHeal, s as FilmGrain, st as RGBSplit, t as ApplyLUT, tt as Paint, u as HighPass, ut as ResizerScaler, v as ShadowsHighlights, w as Blur, x as UnsharpMask, y as TemporalDeflicker, z as CornerPin } from "./effects-BzOlVD-w.mjs";
+import { a as HeadlessMediaRenderer, c as renderSemaphore, i as resetRenderCaches, n as renderFrameGrid, o as HeadlessWebGPURenderer, r as resolveSamplePoints, s as formatQaReport, t as computeGridLayout } from "./renderer-1uLtqb74.mjs";
+import { t as startPreview } from "./preview-BVyG76gO.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { format } from "d3-format";
@@ -261,8 +261,8 @@ function parseMarkup(markup) {
 			} else if (tagName === "accent") style.fill = "#6366f1";
 			else if (tagName === "color") style.fill = attrs.value ?? attrs.hex ?? attrs.fill;
 			else if (tagName === "size") {
-				const num = parseFloat(attrs.value ?? attrs.px ?? attrs.pt ?? "0");
-				if (num > 0) style.fontSize = num;
+				const num$2 = parseFloat(attrs.value ?? attrs.px ?? attrs.pt ?? "0");
+				if (num$2 > 0) style.fontSize = num$2;
 			} else if (tagName === "mark") {
 				style.mark = {
 					background: attrs.bg ?? attrs.background ?? "#6366f133",
@@ -536,9 +536,9 @@ function buildChart(options, props, defaultFontFamily) {
 		}
 		const yValues = [0];
 		series.forEach((s, i) => {
-			const range = stackRanges.get(i);
+			const range$1 = stackRanges.get(i);
 			if (typeOf(s) === "candlestick") for (const c of s.data) yValues.push(c.high, c.low);
-			else if (range) for (const [a, b] of range) yValues.push(a, b);
+			else if (range$1) for (const [a, b] of range$1) yValues.push(a, b);
 			else for (const p of points[i]) yValues.push(p.y);
 		});
 		if (series.every((s) => typeOf(s) === "candlestick" || typeOf(s) === "scatter" || typeOf(s) === "line")) yValues.shift();
@@ -685,14 +685,14 @@ function buildChart(options, props, defaultFontFamily) {
 			const color$1 = colorOf(s, si);
 			const kind = typeOf(s);
 			const pts = points[si];
-			const range = stackRanges.get(si);
+			const range$1 = stackRanges.get(si);
 			if (kind === "bar" && band) {
 				const groupSize = stacked ? 1 : barSeries.length;
 				const groupIdx = stacked ? 0 : barSeries.indexOf(si);
 				const bw = band.bandwidth() / groupSize;
 				const gap = groupSize > 1 ? Math.min(4, bw * .12) : 0;
 				pts.forEach((p, i) => {
-					const [lo$1, hi$1] = range ? range[i] : [0, p.y];
+					const [lo$1, hi$1] = range$1 ? range$1[i] : [0, p.y];
 					const top = plot.y + y(Math.max(lo$1, hi$1));
 					const bottom = plot.y + y(Math.min(lo$1, hi$1));
 					const h = Math.max(0, bottom - top);
@@ -795,8 +795,8 @@ function buildChart(options, props, defaultFontFamily) {
 				const m = Math.ceil(sw * 2 + (s.pointRadius ?? 0) + 2);
 				const xy = pts.map((p, i) => ({
 					x: xPos(p.x) + m,
-					top: (range ? y(range[i][1]) : y(p.y)) + m,
-					base: (range ? y(range[i][0]) : y(Math.max(y.domain()[0], Math.min(0, y.domain()[1])))) + m
+					top: (range$1 ? y(range$1[i][1]) : y(p.y)) + m,
+					base: (range$1 ? y(range$1[i][0]) : y(Math.max(y.domain()[0], Math.min(0, y.domain()[1])))) + m
 				}));
 				const curve = curveOf(s.curve);
 				const frame = {
@@ -843,16 +843,16 @@ function buildChart(options, props, defaultFontFamily) {
 					}));
 					children.push(node);
 				}
-				if ((s.pointRadius ?? 0) > 0) dots(si, pts, color$1, s.pointRadius ?? 0, delay + timing.duration * .5, range);
+				if ((s.pointRadius ?? 0) > 0) dots(si, pts, color$1, s.pointRadius ?? 0, delay + timing.duration * .5, range$1);
 				return;
 			}
-			if (kind === "scatter") dots(si, pts, color$1, s.pointRadius ?? 6, rank * (timing.duration / 3), range);
+			if (kind === "scatter") dots(si, pts, color$1, s.pointRadius ?? 6, rank * (timing.duration / 3), range$1);
 		});
 		if (showLegend) legendRow(legendItems);
-		function dots(si, pts, color$1, r, baseDelay, range) {
+		function dots(si, pts, color$1, r, baseDelay, range$1) {
 			const step = staggerStep(pts.length);
 			pts.forEach((p, i) => {
-				const py = range ? y(range[i][1]) : y(p.y);
+				const py = range$1 ? y(range$1[i][1]) : y(p.y);
 				const node = Layer.shape("circle", {
 					id: `${id}-point-${si}-${i}`,
 					position: "absolute",
@@ -983,6 +983,1168 @@ function translatePath(d, dx, dy) {
 	return out.join("");
 }
 
+//#endregion
+//#region src/clip-vision.ts
+/** Frames looked back over to bridge a gap where the person is lost. */
+const HOLD = 24;
+const CACHE_VERSION = 1;
+/**
+* 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`).
+*/
+var ClipVision = class {
+	source;
+	fps;
+	startFrame;
+	trimStartSec;
+	smoothing;
+	/** @internal */
+	options;
+	results = /* @__PURE__ */ new Map();
+	sourceWidth = 0;
+	sourceHeight = 0;
+	cellW = 0;
+	cellH = 0;
+	cell;
+	queue = Promise.resolve();
+	runner;
+	cacheLoaded;
+	unsaved = 0;
+	unsavedSubjects = 0;
+	blurred = /* @__PURE__ */ new Map();
+	smoothed = /* @__PURE__ */ new Map();
+	personView;
+	/** Full-resolution subject masks for render-time mattes (see `keepSubjects`). */
+	subjects = /* @__PURE__ */ new Map();
+	wantSubjects = false;
+	subjectsLoaded;
+	/** @internal Use `comp.vision(source, options)`. */
+	constructor(source, fps, options = {}) {
+		this.source = source;
+		this.options = options;
+		this.fps = options.fps ?? fps;
+		this.startFrame = Math.round(options.startFrame ?? 0);
+		this.trimStartSec = options.trimStartSec ?? 0;
+		this.smoothing = Math.max(0, Math.round(options.smoothing ?? 2));
+		this.cell = Math.max(1, Math.round(options.maskCell ?? 8));
+	}
+	/** The tracked person in source pixels; `.place()` maps it into the composition. */
+	get person() {
+		this.personView ??= new PersonTrack(this);
+		return this.personView;
+	}
+	/**
+	* 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, toFrame = frame) {
+		const [from, to] = this.window(frame, toFrame);
+		this.queue = this.queue.then(() => this.compute(from, to));
+		return this.queue;
+	}
+	/** True when composition frame `frame` can be read synchronously. */
+	isReady(frame) {
+		const [from, to] = this.window(frame, frame);
+		for (let c = from; c <= to; c++) if (!this.results.has(c)) return false;
+		return true;
+	}
+	/**
+	* @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() {
+		this.wantSubjects = true;
+	}
+	/**
+	* @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, fps) {
+		const c = frame * this.fps / fps;
+		if (Math.abs(c - Math.round(c)) > 1e-6) return void 0;
+		const s = this.subjects.get(Math.round(c));
+		if (s === void 0) return s;
+		if (s === null || !this.sourceWidth) return null;
+		const width = this.sourceWidth;
+		const height = this.sourceHeight;
+		return {
+			category: s.category,
+			mask: decodeRuns(s, width * height),
+			width,
+			height,
+			area: s.area,
+			coverage: s.area / (width * height),
+			detectionIndex: -1
+		};
+	}
+	/** Composition frame → clip frame (fractional). */
+	clipFrame(frame) {
+		return frame - this.startFrame + this.trimStartSec * this.fps;
+	}
+	window(frame, toFrame) {
+		const a = Math.floor(this.clipFrame(Math.min(frame, toFrame)));
+		const b = Math.ceil(this.clipFrame(Math.max(frame, toFrame)));
+		return [Math.max(0, a - HOLD - this.smoothing), Math.max(0, b + this.smoothing)];
+	}
+	analysed(c) {
+		return this.results.has(c) && (!this.wantSubjects || this.subjects.has(c));
+	}
+	async compute(from, to) {
+		this.cacheLoaded ??= this.loadCache();
+		await this.cacheLoaded;
+		if (this.wantSubjects) {
+			this.subjectsLoaded ??= this.loadSubjects();
+			await this.subjectsLoaded;
+		}
+		let missing = false;
+		for (let c = from; c <= to; c++) if (!this.analysed(c)) missing = true;
+		if (!missing) return;
+		const wantPose = this.options.pose ?? true;
+		const wantMask = this.options.mask ?? true;
+		this.runner ??= VisionRunner.create({
+			modelsDir: this.options.modelsDir,
+			baseUrl: this.options.baseUrl,
+			...this.options.confidence !== void 0 && { confidence: this.options.confidence },
+			...this.options.variant !== void 0 && { variant: this.options.variant }
+		});
+		const decoder = mediaDecoderCache.getVideo(this.source, true, "clip-vision");
+		for (let c = from; c <= to; c++) {
+			if (this.analysed(c)) continue;
+			const image = await decodedPixels(await decoder.getFrame(c / this.fps));
+			if (!image) {
+				this.results.set(c, {
+					kp: null,
+					mask: null
+				});
+				if (this.wantSubjects) this.subjects.set(c, null);
+				continue;
+			}
+			if (!this.sourceWidth) this.setSize(image.width, image.height);
+			const known = this.results.get(c);
+			let kp = known?.kp ?? null;
+			let mask = known?.mask ?? null;
+			if (wantPose && !known) {
+				const person = (await this.runner.pose(image)).people[0];
+				if (person) {
+					kp = new Float32Array(51);
+					for (const [k, p] of person.keypoints.entries()) kp.set([
+						p.x,
+						p.y,
+						p.visibility
+					], k * 3);
+				}
+			}
+			const seg = wantMask && !known || this.wantSubjects ? await this.runner.segment(image) : void 0;
+			if (seg && this.wantSubjects) {
+				const subject = mergeSubjectMask(seg.masks);
+				this.subjects.set(c, subject ? {
+					category: subject.category,
+					area: subject.area,
+					...encodeRuns(subject.mask)
+				} : null);
+				this.unsavedSubjects++;
+			}
+			if (seg && wantMask && !known) {
+				const silhouette = personSilhouette(seg);
+				if (silhouette) {
+					mask = new Uint8Array(this.cellW * this.cellH);
+					downsampleMean(silhouette, image.width, image.height, this.cell, mask, this.cellW, this.cellH);
+				}
+			}
+			this.results.set(c, {
+				kp,
+				mask
+			});
+			if (!known) this.unsaved++;
+			if (this.unsaved >= 24) await this.saveCache();
+			if (this.unsavedSubjects >= 24) await this.saveSubjects();
+		}
+		if (this.unsaved > 0) await this.saveCache();
+		if (this.unsavedSubjects > 0) await this.saveSubjects();
+	}
+	setSize(width, height) {
+		this.sourceWidth = width;
+		this.sourceHeight = height;
+		this.cellW = Math.ceil(width / this.cell);
+		this.cellH = Math.ceil(height / this.cell);
+	}
+	/** @internal */
+	size() {
+		return {
+			width: this.sourceWidth,
+			height: this.sourceHeight
+		};
+	}
+	/** @internal Raw result for a clip frame, or throws when it was never analysed. */
+	result(c) {
+		return this.results.get(Math.max(0, c));
+	}
+	/** @internal Confidence-weighted keypoint over the smoothing window, in source px. */
+	keypoint(k, c) {
+		c = Math.max(0, c);
+		const key = `${k}:${c}`;
+		const hit = this.smoothed.get(key);
+		if (hit) return hit;
+		const avg = (center) => {
+			let sx = 0;
+			let sy = 0;
+			let sv = 0;
+			let sw = 0;
+			for (let g = center - this.smoothing; g <= center + this.smoothing; g++) {
+				const r = this.mustHave(g < 0 ? 0 : g);
+				if (!r.kp) continue;
+				const v = r.kp[k * 3 + 2];
+				const w = (this.smoothing + 1 - Math.abs(g - center)) * v * v;
+				sx += r.kp[k * 3] * w;
+				sy += r.kp[k * 3 + 1] * w;
+				sv += v * w;
+				sw += w;
+			}
+			return sw > 1e-6 ? [
+				sx / sw,
+				sy / sw,
+				sv / sw
+			] : null;
+		};
+		let out = null;
+		for (let d = 0; d <= HOLD && !out; d++) if (c - d >= 0) out = avg(c - d);
+		out ??= [
+			this.sourceWidth / 2,
+			this.sourceHeight / 2,
+			0
+		];
+		this.smoothed.set(key, out);
+		return out;
+	}
+	/** @internal Softened silhouette grid for a clip frame (null: no person). */
+	blurredMask(c) {
+		c = Math.max(0, c);
+		if (this.blurred.has(c)) return this.blurred.get(c) ?? null;
+		const r = this.mustHave(c);
+		const grid = r.mask ? boxBlur(r.mask, this.cellW, this.cellH, 2) : null;
+		this.blurred.set(c, grid);
+		return grid;
+	}
+	/** @internal */
+	grid() {
+		return {
+			cell: this.cell,
+			width: this.cellW,
+			height: this.cellH
+		};
+	}
+	mustHave(c) {
+		const r = this.results.get(c);
+		if (r) return r;
+		throw new Error(`ClipVision "${this.source}": frame ${c} is not analysed yet. Read it while rendering (the composition prepares each frame), in a live physics world, or after \`await clip.ready(frame)\`.`);
+	}
+	cacheFile;
+	async cachePath() {
+		if (this.cacheFile !== void 0) return this.cacheFile;
+		this.cacheFile = null;
+		if (this.options.cacheDir === false || typeof process === "undefined" || !process.versions?.node) return null;
+		try {
+			const [fs$1, path$1, os, crypto] = await Promise.all([
+				import("node:fs"),
+				import("node:path"),
+				import("node:os"),
+				import("node:crypto")
+			]);
+			const stat = fs$1.statSync(this.source);
+			const dir = this.options.cacheDir ?? process.env.FRAMEFIELDS_VISION_CACHE_DIR ?? path$1.join(os.homedir(), ".cache", "framefields", "vision");
+			const o = this.options;
+			const key = JSON.stringify([
+				CACHE_VERSION,
+				path$1.resolve(this.source),
+				stat.size,
+				stat.mtimeMs,
+				this.fps,
+				o.pose ?? true,
+				o.mask ?? true,
+				this.cell,
+				o.variant ?? "s",
+				o.confidence ?? null
+			]);
+			const hash = crypto.createHash("sha256").update(key).digest("hex").slice(0, 24);
+			fs$1.mkdirSync(dir, { recursive: true });
+			this.cacheFile = path$1.join(dir, `${path$1.basename(this.source)}.${hash}.json`);
+		} catch {
+			this.cacheFile = null;
+		}
+		return this.cacheFile;
+	}
+	async loadCache() {
+		const file = await this.cachePath();
+		if (!file) return;
+		try {
+			const fs$1 = await import("node:fs");
+			if (!fs$1.existsSync(file)) return;
+			const json = JSON.parse(fs$1.readFileSync(file, "utf8"));
+			if (json.cell !== this.cell) return;
+			this.setSize(json.width, json.height);
+			for (const [c, r] of Object.entries(json.frames)) this.results.set(Number(c), {
+				kp: r.kp ? Float32Array.from(r.kp) : null,
+				mask: r.mask ? new Uint8Array(Buffer.from(r.mask, "base64")) : null
+			});
+		} catch {}
+	}
+	async saveCache() {
+		this.unsaved = 0;
+		const file = await this.cachePath();
+		if (!file || !this.sourceWidth) return;
+		const frames = {};
+		for (const [c, r] of this.results) frames[c] = {
+			kp: r.kp ? Array.from(r.kp, (v) => Math.round(v * 100) / 100) : null,
+			mask: r.mask ? Buffer.from(r.mask).toString("base64") : null
+		};
+		const fs$1 = await import("node:fs");
+		const tmp = `${file}.${process.pid}.tmp`;
+		fs$1.writeFileSync(tmp, JSON.stringify({
+			width: this.sourceWidth,
+			height: this.sourceHeight,
+			cell: this.cell,
+			frames
+		}));
+		fs$1.renameSync(tmp, file);
+	}
+	/** Subjects live beside the results: large, and only matte layers read them. */
+	async subjectsPath() {
+		const file = await this.cachePath();
+		return file ? file.replace(/\.json$/, ".subjects.json") : null;
+	}
+	async loadSubjects() {
+		const file = await this.subjectsPath();
+		if (!file) return;
+		try {
+			const fs$1 = await import("node:fs");
+			if (!fs$1.existsSync(file)) return;
+			const json = JSON.parse(fs$1.readFileSync(file, "utf8"));
+			if (this.sourceWidth && json.width !== this.sourceWidth) return;
+			if (!this.sourceWidth) this.setSize(json.width, json.height);
+			for (const [c, s] of Object.entries(json.frames)) {
+				const lengths = Buffer.from(s?.lengths ?? "", "base64");
+				this.subjects.set(Number(c), s && {
+					category: s.category,
+					area: s.area,
+					values: new Uint8Array(Buffer.from(s.values, "base64")),
+					lengths: new Uint32Array(lengths.buffer.slice(lengths.byteOffset, lengths.byteOffset + lengths.byteLength))
+				});
+			}
+		} catch {}
+	}
+	async saveSubjects() {
+		this.unsavedSubjects = 0;
+		const file = await this.subjectsPath();
+		if (!file || !this.sourceWidth) return;
+		const frames = {};
+		for (const [c, s] of this.subjects) frames[c] = s && {
+			category: s.category,
+			area: s.area,
+			values: Buffer.from(s.values).toString("base64"),
+			lengths: Buffer.from(s.lengths.buffer, s.lengths.byteOffset, s.lengths.byteLength).toString("base64")
+		};
+		const fs$1 = await import("node:fs");
+		const tmp = `${file}.${process.pid}.tmp`;
+		fs$1.writeFileSync(tmp, JSON.stringify({
+			width: this.sourceWidth,
+			height: this.sourceHeight,
+			frames
+		}));
+		fs$1.renameSync(tmp, file);
+	}
+};
+/**
+* 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)`).
+*/
+var PersonTrack = class PersonTrack {
+	/** @internal */
+	constructor(clip, t, placement) {
+		this.clip = clip;
+		this.t = t;
+		this.placement = placement;
+	}
+	/** The same person in composition pixels for a clip laid out at `placement`. */
+	place(placement) {
+		return new PersonTrack(this.clip, void 0, placement);
+	}
+	transform() {
+		if (this.t) return this.t;
+		const p = this.placement;
+		const { width: sw, height: sh } = this.clip.size();
+		if (!p || !sw) return {
+			sx: 1,
+			sy: 1,
+			ox: 0,
+			oy: 0
+		};
+		let sx = p.width / sw;
+		let sy = p.height / sh;
+		if (p.fit !== "fill") {
+			const s = p.fit === "contain" ? Math.min(sx, sy) : Math.max(sx, sy);
+			sx = s;
+			sy = s;
+		}
+		return {
+			sx,
+			sy,
+			ox: (p.x ?? 0) + (p.width - sw * sx) / 2,
+			oy: (p.y ?? 0) + (p.height - sh * sy) / 2
+		};
+	}
+	/** A keypoint at a composition frame (fractional frames interpolate). */
+	point(name, frame) {
+		const k = keypointIndex(name);
+		const c = this.clip.clipFrame(frame);
+		const c0 = Math.floor(c);
+		const u = c - c0;
+		const a = this.clip.keypoint(k, c0);
+		const b = u > 0 ? this.clip.keypoint(k, c0 + 1) : a;
+		const t = this.transform();
+		return {
+			x: (a[0] + (b[0] - a[0]) * u) * t.sx + t.ox,
+			y: (a[1] + (b[1] - a[1]) * u) * t.sy + t.oy,
+			visibility: a[2] + (b[2] - a[2]) * u
+		};
+	}
+	/** Signals for a keypoint, for `.signal("x", …)`; read while rendering. */
+	signals(name) {
+		const read = (axis) => Signal.builder({
+			type: "custom",
+			fn: (ctx) => this.point(name, ctx.frame)[axis]
+		});
+		return {
+			x: read("x"),
+			y: read("y"),
+			visibility: read("visibility")
+		};
+	}
+	/**
+	* @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) {
+		const grid = this.clip.blurredMask(Math.round(this.clip.clipFrame(frame)));
+		if (!grid) return null;
+		const { cell, width, height } = this.clip.grid();
+		const t = this.transform();
+		return {
+			data: grid,
+			width,
+			height,
+			originX: t.ox,
+			originY: t.oy,
+			scaleX: cell * t.sx,
+			scaleY: cell * t.sy
+		};
+	}
+	/**
+	* 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, x, y) {
+		const grid = this.clip.blurredMask(Math.round(this.clip.clipFrame(frame)));
+		if (!grid) return {
+			alpha: 0,
+			gx: 0,
+			gy: 0
+		};
+		const { cell, width: w, height: h } = this.clip.grid();
+		const t = this.transform();
+		const cx = (x - t.ox) / t.sx / cell - .5;
+		const cy = (y - t.oy) / t.sy / cell - .5;
+		const read = (gx, gy) => gx < 0 || gy < 0 || gx >= w || gy >= h ? 0 : grid[gy * w + gx];
+		const bil = (px, py) => {
+			const x0 = Math.floor(px);
+			const y0 = Math.floor(py);
+			const ux = px - x0;
+			const uy = py - y0;
+			const a = read(x0, y0) + (read(x0 + 1, y0) - read(x0, y0)) * ux;
+			return a + (read(x0, y0 + 1) + (read(x0 + 1, y0 + 1) - read(x0, y0 + 1)) * ux - a) * uy;
+		};
+		return {
+			alpha: bil(cx, cy),
+			gx: (bil(cx + 1, cy) - bil(cx - 1, cy)) / (2 * cell * t.sx),
+			gy: (bil(cx, cy + 1) - bil(cx, cy - 1)) / (2 * cell * t.sy)
+		};
+	}
+};
+function keypointIndex(name) {
+	const i = COCO17_KEYPOINT_NAMES.indexOf(name);
+	if (i < 0) throw new Error(`Unknown keypoint "${name}". Use one of ${COCO17_KEYPOINT_NAMES.join(", ")}.`);
+	return i;
+}
+/** RGBA pixels of a decoded frame (headless buffer, or a canvas in the browser). */
+async function decodedPixels(frame) {
+	if (!frame || frame.width <= 0) return null;
+	if (frame.buffer) return {
+		data: frame.buffer,
+		width: frame.width,
+		height: frame.height
+	};
+	const ctx = frame.canvas?.getContext("2d");
+	if (!ctx) return null;
+	return {
+		data: ctx.getImageData(0, 0, frame.width, frame.height).data,
+		width: frame.width,
+		height: frame.height
+	};
+}
+/**
+* The largest person's mask, plus instances that overlap it and are no more
+* than twice its size (a flowing dress often comes back as "kite").
+*/
+function personSilhouette(seg) {
+	const people = seg.masks.filter((m) => m.category === "person");
+	if (people.length === 0) return void 0;
+	const person = people.reduce((a, b) => b.area > a.area ? b : a);
+	const box = seg.detections[person.detectionIndex]?.boundingBox;
+	const out = new Uint8Array(person.mask);
+	if (!box) return out;
+	for (const m of seg.masks) {
+		if (m === person || m.area > person.area * 2) continue;
+		const b = seg.detections[m.detectionIndex]?.boundingBox;
+		if (!b) continue;
+		if (Math.max(0, Math.min(box.originX + box.width, b.originX + b.width) - Math.max(box.originX, b.originX)) * Math.max(0, Math.min(box.originY + box.height, b.originY + b.height) - Math.max(box.originY, b.originY)) < .3 * b.width * b.height) continue;
+		for (let i = 0; i < out.length; i++) if (m.mask[i] > out[i]) out[i] = m.mask[i];
+	}
+	return out;
+}
+function downsampleMean(src, w, h, cell, dst, mw, mh) {
+	for (let my = 0; my < mh; my++) for (let mx = 0; mx < mw; mx++) {
+		let sum = 0;
+		let n = 0;
+		for (let y = my * cell; y < Math.min(h, (my + 1) * cell); y++) for (let x = mx * cell; x < Math.min(w, (mx + 1) * cell); x++) {
+			sum += src[y * w + x];
+			n++;
+		}
+		dst[my * mw + mx] = n ? Math.round(sum / n) : 0;
+	}
+}
+/** A mask as (value, run length) pairs: long flat runs with soft edges. */
+function encodeRuns(mask) {
+	let runs = 0;
+	for (let i = 1; i <= mask.length; i++) if (i === mask.length || mask[i] !== mask[i - 1]) runs++;
+	const values = new Uint8Array(runs);
+	const lengths = new Uint32Array(runs);
+	let r = 0;
+	let start = 0;
+	for (let i = 1; i <= mask.length; i++) if (i === mask.length || mask[i] !== mask[start]) {
+		values[r] = mask[start];
+		lengths[r++] = i - start;
+		start = i;
+	}
+	return {
+		values,
+		lengths
+	};
+}
+function decodeRuns(runs, size$1) {
+	const out = new Uint8Array(size$1);
+	let at = 0;
+	for (let r = 0; r < runs.values.length; r++) {
+		const end = Math.min(size$1, at + runs.lengths[r]);
+		if (runs.values[r] !== 0) out.fill(runs.values[r], at, end);
+		at = end;
+	}
+	return out;
+}
+/** Separable box blur to 0–1, so gradients reach a little past the edge. */
+function boxBlur(src, w, h, r) {
+	const tmp = new Float32Array(w * h);
+	const dst = new Float32Array(w * h);
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		let s = 0;
+		let n = 0;
+		for (let k = -r; k <= r; k++) {
+			const xx = x + k;
+			if (xx >= 0 && xx < w) {
+				s += src[y * w + xx];
+				n++;
+			}
+		}
+		tmp[y * w + x] = s / n / 255;
+	}
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		let s = 0;
+		let n = 0;
+		for (let k = -r; k <= r; k++) {
+			const yy = y + k;
+			if (yy >= 0 && yy < h) {
+				s += tmp[yy * w + x];
+				n++;
+			}
+		}
+		dst[y * w + x] = s / n;
+	}
+	return dst;
+}
+
+//#endregion
+//#region src/physics/core.ts
+const CHANNEL_TOLERANCE_SCALE = {
+	rotation: .2,
+	rotateX: .2,
+	rotateY: .2,
+	rotateZ: .2
+};
+function sampleDriver(driver, frame, fps) {
+	if (typeof driver === "number") return driver;
+	if (typeof driver === "function") return driver(frame);
+	const time = frame / fps;
+	return driver.get({
+		frame,
+		fps,
+		time,
+		duration: 0,
+		durationMs: 0,
+		progress: 0,
+		deltaTime: 1 / fps
+	});
+}
+/** Shortest-path angle continuation so rotation never jumps by 360. */
+function unwrapDegrees(previous, next) {
+	let d = next - previous;
+	d -= Math.round(d / 360) * 360;
+	return previous + d;
+}
+/**
+* Ramer–Douglas–Peucker over one channel: the fewest linear keyframes that
+* stay within `tolerance` of every simulated frame.
+*/
+function simplifyKeys(values, tolerance) {
+	const n = values.length;
+	if (n === 0) return [];
+	const keep = new Uint8Array(n);
+	keep[0] = 1;
+	keep[n - 1] = 1;
+	const stack$1 = [[0, n - 1]];
+	while (stack$1.length > 0) {
+		const [a, b] = stack$1.pop();
+		let worst = -1;
+		let worstErr = tolerance;
+		for (let i = a + 1; i < b; i++) {
+			const t = (i - a) / (b - a);
+			const lerp = values[a] + (values[b] - values[a]) * t;
+			const err = Math.abs(values[i] - lerp);
+			if (err > worstErr) {
+				worstErr = err;
+				worst = i;
+			}
+		}
+		if (worst >= 0) {
+			keep[worst] = 1;
+			stack$1.push([a, worst], [worst, b]);
+		}
+	}
+	const keys = [];
+	for (let i = 0; i < n; i++) if (keep[i]) keys.push([
+		i,
+		round4(values[i]),
+		"none"
+	]);
+	if (keys.length === 2 && keys[0][1] === keys[1][1]) keys.pop();
+	return keys;
+}
+function round4(v) {
+	return Math.round(v * 1e4) / 1e4;
+}
+/**
+* Per-frame recordings of one body, indexed by composition frame. Arrays are
+* filled when the world simulates; reading a signal before that simulates.
+*/
+var Recording = class {
+	channels = /* @__PURE__ */ new Map();
+	signals = /* @__PURE__ */ new Map();
+	constructor(length, fps, ensure) {
+		this.length = length;
+		this.fps = fps;
+		this.ensure = ensure;
+	}
+	channel(name) {
+		let arr = this.channels.get(name);
+		if (!arr) {
+			arr = new Float32Array(this.length);
+			this.channels.set(name, arr);
+		}
+		return arr;
+	}
+	/**
+	* 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) {
+		let sig = this.signals.get(name);
+		if (!sig) {
+			const arr = this.channel(name);
+			const fps = this.fps;
+			sig = Signal.builder({
+				type: "custom",
+				fn: (ctx) => {
+					this.ensure();
+					const f = ctx.fps && ctx.fps !== fps ? ctx.frame / ctx.fps * fps : ctx.frame;
+					return arr[Math.max(0, Math.min(arr.length - 1, Math.round(f)))];
+				}
+			});
+			this.signals.set(name, sig);
+		}
+		return sig;
+	}
+};
+/**
+* Stepping, recording, impacts and output shared by `PhysicsWorld2D` and
+* `PhysicsWorld3D`. V is a vector in backend units (meters).
+*/
+var WorldCore = class {
+	fps;
+	frames;
+	startFrame;
+	pixelsPerMeter;
+	substeps;
+	impactDecay;
+	impactReference;
+	bodies = [];
+	forces = [];
+	impulses = [];
+	fields = [];
+	worldRecording;
+	allCollisions = [];
+	/** No more bodies, joints or forces: the world has started (or finished). */
+	locked = false;
+	liveMode = false;
+	stepper;
+	chain = Promise.resolve();
+	constructor(sim, gravity, options) {
+		this.sim = sim;
+		this.gravity = gravity;
+		if (!(options.fps > 0)) throw new Error("Physics: `fps` must be > 0.");
+		if (!(options.frames >= 1) || !Number.isInteger(options.frames)) throw new Error("Physics: `frames` must be a positive integer.");
+		this.fps = options.fps;
+		this.frames = options.frames;
+		this.startFrame = Math.max(0, Math.round(options.startFrame ?? 0));
+		this.pixelsPerMeter = options.pixelsPerMeter ?? 100;
+		this.substeps = Math.max(1, Math.round(options.substeps ?? 4));
+		this.impactDecay = Math.max(.5, options.impactDecay ?? 8);
+		this.impactReference = options.impactReference ?? 1500;
+		this.worldRecording = this.newRecording();
+	}
+	/** First contacts so far (all of them once simulated), in frame order. */
+	get collisions() {
+		this.ensureSimulated();
+		return this.allCollisions;
+	}
+	/** Loudest impact envelope of any body each frame: camera shake, flashes, hit sounds. */
+	get impact() {
+		return this.worldRecording.signal("impact");
+	}
+	/** Runs the whole simulation now (once) and binds every body's layer per its `output`. */
+	simulate() {
+		if (this.liveMode) throw new Error("Physics: this world is live; it steps as frames render.");
+		this.ensureSimulated();
+		return this;
+	}
+	/** Like {@link simulate}, but writes keyframes for every body whose `output` was left at its default. */
+	bakeKeyframes(options = {}) {
+		if (this.locked) throw new Error("Physics: bakeKeyframes() must come before simulate(), live() or reading any body signal.");
+		this.bakeDefault = options;
+		this.ensureSimulated();
+		return 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, options = {}) {
+		if (this.locked) throw new Error("Physics: live() must come before simulate() or reading any body signal.");
+		this.locked = true;
+		this.liveMode = true;
+		const prepare = async (frame) => {
+			await comp.prepareVision?.(frame);
+			for (const input of options.inputs ?? []) await input.ready(frame);
+		};
+		this.prepareInputs = prepare;
+		for (const body of this.bodies) this.bind(body);
+		comp.onPrepareFrame((ctx) => this.advanceTo(ctx.frame));
+		return 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) {
+		this.chain = this.chain.then(async () => {
+			const target = Math.min(this.frames - 1, Math.round(frame) - this.startFrame);
+			if (!this.stepper) {
+				await this.prepareInputs?.(this.startFrame);
+				this.stepper = this.begin();
+			}
+			const st = this.stepper;
+			while (st.current < target) {
+				const next = st.current + 1;
+				await this.prepareInputs?.(this.startFrame + next);
+				this.stepFrame(st, next);
+			}
+			if (st.current === this.frames - 1 && !st.freed) {
+				st.freed = true;
+				this.sim.free();
+			}
+		});
+		return this.chain;
+	}
+	prepareInputs;
+	bakeDefault;
+	newRecording() {
+		return new Recording(this.startFrame + this.frames, this.fps, () => this.ensureSimulated());
+	}
+	assertOpen() {
+		if (this.locked) throw new Error("Physics: the world has already started; add every body, joint and force before simulate(), live() or reading signals.");
+	}
+	addBody(body) {
+		this.assertOpen();
+		this.bodies.push(body);
+		return body;
+	}
+	addForce(body, accel) {
+		this.assertOpen();
+		this.forces.push({
+			body,
+			accel
+		});
+	}
+	addField(accel, targets) {
+		this.assertOpen();
+		this.fields.push({
+			accel,
+			...targets && { targets: new Set(targets) }
+		});
+	}
+	addImpulse(body, frame, dv) {
+		this.assertOpen();
+		this.impulses.push({
+			body,
+			frame: Math.round(frame),
+			dv
+		});
+	}
+	ensureSimulated() {
+		if (this.locked) return;
+		this.locked = true;
+		const st = this.begin();
+		for (let f = 1; f < this.frames; f++) this.stepFrame(st, f);
+		st.freed = true;
+		this.sim.free();
+		for (const body of this.bodies) this.bind(body);
+	}
+	/** Records frame 0 and sets every channel to it, so frames not simulated yet hold the start pose. */
+	begin() {
+		const { startFrame } = this;
+		const bodies = this.bodies;
+		const bySim = /* @__PURE__ */ new Map();
+		for (const b of bodies) bySim.set(b.sim, b);
+		for (const b of bodies) if (b.startFrame > 0) b.sim.setEnabled(false);
+		const kinematicFrom = /* @__PURE__ */ new Map();
+		for (const b of bodies) {
+			b.record(startFrame, -1);
+			b.recording.channel("impact");
+			const t = b.kinematicTarget?.(startFrame);
+			if (t) kinematicFrom.set(b, t);
+		}
+		this.worldRecording.channel("impact");
+		for (const rec of [...bodies.map((b) => b.recording), this.worldRecording]) for (const arr of rec.channels.values()) arr.fill(arr[startFrame]);
+		return {
+			current: 0,
+			freed: false,
+			bySim,
+			kinematicFrom,
+			level: new Map(bodies.map((b) => [b, 0]))
+		};
+	}
+	stepFrame(st, f) {
+		const { fps, startFrame, substeps } = this;
+		const dt = 1 / (fps * substeps);
+		const bodies = this.bodies;
+		const frame = startFrame + f;
+		const dims = this.gravity.length;
+		const prevVel = /* @__PURE__ */ new Map();
+		for (const b of bodies) {
+			if (b.startFrame > 0 && f === b.startFrame + 1) b.sim.setEnabled(true);
+			prevVel.set(b, b.sim.velocity());
+		}
+		const isActive = (b) => b.type === "dynamic" && f > b.startFrame;
+		const expected = /* @__PURE__ */ new Map();
+		for (const b of bodies) expected.set(b, this.gravity.map((g) => isActive(b) ? g * b.gravityScale / fps : 0));
+		for (const imp of this.impulses) {
+			if (imp.frame !== f) continue;
+			const body = imp.body;
+			if (!isActive(body)) continue;
+			const m = body.sim.mass();
+			body.sim.applyImpulse(imp.dv.map((v) => v * m));
+			const e = expected.get(body);
+			for (let i = 0; i < dims; i++) e[i] += imp.dv[i];
+		}
+		const frameForces = this.forces.filter((fe) => isActive(fe.body)).map((fe) => {
+			const body = fe.body;
+			const a = fe.accel(frame);
+			const e = expected.get(body);
+			for (let i = 0; i < dims; i++) e[i] += a[i] / fps;
+			return {
+				body,
+				a
+			};
+		});
+		const kinematicTo = /* @__PURE__ */ new Map();
+		for (const b of bodies) {
+			const t = b.kinematicTarget?.(frame);
+			if (t) kinematicTo.set(b, t);
+		}
+		const started = /* @__PURE__ */ new Set();
+		const pairs = [];
+		for (let s = 1; s <= substeps; s++) {
+			for (const { body, a } of frameForces) {
+				const m = body.sim.mass();
+				body.sim.applyImpulse(a.map((v) => v * m * dt));
+			}
+			for (const field of this.fields) for (const b of bodies) {
+				if (!isActive(b) || field.targets && !field.targets.has(b)) continue;
+				const a = field.accel(b, frame);
+				if (!a) continue;
+				const m = b.sim.mass();
+				b.sim.applyImpulse(a.map((v) => v * m * dt));
+				const e = expected.get(b);
+				for (let i = 0; i < dims; i++) e[i] += a[i] * dt;
+			}
+			for (const [b, to] of kinematicTo) {
+				const from = st.kinematicFrom.get(b) ?? to;
+				const k = s / substeps;
+				b.sim.setKinematicTarget(lerpVec(from.position, to.position, k), this.lerpRotation(from.rotation, to.rotation, k));
+			}
+			this.sim.step(dt);
+			for (const [sa, sb] of this.sim.drainCollisionStarts()) {
+				const a = st.bySim.get(sa);
+				const b = st.bySim.get(sb);
+				if (!a || !b) continue;
+				const key = `${bodies.indexOf(a)}:${bodies.indexOf(b)}`;
+				if (started.has(key)) continue;
+				started.add(key);
+				pairs.push([a, b]);
+			}
+		}
+		st.kinematicFrom = kinematicTo;
+		for (const b of bodies) b.record(frame, frame - 1);
+		const raw = /* @__PURE__ */ new Map();
+		if (pairs.length > 0) {
+			const ppm = this.pixelsPerMeter;
+			const hit = (b) => {
+				if (b.type !== "dynamic") return 0;
+				const v = b.sim.velocity();
+				const v0 = prevVel.get(b);
+				const e = expected.get(b);
+				let sq = 0;
+				for (let i = 0; i < dims; i++) {
+					const d = v[i] - (v0[i] + e[i]);
+					sq += d * d;
+				}
+				return Math.sqrt(sq) * ppm;
+			};
+			for (const [a, b] of pairs) {
+				const speed = Math.max(hit(a), hit(b));
+				for (const [self, other] of [[a, b], [b, a]]) {
+					raw.set(self, Math.max(raw.get(self) ?? 0, speed));
+					const c = {
+						frame,
+						with: other,
+						speed
+					};
+					self.collisions.push(c);
+					if (self === a) this.allCollisions.push({
+						...c,
+						body: a
+					});
+				}
+			}
+		}
+		const decay = Math.exp(-1 / this.impactDecay);
+		let loudest = 0;
+		for (const b of bodies) {
+			const level = Math.max((raw.get(b) ?? 0) / this.impactReference, (st.level.get(b) ?? 0) * decay);
+			st.level.set(b, level);
+			b.recording.channel("impact")[frame] = level;
+			if (level > loudest) loudest = level;
+		}
+		this.worldRecording.channel("impact")[frame] = loudest;
+		st.current = f;
+	}
+	bind(body) {
+		const layer = body.layer;
+		const output = body.output ?? (this.bakeDefault ? "keyframes" : "signals");
+		if (typeof layer?.animate !== "function" || output === "none") return;
+		if (body.type === "fixed") return;
+		const channels = body.boundChannels();
+		if (output === "keyframes" && this.liveMode) throw new Error("Physics: live worlds bind signals; drop `output: \"keyframes\"` or use simulate().");
+		if (output === "signals") {
+			const anim$1 = LayerAnimation.create();
+			for (const [prop, channel] of channels) anim$1.signal(prop, body.recording.signal(channel));
+			layer.animate(anim$1);
+			return;
+		}
+		const tolerance = this.bakeDefault?.tolerance ?? .25;
+		const anim = LayerAnimation.create();
+		for (const [prop, channel] of channels) {
+			const local = body.recording.channel(channel).subarray(this.startFrame);
+			const scale = CHANNEL_TOLERANCE_SCALE[prop] ?? 1;
+			anim.keys(prop, simplifyKeys(local, tolerance * scale));
+		}
+		layer.animate(anim);
+	}
+};
+function lerpVec(a, b, t) {
+	return a.map((v, i) => v + (b[i] - v) * t);
+}
+
+//#endregion
+//#region src/particles.ts
+const range = (r, fallback) => r === void 0 ? fallback : typeof r === "number" ? [r, r] : r;
+/**
+* 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.
+*/
+var Particles = class extends Effect$1 {
+	op = "Particles";
+	particleStatic;
+	particleState;
+	options;
+	constructor(options) {
+		super({});
+		this.options = options;
+		const e = options.emitter ?? {};
+		const staticPos = (d) => typeof d === "number" ? d : void 0;
+		const width = options.width;
+		const height = options.height;
+		const colors = (Array.isArray(options.color) ? options.color : [options.color ?? "#ffffff"]).map((c) => {
+			const p = parseColor(c);
+			return [
+				p.r,
+				p.g,
+				p.b,
+				p.a
+			];
+		});
+		this.particleStatic = {
+			max: Math.max(1, Math.round(options.max ?? 2e4)),
+			seed: Math.round(options.seed ?? 1) >>> 0,
+			layer: {
+				x: options.x ?? 0,
+				y: options.y ?? 0,
+				width,
+				height
+			},
+			emitter: {
+				shape: e.shape ?? "rect",
+				x: staticPos(e.x) ?? (e.shape === "circle" || e.shape === "ring" || e.shape === "point" ? width / 2 : 0),
+				y: staticPos(e.y) ?? (e.shape === "circle" || e.shape === "ring" || e.shape === "point" ? height / 2 : 0),
+				width: e.width ?? width,
+				height: e.height ?? (e.shape === "line" ? 0 : height),
+				radius: e.radius ?? Math.min(width, height) / 4,
+				radial: e.radial ?? false
+			},
+			lifetime: range(options.lifetime, [2, 4]),
+			speed: range(options.speed, [40, 160]),
+			direction: options.direction ?? -90,
+			spread: options.spread ?? 360,
+			bounds: options.bounds ?? "none",
+			floor: options.floor ?? null,
+			bounce: options.bounce ?? .3,
+			size: range(options.size, [6, 0]),
+			sizeJitter: options.sizeJitter ?? .5,
+			fade: options.fade ?? [.1, .3],
+			shape: options.shape ?? "circle",
+			stretch: options.stretch ?? .04,
+			blend: options.blend ?? "normal",
+			colors: colors.slice(0, 8),
+			colorBySpeed: options.colorBySpeed ?? null,
+			opacity: options.opacity ?? 1,
+			substeps: options.substeps ?? 2,
+			prewarm: options.prewarm ?? 0
+		};
+	}
+	particleFrame(frame, fps) {
+		const o = this.options;
+		const read = (d, fallback) => d === void 0 ? fallback : sampleDriver(d, frame, fps);
+		const layerFrame = frame - (o.startFrame ?? 0);
+		const burst = (o.emitter?.bursts ?? []).filter((b) => Math.round(b.frame) === layerFrame).reduce((n, b) => n + b.count, 0);
+		const g = o.gravity;
+		const gravity = Array.isArray(g) ? [read(g[0], 0), read(g[1], 0)] : [0, read(g, 0)];
+		let push = null;
+		if (o.push) push = {
+			strength: read(o.push.strength, 6e3),
+			sweep: read(o.push.sweep, 6e4),
+			mask: o.push.person.silhouetteGrid(frame),
+			previous: o.push.person.silhouetteGrid(Math.max(0, frame - 1))
+		};
+		const ex = o.emitter?.x;
+		const ey = o.emitter?.y;
+		const moving = ex !== void 0 && typeof ex !== "number" || ey !== void 0 && typeof ey !== "number";
+		const at = (f) => ({
+			x: ex === void 0 ? this.particleStatic.emitter.x : sampleDriver(ex, f, fps),
+			y: ey === void 0 ? this.particleStatic.emitter.y : sampleDriver(ey, f, fps)
+		});
+		let emitter;
+		if (moving) {
+			const now = at(frame);
+			const before = at(Math.max(0, frame - 1));
+			emitter = {
+				x: now.x,
+				y: now.y,
+				previousX: before.x,
+				previousY: before.y
+			};
+		}
+		return {
+			...emitter && { emitter },
+			rate: read(o.emitter?.rate, 1e3),
+			burst,
+			gravity,
+			drag: read(o.drag, .4),
+			noise: {
+				strength: read(o.noise?.strength, 0),
+				scale: o.noise?.scale ?? 300,
+				speed: o.noise?.speed ?? .3
+			},
+			attractors: (o.attractors ?? []).map((a) => ({
+				x: read(a.x, 0),
+				y: read(a.y, 0),
+				strength: read(a.strength, 0),
+				radius: a.radius ?? 200
+			})),
+			push
+		};
+	}
+};
+
 //#endregion
 //#region src/shapes3d.ts
 const MATERIAL_KEYS = [
@@ -1954,25 +3116,1755 @@ const Lighting = {
 };
 
 //#endregion
-//#region src/index.ts
-function decorateTrackSignals(track, source) {
-	if (!track) return track;
-	if (source && !track.source) Object.defineProperty(track, "source", {
-		value: source,
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	if (typeof track.section !== "function") Object.defineProperty(track, "section", {
-		value: (sourceOrOptions, options) => {
-			if (typeof sourceOrOptions === "object" && sourceOrOptions !== null && !("kind" in sourceOrOptions) && !("inputHandleId" in sourceOrOptions) && !("src" in sourceOrOptions)) {
-				const resolvedSource$1 = sourceOrOptions.source ?? track.source ?? source;
-				return Layer.section(resolvedSource$1, track, sourceOrOptions);
+//#region src/physics/backend.ts
+const RAPIER_2D = "@dimforge/rapier2d-deterministic-compat";
+const RAPIER_3D = "@dimforge/rapier3d-deterministic-compat";
+async function loadRapier(specifier, load) {
+	let mod;
+	try {
+		mod = await load();
+	} catch (error) {
+		throw new Error(`Physics needs the optional dependency "${specifier}". Install it with \`npm i ${specifier}\`.`, { cause: error });
+	}
+	const rapier = mod.default ?? mod;
+	await rapier.init();
+	return rapier;
+}
+let rapier2d;
+let rapier3d;
+/** Loads and initializes Rapier once per process; 2D and 3D are separate modules. */
+async function rapierBackend(dims) {
+	if (dims === 2) {
+		rapier2d ??= loadRapier(RAPIER_2D, () => import("@dimforge/rapier2d-deterministic-compat"));
+		const R$1 = await rapier2d;
+		return {
+			createWorld2D: (gravity) => new RapierWorld2D(R$1, gravity),
+			createWorld3D: () => {
+				throw new Error("This backend was loaded for 2D.");
 			}
-			const resolvedSource = sourceOrOptions ?? track.source ?? source;
-			return Layer.section(resolvedSource, track, options);
+		};
+	}
+	rapier3d ??= loadRapier(RAPIER_3D, () => import("@dimforge/rapier3d-deterministic-compat"));
+	const R = await rapier3d;
+	return {
+		createWorld2D: () => {
+			throw new Error("This backend was loaded for 3D.");
 		},
-		enumerable: false,
+		createWorld3D: (gravity) => new RapierWorld3D(R, gravity)
+	};
+}
+var RapierWorld2D = class {
+	world;
+	events;
+	byCollider = /* @__PURE__ */ new Map();
+	started = [];
+	constructor(R, gravity) {
+		this.R = R;
+		this.world = new R.World({
+			x: gravity[0],
+			y: gravity[1]
+		});
+		this.events = new R.EventQueue(true);
+	}
+	addBody(spec$1) {
+		const R = this.R;
+		const desc = bodyDesc(R, spec$1.type).setTranslation(spec$1.position[0], spec$1.position[1]).setRotation(spec$1.angle).setLinvel(spec$1.velocity[0], spec$1.velocity[1]).setAngvel(spec$1.angularVelocity).setLinearDamping(spec$1.linearDamping).setAngularDamping(spec$1.angularDamping).setGravityScale(spec$1.gravityScale).setCcdEnabled(spec$1.ccd).setEnabled(spec$1.enabled);
+		if (spec$1.lockRotation) desc.lockRotations();
+		const body = this.world.createRigidBody(desc);
+		const collider = this.world.createCollider(shapeDesc2D(R, spec$1.shape).setDensity(spec$1.density).setFriction(spec$1.friction).setRestitution(spec$1.restitution).setActiveEvents(R.ActiveEvents.COLLISION_EVENTS).setSensor(spec$1.sensor ?? false), body);
+		const sim = {
+			raw: body,
+			position: () => {
+				const t = body.translation();
+				return [t.x, t.y];
+			},
+			rotation: () => body.rotation(),
+			velocity: () => {
+				const v = body.linvel();
+				return [v.x, v.y];
+			},
+			angularVelocity: () => body.angvel(),
+			sleeping: () => body.isSleeping(),
+			mass: () => body.mass(),
+			setEnabled: (on) => body.setEnabled(on),
+			applyImpulse: ([x, y]) => body.applyImpulse({
+				x,
+				y
+			}, true),
+			setKinematicTarget: ([x, y], angle) => {
+				body.setNextKinematicTranslation({
+					x,
+					y
+				});
+				body.setNextKinematicRotation(angle);
+			}
+		};
+		this.byCollider.set(collider.handle, sim);
+		return sim;
+	}
+	addJoint(a, b, spec$1) {
+		const R = this.R;
+		const a1 = {
+			x: spec$1.anchorA[0],
+			y: spec$1.anchorA[1]
+		};
+		const a2 = {
+			x: spec$1.anchorB[0],
+			y: spec$1.anchorB[1]
+		};
+		let data;
+		switch (spec$1.type) {
+			case "revolute":
+			case "spherical":
+				data = R.JointData.revolute(a1, a2);
+				break;
+			case "fixed":
+				data = R.JointData.fixed(a1, 0, a2, 0);
+				break;
+			case "rope":
+				data = R.JointData.rope(spec$1.length, a1, a2);
+				break;
+			case "spring":
+				data = R.JointData.spring(spec$1.restLength, spec$1.stiffness, spec$1.damping, a1, a2);
+				break;
+		}
+		this.world.createImpulseJoint(data, rawBody(a), rawBody(b), true).setContactsEnabled(false);
+	}
+	step(dt) {
+		this.world.timestep = dt;
+		this.world.step(this.events);
+		this.events.drainCollisionEvents((h1, h2, started) => {
+			if (!started) return;
+			const a = this.byCollider.get(h1);
+			const b = this.byCollider.get(h2);
+			if (a && b) this.started.push([a, b]);
+		});
+	}
+	drainCollisionStarts() {
+		return this.started.splice(0);
+	}
+	free() {
+		this.events.free();
+		this.world.free();
+	}
+};
+var RapierWorld3D = class {
+	world;
+	events;
+	byCollider = /* @__PURE__ */ new Map();
+	started = [];
+	constructor(R, gravity) {
+		this.R = R;
+		this.world = new R.World({
+			x: gravity[0],
+			y: gravity[1],
+			z: gravity[2]
+		});
+		this.events = new R.EventQueue(true);
+	}
+	addBody(spec$1) {
+		const R = this.R;
+		const [qx, qy, qz, qw] = spec$1.rotation;
+		const desc = bodyDesc(R, spec$1.type).setTranslation(spec$1.position[0], spec$1.position[1], spec$1.position[2]).setRotation({
+			x: qx,
+			y: qy,
+			z: qz,
+			w: qw
+		}).setLinvel(spec$1.velocity[0], spec$1.velocity[1], spec$1.velocity[2]).setAngvel(vec3(spec$1.lockRotation ? [
+			0,
+			0,
+			0
+		] : spec$1.angularVelocity.map((w, i) => spec$1.enabledRotations && !spec$1.enabledRotations[i] ? 0 : w))).setLinearDamping(spec$1.linearDamping).setAngularDamping(spec$1.angularDamping).setGravityScale(spec$1.gravityScale).setCcdEnabled(spec$1.ccd).setEnabled(spec$1.enabled);
+		if (spec$1.lockRotation) desc.lockRotations();
+		else if (spec$1.enabledRotations) desc.enabledRotations(...spec$1.enabledRotations);
+		const body = this.world.createRigidBody(desc);
+		const shape = shapeDesc3D(R, spec$1.shape);
+		const collider = this.world.createCollider(shape.setDensity(spec$1.density).setFriction(spec$1.friction).setRestitution(spec$1.restitution).setActiveEvents(R.ActiveEvents.COLLISION_EVENTS).setSensor(spec$1.sensor ?? false), body);
+		const sim = {
+			raw: body,
+			position: () => {
+				const t = body.translation();
+				return [
+					t.x,
+					t.y,
+					t.z
+				];
+			},
+			rotation: () => {
+				const q = body.rotation();
+				return [
+					q.x,
+					q.y,
+					q.z,
+					q.w
+				];
+			},
+			velocity: () => {
+				const v = body.linvel();
+				return [
+					v.x,
+					v.y,
+					v.z
+				];
+			},
+			angularVelocity: () => {
+				const w = body.angvel();
+				return [
+					w.x,
+					w.y,
+					w.z
+				];
+			},
+			sleeping: () => body.isSleeping(),
+			mass: () => body.mass(),
+			setEnabled: (on) => body.setEnabled(on),
+			applyImpulse: (v) => body.applyImpulse(vec3(v), true),
+			setKinematicTarget: (p, [x, y, z, w]) => {
+				body.setNextKinematicTranslation(vec3(p));
+				body.setNextKinematicRotation({
+					x,
+					y,
+					z,
+					w
+				});
+			}
+		};
+		this.byCollider.set(collider.handle, sim);
+		return sim;
+	}
+	addJoint(a, b, spec$1) {
+		const R = this.R;
+		const a1 = vec3(spec$1.anchorA);
+		const a2 = vec3(spec$1.anchorB);
+		let data;
+		switch (spec$1.type) {
+			case "revolute":
+				data = R.JointData.revolute(a1, a2, vec3(spec$1.axis ?? [
+					0,
+					0,
+					1
+				]));
+				break;
+			case "spherical":
+				data = R.JointData.spherical(a1, a2);
+				break;
+			case "fixed": {
+				const identity = {
+					x: 0,
+					y: 0,
+					z: 0,
+					w: 1
+				};
+				data = R.JointData.fixed(a1, identity, a2, identity);
+				break;
+			}
+			case "rope":
+				data = R.JointData.rope(spec$1.length, a1, a2);
+				break;
+			case "spring":
+				data = R.JointData.spring(spec$1.restLength, spec$1.stiffness, spec$1.damping, a1, a2);
+				break;
+		}
+		this.world.createImpulseJoint(data, rawBody(a), rawBody(b), true).setContactsEnabled(false);
+	}
+	step(dt) {
+		this.world.timestep = dt;
+		this.world.step(this.events);
+		this.events.drainCollisionEvents((h1, h2, started) => {
+			if (!started) return;
+			const a = this.byCollider.get(h1);
+			const b = this.byCollider.get(h2);
+			if (a && b) this.started.push([a, b]);
+		});
+	}
+	drainCollisionStarts() {
+		return this.started.splice(0);
+	}
+	free() {
+		this.events.free();
+		this.world.free();
+	}
+};
+function vec3([x, y, z]) {
+	return {
+		x,
+		y,
+		z
+	};
+}
+function rawBody(body) {
+	return body.raw;
+}
+function bodyDesc(R, type) {
+	const D = R.RigidBodyDesc;
+	return type === "fixed" ? D.fixed() : type === "kinematic" ? D.kinematicPositionBased() : D.dynamic();
+}
+function shapeDesc2D(R, shape) {
+	switch (shape.kind) {
+		case "ball": return R.ColliderDesc.ball(shape.radius);
+		case "box": {
+			const r = Math.min(shape.radius ?? 0, shape.hx / 2, shape.hy / 2);
+			return r > 0 ? R.ColliderDesc.roundCuboid(shape.hx - r, shape.hy - r, r) : R.ColliderDesc.cuboid(shape.hx, shape.hy);
+		}
+		case "hull": {
+			const desc = R.ColliderDesc.convexHull(new Float32Array(shape.points));
+			if (!desc) throw new Error("Physics: could not build a convex hull for this shape.");
+			return desc;
+		}
+	}
+}
+function shapeDesc3D(R, shape) {
+	switch (shape.kind) {
+		case "ball": return R.ColliderDesc.ball(shape.radius);
+		case "box": {
+			const r = Math.min(shape.radius ?? 0, shape.hx / 2, shape.hy / 2, shape.hz / 2);
+			return r > 0 ? R.ColliderDesc.roundCuboid(shape.hx - r, shape.hy - r, shape.hz - r, r) : R.ColliderDesc.cuboid(shape.hx, shape.hy, shape.hz);
+		}
+		case "cylinder": return R.ColliderDesc.cylinder(shape.halfHeight, shape.radius);
+		case "hull": {
+			const desc = R.ColliderDesc.convexHull(new Float32Array(shape.points));
+			if (!desc) throw new Error("Physics: could not build a convex hull for this shape.");
+			return desc;
+		}
+	}
+}
+
+//#endregion
+//#region src/physics/world2d.ts
+/**
+* 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.
+*/
+var PhysicsBody2D = class {
+	collisions = [];
+	/** @internal */ recording;
+	/** @internal */ sim;
+	/** @internal */
+	constructor(world, sim, type, layer, frame, options, recording) {
+		this.world = world;
+		this.type = type;
+		this.layer = layer;
+		this.frame = frame;
+		this.options = options;
+		this.sim = sim;
+		this.recording = recording;
+	}
+	get startFrame() {
+		return Math.max(0, Math.round(this.options.startFrame ?? 0));
+	}
+	get gravityScale() {
+		return this.options.gravityScale ?? 1;
+	}
+	get output() {
+		return this.options.output;
+	}
+	/** The layer's `x` (top-left) every frame. */
+	get x() {
+		return this.recording.signal("x");
+	}
+	/** The layer's `y` (top-left) every frame. */
+	get y() {
+		return this.recording.signal("y");
+	}
+	/** Degrees, clockwise, continuous (no jump at 360). */
+	get rotation() {
+		return this.recording.signal("rotation");
+	}
+	/** Body center, px. */
+	get centerX() {
+		return this.recording.signal("centerX");
+	}
+	get centerY() {
+		return this.recording.signal("centerY");
+	}
+	/** px/s. */
+	get vx() {
+		return this.recording.signal("vx");
+	}
+	get vy() {
+		return this.recording.signal("vy");
+	}
+	/** px/s. */
+	get speed() {
+		return this.recording.signal("speed");
+	}
+	/** Degrees per second. */
+	get angularVelocity() {
+		return this.recording.signal("angularVelocity");
+	}
+	/**
+	* Hit envelope: jumps on each new contact (1 ≈ a 1500 px/s velocity
+	* change, see `impactReference`) and decays over `impactDecay` frames.
+	*/
+	get impact() {
+		return this.recording.signal("impact");
+	}
+	/** 1 while the body is at rest, else 0. */
+	get sleeping() {
+		return this.recording.signal("sleeping");
+	}
+	/** @internal */
+	kinematicTarget(frame) {
+		const follow = this.options.follow;
+		if (this.type !== "kinematic" || !follow) return void 0;
+		const f = this.frame;
+		const fps = this.world.fps;
+		const x = follow.x === void 0 ? void 0 : sampleDriver(follow.x, frame, fps);
+		const y = follow.y === void 0 ? void 0 : sampleDriver(follow.y, frame, fps);
+		const rotation = follow.rotation === void 0 ? f.rotation : sampleDriver(follow.rotation, frame, fps);
+		const start = this.initialLayerXY();
+		const center = layerToCenter(x ?? start[0], y ?? start[1], rotation, f);
+		const ppm = this.world.pixelsPerMeter;
+		return {
+			position: [center[0] / ppm, center[1] / ppm],
+			rotation: rotation * Math.PI / 180
+		};
+	}
+	initialLayerXY() {
+		const l = this.layer;
+		return [Number(l?.x ?? 0), Number(l?.y ?? 0)];
+	}
+	/** @internal */
+	record(index, previous) {
+		const ppm = this.world.pixelsPerMeter;
+		const [mx, my] = this.sim.position();
+		const cx = mx * ppm;
+		const cy = my * ppm;
+		const rec = this.recording;
+		const rotation = rec.channel("rotation");
+		const deg = this.sim.rotation() * 180 / Math.PI;
+		rotation[index] = previous < 0 ? unwrapDegrees(this.frame.rotation, deg) : unwrapDegrees(rotation[previous], deg);
+		const [x, y] = centerToLayer(cx, cy, rotation[index], this.frame);
+		rec.channel("x")[index] = x;
+		rec.channel("y")[index] = y;
+		rec.channel("centerX")[index] = cx;
+		rec.channel("centerY")[index] = cy;
+		const [vx, vy] = this.sim.velocity();
+		rec.channel("vx")[index] = vx * ppm;
+		rec.channel("vy")[index] = vy * ppm;
+		rec.channel("speed")[index] = Math.hypot(vx, vy) * ppm;
+		rec.channel("angularVelocity")[index] = this.sim.angularVelocity() * 180 / Math.PI;
+		rec.channel("sleeping")[index] = this.sim.sleeping() ? 1 : 0;
+	}
+	/** @internal */
+	boundChannels() {
+		const out = [["x", "x"], ["y", "y"]];
+		if (!this.options.lockRotation) out.push(["rotation", "rotation"]);
+		return out;
+	}
+	/** @internal World-space point (px) → this body's local frame (meters), at the start pose. */
+	localAnchor(point) {
+		if (!point) return [0, 0];
+		const ppm = this.world.pixelsPerMeter;
+		const [px, py] = this.sim.position();
+		const a = -this.sim.rotation();
+		const dx = point[0] / ppm - px;
+		const dy = point[1] / ppm - py;
+		return [dx * Math.cos(a) - dy * Math.sin(a), dx * Math.sin(a) + dy * Math.cos(a)];
+	}
+	/** @internal Start-pose center in px. */
+	center() {
+		const ppm = this.world.pixelsPerMeter;
+		const [x, y] = this.sim.position();
+		return [x * ppm, y * ppm];
+	}
+};
+/**
+* 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.
+*/
+var PhysicsWorld2D = class extends WorldCore {
+	/** @internal */
+	constructor(backend, options) {
+		const ppm = options.pixelsPerMeter ?? 100;
+		const g = options.gravity ?? 2400;
+		const gravity = typeof g === "number" ? [0, g / ppm] : [g[0] / ppm, g[1] / ppm];
+		const sim = backend.createWorld2D(gravity);
+		super(sim, gravity, options);
+	}
+	/**
+	* 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, options = {}) {
+		this.assertOpen();
+		const layer = typeof target.kind === "string" ? target : void 0;
+		const geom = layerGeometry(target, options);
+		const ppm = this.pixelsPerMeter;
+		const type = options.type ?? "dynamic";
+		const [cx, cy] = layerToCenter(geom.x, geom.y, geom.rotation, geom);
+		const v = options.velocity ?? [0, 0];
+		const spec$1 = {
+			type,
+			position: [cx / ppm, cy / ppm],
+			angle: geom.rotation * Math.PI / 180,
+			velocity: [v[0] / ppm, v[1] / ppm],
+			angularVelocity: (options.angularVelocity ?? 0) * Math.PI / 180,
+			linearDamping: options.linearDamping ?? 0,
+			angularDamping: options.angularDamping ?? 0,
+			gravityScale: options.gravityScale ?? 1,
+			lockRotation: options.lockRotation ?? false,
+			ccd: options.ccd ?? false,
+			enabled: true,
+			sensor: options.sensor ?? false,
+			density: options.density ?? 1,
+			friction: options.friction ?? .6,
+			restitution: options.restitution ?? .3,
+			shape: scaleShape$1(geom.shape, 1 / ppm)
+		};
+		const simBody = this.sim.addBody(spec$1);
+		const body = new PhysicsBody2D(this, simBody, type, layer, geom, options, this.newRecording());
+		return this.addBody(body);
+	}
+	/** A fixed, very wide floor whose top edge sits at `y`. */
+	ground(options) {
+		const t = 2e3;
+		const w = 1e6;
+		return this.body({
+			x: -w / 2,
+			y: options.y,
+			width: w,
+			height: t
+		}, {
+			type: "fixed",
+			friction: options.friction,
+			restitution: options.restitution ?? .2
+		});
+	}
+	/** Fixed floor, left and right walls (and optionally a ceiling) around a box, e.g. the canvas. */
+	walls(options) {
+		const { width: W, height: H } = options;
+		const x = options.x ?? 0;
+		const y = options.y ?? 0;
+		const t = options.thickness ?? 400;
+		const mat = {
+			type: "fixed",
+			friction: options.friction,
+			restitution: options.restitution ?? .2
+		};
+		const tall = H * 4 + t;
+		const result = {
+			floor: this.body({
+				x: x - t,
+				y: y + H,
+				width: W + 2 * t,
+				height: t
+			}, mat),
+			left: this.body({
+				x: x - t,
+				y: y + H - tall,
+				width: t,
+				height: tall
+			}, mat),
+			right: this.body({
+				x: x + W,
+				y: y + H - tall,
+				width: t,
+				height: tall
+			}, mat),
+			ceiling: void 0
+		};
+		if (options.ceiling) result.ceiling = this.body({
+			x: x - t,
+			y: y - t,
+			width: W + 2 * t,
+			height: t
+		}, mat);
+		return result;
+	}
+	/** Pins a body to the world at a point (default its center); it can still swing around it. */
+	pin(body, at) {
+		const point = at ?? body.center();
+		const anchor = this.anchorBody(point);
+		this.joint(body, anchor, {
+			type: "revolute",
+			anchorA: body.localAnchor(point),
+			anchorB: [0, 0]
+		});
+		return this;
+	}
+	/** Joins two bodies at a world point so they swing around it (a hinge). */
+	hinge(a, b, at) {
+		this.joint(a, b, {
+			type: "revolute",
+			anchorA: a.localAnchor(at),
+			anchorB: b.localAnchor(at)
+		});
+		return this;
+	}
+	/** Glues two bodies together rigidly. */
+	weld(a, b) {
+		const at = a.center();
+		this.joint(a, b, {
+			type: "fixed",
+			anchorA: [0, 0],
+			anchorB: b.localAnchor(at)
+		});
+		return this;
+	}
+	/** A damped spring between two bodies, or from a body to a world point. */
+	spring(a, b, options = {}) {
+		const { other, pa, pb } = this.endpoints(a, b, options.anchorA, options.anchorB);
+		const ppm = this.pixelsPerMeter;
+		const length = (options.length ?? Math.hypot(pb[0] - pa[0], pb[1] - pa[1])) / ppm;
+		const mass = effectiveMass(a, other);
+		const w = 2 * Math.PI * (options.frequency ?? 2);
+		this.joint(a, other, {
+			type: "spring",
+			anchorA: a.localAnchor(pa),
+			anchorB: other.localAnchor(pb),
+			restLength: length,
+			stiffness: mass * w * w,
+			damping: 2 * (options.dampingRatio ?? .2) * mass * w
+		});
+		return this;
+	}
+	/** A rope: never longer than `length`, slack when closer. */
+	rope(a, b, options = {}) {
+		const { other, pa, pb } = this.endpoints(a, b, options.anchorA, options.anchorB);
+		const length = options.length ?? Math.hypot(pb[0] - pa[0], pb[1] - pa[1]);
+		this.joint(a, other, {
+			type: "rope",
+			anchorA: a.localAnchor(pa),
+			anchorB: other.localAnchor(pb),
+			length: length / this.pixelsPerMeter
+		});
+		return this;
+	}
+	/** A steady push, px/s² (mass-independent): wind, magnets, audio. Drivers are read every frame. */
+	force(body, accel) {
+		const ppm = this.pixelsPerMeter;
+		this.addForce(body, (frame) => [accel.x === void 0 ? 0 : sampleDriver(accel.x, frame, this.fps) / ppm, accel.y === void 0 ? 0 : sampleDriver(accel.y, frame, this.fps) / ppm]);
+		return 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, options = {}) {
+		const ppm = this.pixelsPerMeter;
+		this.addField((body, frame) => {
+			const [x, y] = body.sim.position();
+			const [vx, vy] = body.sim.velocity();
+			const a = accel({
+				x: x * ppm,
+				y: y * ppm,
+				vx: vx * ppm,
+				vy: vy * ppm,
+				frame,
+				body
+			});
+			return a ? [a[0] / ppm, a[1] / ppm] : null;
+		}, options.bodies);
+		return this;
+	}
+	/** An instant kick at a simulation frame: adds `[vx, vy]` px/s to the body's velocity. */
+	impulse(body, frame, velocity) {
+		const ppm = this.pixelsPerMeter;
+		this.addImpulse(body, frame, [velocity[0] / ppm, velocity[1] / ppm]);
+		return this;
+	}
+	lerpRotation(a, b, t) {
+		return a + (b - a) * t;
+	}
+	joint(a, b, spec$1) {
+		this.assertOpen();
+		this.sim.addJoint(a.sim, b.sim, spec$1);
+	}
+	anchorBody(point) {
+		return this.body({
+			x: point[0] - .5,
+			y: point[1] - .5,
+			width: 1,
+			height: 1
+		}, {
+			type: "fixed",
+			output: "none",
+			sensor: true
+		});
+	}
+	endpoints(a, b, anchorA, anchorB) {
+		const pa = anchorA ?? a.center();
+		if (Array.isArray(b)) {
+			const pb = anchorB ?? b;
+			return {
+				other: this.anchorBody(pb),
+				pa,
+				pb
+			};
+		}
+		return {
+			other: b,
+			pa,
+			pb: anchorB ?? b.center()
+		};
+	}
+};
+function effectiveMass(a, b) {
+	const ma = a.type === "dynamic" ? a.sim.mass() : 0;
+	const mb = b.type === "dynamic" ? b.sim.mass() : 0;
+	if (ma > 0 && mb > 0) return ma * mb / (ma + mb);
+	return Math.max(ma, mb, .001);
+}
+function num$1(v, fallback) {
+	return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function layerGeometry(layer, options) {
+	const id = typeof layer.id === "string" ? ` "${layer.id}"` : "";
+	if (typeof layer.x !== "number" || typeof layer.y !== "number") throw new Error(`Physics: layer${id} needs numeric \`x\` and \`y\` (absolute position) to become a body.`);
+	let width = options.size?.[0] ?? (typeof layer.width === "number" ? layer.width : void 0);
+	let height = options.size?.[1] ?? (typeof layer.height === "number" ? layer.height : void 0);
+	if ((width === void 0 || height === void 0) && layer.kind === "text") {
+		const m = FontManager.measure(String(layer.text ?? ""), {
+			fontFamily: String(layer.fontFamily ?? "Inter"),
+			fontSize: num$1(layer.fontSize, 48),
+			fontWeight: layer.fontWeight,
+			letterSpacing: num$1(layer.letterSpacing, 0),
+			lineHeight: typeof layer.lineHeight === "number" ? layer.lineHeight : void 0
+		});
+		width ??= m.width;
+		height ??= m.height;
+	}
+	if (width === void 0 || height === void 0 || width <= 0 || height <= 0) throw new Error(`Physics: layer${id} needs a numeric \`width\` and \`height\` (or the \`size\` option) to become a body.`);
+	const scale = num$1(layer.scale, 1);
+	return {
+		x: layer.x,
+		y: layer.y,
+		width,
+		height,
+		scale,
+		anchorX: num$1(layer.anchorX, .5),
+		anchorY: num$1(layer.anchorY, .5),
+		rotation: num$1(layer.rotation, 0),
+		shape: scaleShape$1(colliderShape(layer, width, height, options.shape ?? "auto"), scale)
+	};
+}
+function colliderShape(layer, w, h, mode) {
+	const shapeType = layer.kind === "shape" ? String(layer.shapeType ?? "rect") : "rect";
+	const radius = num$1(layer.borderRadius, num$1(layer.cornerRadius, 0));
+	const box = {
+		kind: "box",
+		hx: w / 2,
+		hy: h / 2,
+		radius
+	};
+	if (mode === "box") return box;
+	if (mode === "circle" || mode === "auto" && shapeType === "circle") return {
+		kind: "ball",
+		radius: Math.min(w, h) / 2
+	};
+	if (mode === "auto" && shapeType === "rect") return box;
+	if (mode === "hull" || mode === "auto") {
+		const points = outlinePoints(layer, shapeType, w, h);
+		return points.length >= 6 ? {
+			kind: "hull",
+			points
+		} : box;
+	}
+	return box;
+}
+/** The shape's outline as flat points around the box center, px. */
+function outlinePoints(layer, shapeType, w, h) {
+	const d = shapeType === "path" ? String(layer.d ?? "") : buildShapeSvgPath({
+		shapeType,
+		width: w,
+		height: h,
+		cornerRadius: num$1(layer.cornerRadius, num$1(layer.borderRadius, 0)),
+		polygonSides: layer.polygonSides,
+		starPoints: layer.starPoints,
+		starInnerRadiusRatio: layer.starInnerRadiusRatio,
+		arrowHeadWidth: layer.arrowHeadWidth,
+		arrowHeadLength: layer.arrowHeadLength,
+		arrowShaftWidth: layer.arrowShaftWidth
+	});
+	const out = [];
+	for (const seg of parseSvgPathToSegments(d)) out.push(seg.p0.x - w / 2, seg.p0.y - h / 2, seg.p1.x - w / 2, seg.p1.y - h / 2);
+	return out;
+}
+function scaleShape$1(shape, s) {
+	switch (shape.kind) {
+		case "ball": return {
+			kind: "ball",
+			radius: shape.radius * s
+		};
+		case "box": return {
+			kind: "box",
+			hx: shape.hx * s,
+			hy: shape.hy * s,
+			radius: (shape.radius ?? 0) * s
+		};
+		case "hull": return {
+			kind: "hull",
+			points: shape.points.map((v) => v * s)
+		};
+	}
+}
+/**
+* Layers rotate and scale around their pivot (`anchorX/Y` of the unscaled
+* box); bodies rotate around their center. These convert between the two.
+*/
+function pivotOffset(rotationDeg, f) {
+	const a = rotationDeg * Math.PI / 180;
+	const dx = (.5 - f.anchorX) * f.width * f.scale;
+	const dy = (.5 - f.anchorY) * f.height * f.scale;
+	return [dx * Math.cos(a) - dy * Math.sin(a), dx * Math.sin(a) + dy * Math.cos(a)];
+}
+function layerToCenter(x, y, rotationDeg, f) {
+	const [ox, oy] = pivotOffset(rotationDeg, f);
+	return [x + f.anchorX * f.width + ox, y + f.anchorY * f.height + oy];
+}
+function centerToLayer(cx, cy, rotationDeg, f) {
+	const [ox, oy] = pivotOffset(rotationDeg, f);
+	return [cx - ox - f.anchorX * f.width, cy - oy - f.anchorY * f.height];
+}
+
+//#endregion
+//#region src/physics/world3d.ts
+const DEG = Math.PI / 180;
+/** Quaternion of the renderer's Euler order: R = Rz · Ry · Rx (degrees). */
+function quatFromEuler(rx, ry, rz) {
+	const half = (d) => d * DEG / 2;
+	const qx = [
+		Math.sin(half(rx)),
+		0,
+		0,
+		Math.cos(half(rx))
+	];
+	const qy = [
+		0,
+		Math.sin(half(ry)),
+		0,
+		Math.cos(half(ry))
+	];
+	return quatMul(quatMul([
+		0,
+		0,
+		Math.sin(half(rz)),
+		Math.cos(half(rz))
+	], qy), qx);
+}
+function quatMul(a, b) {
+	const [ax, ay, az, aw] = a;
+	const [bx, by, bz, bw] = b;
+	return [
+		aw * bx + ax * bw + ay * bz - az * by,
+		aw * by - ax * bz + ay * bw + az * bx,
+		aw * bz + ax * by - ay * bx + az * bw,
+		aw * bw - ax * bx - ay * by - az * bz
+	];
+}
+/**
+* Euler angles (degrees, R = Rz · Ry · Rx) for a quaternion, choosing of the
+* two equivalent solutions the one closest to `previous` and unwrapping each
+* angle, so rotations stay continuous frame to frame.
+*/
+function eulerFromQuat(q, previous) {
+	const [x, y, z, w] = q;
+	const r00 = 1 - 2 * (y * y + z * z);
+	const r10 = 2 * (x * y + w * z);
+	const r20 = 2 * (x * z - w * y);
+	const r21 = 2 * (y * z + w * x);
+	const r22 = 1 - 2 * (x * x + y * y);
+	const r01 = 2 * (x * y - w * z);
+	const r11 = 1 - 2 * (x * x + z * z);
+	const sy = Math.max(-1, Math.min(1, -r20));
+	let a;
+	if (Math.abs(sy) > .999999) {
+		const ay = Math.asin(sy);
+		const keepX = previous ? previous[0] * DEG : 0;
+		a = [
+			keepX,
+			ay,
+			Math.atan2(-r01, r11) + (sy > 0 ? keepX : -keepX)
+		];
+	} else a = [
+		Math.atan2(r21, r22),
+		Math.asin(sy),
+		Math.atan2(r10, r00)
+	];
+	const first = [
+		a[0] / DEG,
+		a[1] / DEG,
+		a[2] / DEG
+	];
+	if (!previous) return first;
+	const second = [
+		first[0] + 180,
+		180 - first[1],
+		first[2] + 180
+	];
+	const unwrap = (c) => [
+		unwrapDegrees(previous[0], c[0]),
+		unwrapDegrees(previous[1], c[1]),
+		unwrapDegrees(previous[2], c[2])
+	];
+	const p = unwrap(first);
+	const s = unwrap(second);
+	const dist$1 = (c) => Math.abs(c[0] - previous[0]) + Math.abs(c[1] - previous[1]) + Math.abs(c[2] - previous[2]);
+	return dist$1(p) <= dist$1(s) ? p : s;
+}
+/**
+* A simulated 3D body. Like {@link PhysicsBody2D}, its signals hold one
+* value per composition frame and reading one runs the simulation.
+*/
+var PhysicsBody3D = class {
+	collisions = [];
+	/** @internal */ recording;
+	/** @internal */ sim;
+	/** @internal */
+	constructor(world, sim, type, layer, start, options, recording) {
+		this.world = world;
+		this.type = type;
+		this.layer = layer;
+		this.start = start;
+		this.options = options;
+		this.sim = sim;
+		this.recording = recording;
+	}
+	get startFrame() {
+		return Math.max(0, Math.round(this.options.startFrame ?? 0));
+	}
+	get gravityScale() {
+		return this.options.gravityScale ?? 1;
+	}
+	get output() {
+		return this.options.output;
+	}
+	/** Center, px (what Layer3D's `x` / `y` / `z` mean). */
+	get x() {
+		return this.recording.signal("x");
+	}
+	get y() {
+		return this.recording.signal("y");
+	}
+	get z() {
+		return this.recording.signal("z");
+	}
+	/** Degrees, continuous. */
+	get rotateX() {
+		return this.recording.signal("rotateX");
+	}
+	get rotateY() {
+		return this.recording.signal("rotateY");
+	}
+	get rotateZ() {
+		return this.recording.signal("rotateZ");
+	}
+	/** px/s. */
+	get vx() {
+		return this.recording.signal("vx");
+	}
+	get vy() {
+		return this.recording.signal("vy");
+	}
+	get vz() {
+		return this.recording.signal("vz");
+	}
+	get speed() {
+		return this.recording.signal("speed");
+	}
+	/** Hit envelope, as on 2D bodies. */
+	get impact() {
+		return this.recording.signal("impact");
+	}
+	/** 1 while the body is at rest, else 0. */
+	get sleeping() {
+		return this.recording.signal("sleeping");
+	}
+	/** @internal */
+	kinematicTarget(frame) {
+		const follow = this.options.follow;
+		if (this.type !== "kinematic" || !follow) return void 0;
+		const fps = this.world.fps;
+		const read = (d, fallback) => d === void 0 ? fallback : sampleDriver(d, frame, fps);
+		const p = this.start.position;
+		const r = this.start.rotation;
+		const ppm = this.world.pixelsPerMeter;
+		return {
+			position: [
+				read(follow.x, p[0]) / ppm,
+				read(follow.y, p[1]) / ppm,
+				read(follow.z, p[2]) / ppm
+			],
+			rotation: quatFromEuler(read(follow.rotateX, r[0]), read(follow.rotateY, r[1]), read(follow.rotateZ, r[2]))
+		};
+	}
+	/** @internal */
+	record(index, previous) {
+		const ppm = this.world.pixelsPerMeter;
+		const rec = this.recording;
+		const [x, y, z] = this.sim.position();
+		rec.channel("x")[index] = x * ppm;
+		rec.channel("y")[index] = y * ppm;
+		rec.channel("z")[index] = z * ppm;
+		const rx = rec.channel("rotateX");
+		const ry = rec.channel("rotateY");
+		const rz = rec.channel("rotateZ");
+		const prev = previous < 0 ? this.start.rotation : [
+			rx[previous],
+			ry[previous],
+			rz[previous]
+		];
+		const e = eulerFromQuat(this.sim.rotation(), prev);
+		rx[index] = e[0];
+		ry[index] = e[1];
+		rz[index] = e[2];
+		const [vx, vy, vz] = this.sim.velocity();
+		rec.channel("vx")[index] = vx * ppm;
+		rec.channel("vy")[index] = vy * ppm;
+		rec.channel("vz")[index] = vz * ppm;
+		rec.channel("speed")[index] = Math.hypot(vx, vy, vz) * ppm;
+		rec.channel("sleeping")[index] = this.sim.sleeping() ? 1 : 0;
+	}
+	/** @internal */
+	boundChannels() {
+		const out = [
+			["x", "x"],
+			["y", "y"],
+			["z", "z"]
+		];
+		if (this.options.lockRotation !== true) out.push(["rotateX", "rotateX"], ["rotateY", "rotateY"], ["rotateZ", "rotateZ"]);
+		return out;
+	}
+	/** @internal World point (px) → local frame (meters) at the start pose. */
+	localAnchor(point) {
+		if (!point) return [
+			0,
+			0,
+			0
+		];
+		const ppm = this.world.pixelsPerMeter;
+		const p = this.sim.position();
+		const [qx, qy, qz, qw] = this.sim.rotation();
+		return rotateByQuat([
+			point[0] / ppm - p[0],
+			point[1] / ppm - p[1],
+			point[2] / ppm - p[2]
+		], [
+			-qx,
+			-qy,
+			-qz,
+			qw
+		]);
+	}
+	/** @internal Start-pose center, px. */
+	center() {
+		const ppm = this.world.pixelsPerMeter;
+		const [x, y, z] = this.sim.position();
+		return [
+			x * ppm,
+			y * ppm,
+			z * ppm
+		];
+	}
+};
+function rotateByQuat(v, q) {
+	const r = quatMul(quatMul(q, [
+		v[0],
+		v[1],
+		v[2],
+		0
+	]), [
+		-q[0],
+		-q[1],
+		-q[2],
+		q[3]
+	]);
+	return [
+		r[0],
+		r[1],
+		r[2]
+	];
+}
+/**
+* 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.
+*/
+var PhysicsWorld3D = class extends WorldCore {
+	/** @internal */
+	constructor(backend, options) {
+		const ppm = options.pixelsPerMeter ?? 100;
+		const g = options.gravity ?? 2400;
+		const gravity = typeof g === "number" ? [
+			0,
+			g / ppm,
+			0
+		] : [
+			g[0] / ppm,
+			g[1] / ppm,
+			g[2] / ppm
+		];
+		super(backend.createWorld3D(gravity), gravity, options);
+	}
+	/** Adds a body for a Layer3D primitive or model (centered on its `x/y/z`), or a plain box. */
+	body(target, options = {}) {
+		this.assertOpen();
+		const layer = typeof target.kind === "string" ? target : void 0;
+		const t = target;
+		const position = [
+			num(t.x, 0),
+			num(t.y, 0),
+			num(t.z, 0)
+		];
+		const rotation = [
+			num(t.rotateX, 0),
+			num(t.rotateY, 0),
+			num(t.rotateZ, 0)
+		];
+		const ppm = this.pixelsPerMeter;
+		const type = options.type ?? "dynamic";
+		const v = options.velocity ?? [
+			0,
+			0,
+			0
+		];
+		const w = options.angularVelocity ?? [
+			0,
+			0,
+			0
+		];
+		const spec$1 = {
+			type,
+			position: [
+				position[0] / ppm,
+				position[1] / ppm,
+				position[2] / ppm
+			],
+			rotation: quatFromEuler(rotation[0], rotation[1], rotation[2]),
+			velocity: [
+				v[0] / ppm,
+				v[1] / ppm,
+				v[2] / ppm
+			],
+			angularVelocity: [
+				w[0] * DEG,
+				w[1] * DEG,
+				w[2] * DEG
+			],
+			linearDamping: options.linearDamping ?? 0,
+			angularDamping: options.angularDamping ?? 0,
+			gravityScale: options.gravityScale ?? 1,
+			lockRotation: options.lockRotation === true,
+			...typeof options.lockRotation === "object" && { enabledRotations: [
+				!options.lockRotation.x,
+				!options.lockRotation.y,
+				!options.lockRotation.z
+			] },
+			ccd: options.ccd ?? false,
+			enabled: true,
+			sensor: options.sensor ?? false,
+			density: options.density ?? 1,
+			friction: options.friction ?? .6,
+			restitution: options.restitution ?? .3,
+			shape: scaleShape(colliderShape3D(t, options), 1 / ppm)
+		};
+		const simBody = this.sim.addBody(spec$1);
+		const body = new PhysicsBody3D(this, simBody, type, layer, {
+			position,
+			rotation
+		}, options, this.newRecording());
+		return this.addBody(body);
+	}
+	/** A fixed, very large floor whose top face sits at `y`. */
+	ground(options) {
+		const t = 2e3;
+		return this.body({
+			x: 0,
+			y: options.y + t / 2,
+			z: 0,
+			width: 1e6,
+			height: t,
+			depth: 1e6
+		}, {
+			type: "fixed",
+			friction: options.friction,
+			restitution: options.restitution ?? .2
+		});
+	}
+	/** Fixed floor and four walls around a box centered on `x`/`z`, floor at `y + height/2`. */
+	walls(options) {
+		const { width: W, height: H, depth: D } = options;
+		const [x, y, z] = [
+			options.x ?? 0,
+			options.y ?? 0,
+			options.z ?? 0
+		];
+		const t = options.thickness ?? 400;
+		const mat = {
+			type: "fixed",
+			friction: options.friction,
+			restitution: options.restitution ?? .2
+		};
+		const tall = H * 4;
+		const wy = y + H / 2 - tall / 2;
+		return [
+			this.body({
+				x,
+				y: y + H / 2 + t / 2,
+				z,
+				width: W + 2 * t,
+				height: t,
+				depth: D + 2 * t
+			}, mat),
+			this.body({
+				x: x - W / 2 - t / 2,
+				y: wy,
+				z,
+				width: t,
+				height: tall,
+				depth: D + 2 * t
+			}, mat),
+			this.body({
+				x: x + W / 2 + t / 2,
+				y: wy,
+				z,
+				width: t,
+				height: tall,
+				depth: D + 2 * t
+			}, mat),
+			this.body({
+				x,
+				y: wy,
+				z: z - D / 2 - t / 2,
+				width: W,
+				height: tall,
+				depth: t
+			}, mat),
+			this.body({
+				x,
+				y: wy,
+				z: z + D / 2 + t / 2,
+				width: W,
+				height: tall,
+				depth: t
+			}, mat)
+		];
+	}
+	/** Pins a body to the world at a point (default its center); it can still turn around it. */
+	pin(body, at) {
+		const point = at ?? body.center();
+		const anchor = this.anchorBody(point);
+		this.joint(body, anchor, {
+			type: "spherical",
+			anchorA: body.localAnchor(point),
+			anchorB: [
+				0,
+				0,
+				0
+			]
+		});
+		return this;
+	}
+	/** Joins two bodies at a world point, turning only around `axis` (default z, facing the camera). */
+	hinge(a, b, at, axis = [
+		0,
+		0,
+		1
+	]) {
+		this.joint(a, b, {
+			type: "revolute",
+			anchorA: a.localAnchor(at),
+			anchorB: b.localAnchor(at),
+			axis
+		});
+		return this;
+	}
+	/** Glues two bodies together rigidly. */
+	weld(a, b) {
+		this.joint(a, b, {
+			type: "fixed",
+			anchorA: [
+				0,
+				0,
+				0
+			],
+			anchorB: b.localAnchor(a.center())
+		});
+		return this;
+	}
+	spring(a, b, options = {}) {
+		const { other, pa, pb } = this.endpoints(a, b, options.anchorA, options.anchorB);
+		const ppm = this.pixelsPerMeter;
+		const length = (options.length ?? dist(pa, pb)) / ppm;
+		const ma = a.type === "dynamic" ? a.sim.mass() : 0;
+		const mb = other.type === "dynamic" ? other.sim.mass() : 0;
+		const mass = ma > 0 && mb > 0 ? ma * mb / (ma + mb) : Math.max(ma, mb, .001);
+		const w = 2 * Math.PI * (options.frequency ?? 2);
+		this.joint(a, other, {
+			type: "spring",
+			anchorA: a.localAnchor(pa),
+			anchorB: other.localAnchor(pb),
+			restLength: length,
+			stiffness: mass * w * w,
+			damping: 2 * (options.dampingRatio ?? .2) * mass * w
+		});
+		return this;
+	}
+	rope(a, b, options = {}) {
+		const { other, pa, pb } = this.endpoints(a, b, options.anchorA, options.anchorB);
+		this.joint(a, other, {
+			type: "rope",
+			anchorA: a.localAnchor(pa),
+			anchorB: other.localAnchor(pb),
+			length: (options.length ?? dist(pa, pb)) / this.pixelsPerMeter
+		});
+		return this;
+	}
+	/** A steady push, px/s² (mass-independent). Drivers are read every frame. */
+	force(body, accel) {
+		const ppm = this.pixelsPerMeter;
+		const read = (d, frame) => d === void 0 ? 0 : sampleDriver(d, frame, this.fps) / ppm;
+		this.addForce(body, (frame) => [
+			read(accel.x, frame),
+			read(accel.y, frame),
+			read(accel.z, frame)
+		]);
+		return this;
+	}
+	/** A force field, as in 2D: returns `[ax, ay, az]` px/s² for a body at `x/y/z` px. */
+	field(accel, options = {}) {
+		const ppm = this.pixelsPerMeter;
+		this.addField((body, frame) => {
+			const [x, y, z] = body.sim.position();
+			const [vx, vy, vz] = body.sim.velocity();
+			const a = accel({
+				x: x * ppm,
+				y: y * ppm,
+				z: z * ppm,
+				vx: vx * ppm,
+				vy: vy * ppm,
+				vz: vz * ppm,
+				frame,
+				body
+			});
+			return a ? [
+				a[0] / ppm,
+				a[1] / ppm,
+				a[2] / ppm
+			] : null;
+		}, options.bodies);
+		return this;
+	}
+	/** An instant kick at a simulation frame: adds `[vx, vy, vz]` px/s. */
+	impulse(body, frame, velocity) {
+		const ppm = this.pixelsPerMeter;
+		this.addImpulse(body, frame, [
+			velocity[0] / ppm,
+			velocity[1] / ppm,
+			velocity[2] / ppm
+		]);
+		return this;
+	}
+	lerpRotation(a, b, t) {
+		const sign = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3] < 0 ? -1 : 1;
+		const q = a.map((v, i) => v + (b[i] * sign - v) * t);
+		const len = Math.hypot(...q) || 1;
+		return q.map((v) => v / len);
+	}
+	joint(a, b, spec$1) {
+		this.assertOpen();
+		this.sim.addJoint(a.sim, b.sim, spec$1);
+	}
+	anchorBody(point) {
+		return this.body({
+			x: point[0],
+			y: point[1],
+			z: point[2],
+			width: 1,
+			height: 1,
+			depth: 1
+		}, {
+			type: "fixed",
+			output: "none",
+			sensor: true
+		});
+	}
+	endpoints(a, b, anchorA, anchorB) {
+		const pa = anchorA ?? a.center();
+		if (Array.isArray(b)) {
+			const pb = anchorB ?? b;
+			return {
+				other: this.anchorBody(pb),
+				pa,
+				pb
+			};
+		}
+		return {
+			other: b,
+			pa,
+			pb: anchorB ?? b.center()
+		};
+	}
+};
+function dist(a, b) {
+	return Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+}
+function num(v, fallback) {
+	return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+/** Collider in px around the layer's center, with the layer's scale applied. */
+function colliderShape3D(t, options) {
+	const id = typeof t.id === "string" ? ` "${t.id}"` : "";
+	const s = num(t.scale, 1);
+	const scale = [
+		s * num(t.scaleX, 1),
+		s * num(t.scaleY, 1),
+		s * num(t.scaleZ, 1)
+	];
+	const uniform = scale[0] === scale[1] && scale[1] === scale[2];
+	const prim = t.primitive3d ?? {};
+	const mode = options.shape ?? "auto";
+	const hull = () => {
+		const pts = meshPoints(t.modelData);
+		if (!pts) return void 0;
+		return {
+			kind: "hull",
+			points: pts.map((v, i) => v * scale[i % 3])
+		};
+	};
+	if (options.size || mode === "box") {
+		const [w, h$1, d] = options.size ?? boxSize(t, prim) ?? [
+			0,
+			0,
+			0
+		];
+		if (w > 0 && h$1 > 0 && d > 0) return {
+			kind: "box",
+			hx: w * scale[0] / 2,
+			hy: h$1 * scale[1] / 2,
+			hz: d * scale[2] / 2,
+			radius: prim.type === "roundedBox" ? num(prim.radius, 0) * Math.min(...scale) : 0
+		};
+	}
+	if (mode === "hull") {
+		const h$1 = hull();
+		if (h$1) return h$1;
+	}
+	if ((mode === "sphere" || mode === "auto" && prim.type === "sphere") && (uniform || mode === "sphere")) {
+		const r = num(prim.radius, 0) || Math.max(...boxSize(t, prim) ?? [0]) / 2;
+		if (r > 0) return {
+			kind: "ball",
+			radius: r * Math.max(...scale)
+		};
+	}
+	const rTop = num(prim.radiusTop, num(prim.radius, 0));
+	const rBottom = num(prim.radiusBottom, num(prim.radius, 0));
+	if ((mode === "cylinder" || mode === "auto" && prim.type === "cylinder") && rTop === rBottom && rTop > 0 && scale[0] === scale[2]) return {
+		kind: "cylinder",
+		halfHeight: num(prim.height, 0) * scale[1] / 2,
+		radius: rTop * scale[0]
+	};
+	if (mode === "auto" && prim.type === "roundedBox" && (prim.taper ?? 1) === 1) {
+		const [w, h$1, d] = [
+			num(prim.width, 0),
+			num(prim.height, 0),
+			num(prim.depth, 0)
+		];
+		return {
+			kind: "box",
+			hx: w * scale[0] / 2,
+			hy: h$1 * scale[1] / 2,
+			hz: d * scale[2] / 2,
+			radius: num(prim.radius, 0) * Math.min(...scale)
+		};
+	}
+	const h = hull();
+	if (h) return h;
+	const size$1 = boxSize(t, prim);
+	if (size$1) return {
+		kind: "box",
+		hx: size$1[0] * scale[0] / 2,
+		hy: size$1[1] * scale[1] / 2,
+		hz: size$1[2] * scale[2] / 2
+	};
+	throw new Error(`Physics: layer${id} has no mesh or size to build a 3D collider from; pass \`size: [w, h, d]\`.`);
+}
+function boxSize(t, prim) {
+	if (prim.type === "roundedBox") return [
+		num(prim.width, 0),
+		num(prim.height, 0),
+		num(prim.depth, 0)
+	];
+	if (prim.type === "sphere") {
+		const d = num(prim.radius, 0) * 2;
+		return [
+			d,
+			d,
+			d
+		];
+	}
+	if (prim.type === "cylinder") {
+		const d = Math.max(num(prim.radiusTop, num(prim.radius, 0)), num(prim.radiusBottom, num(prim.radius, 0))) * 2;
+		return [
+			d,
+			num(prim.height, 0),
+			d
+		];
+	}
+	if (typeof t.width === "number" && typeof t.height === "number" && typeof t.depth === "number") return [
+		t.width,
+		t.height,
+		t.depth
+	];
+}
+/** Every vertex of a model, flat xyz, at most ~4k points (the hull needs no more). */
+function meshPoints(modelData) {
+	const meshes = modelData?.meshes;
+	if (!meshes?.length) return void 0;
+	let total = 0;
+	for (const m of meshes) total += (m.positions?.length ?? 0) / 3;
+	if (total < 4) return void 0;
+	const stride = Math.max(1, Math.floor(total / 4096));
+	const out = [];
+	let i = 0;
+	for (const m of meshes) {
+		const p = m.positions;
+		if (!p) continue;
+		for (let v = 0; v < p.length; v += 3, i++) if (i % stride === 0) out.push(p[v], p[v + 1], p[v + 2]);
+	}
+	return out;
+}
+function scaleShape(shape, s) {
+	switch (shape.kind) {
+		case "ball": return {
+			kind: "ball",
+			radius: shape.radius * s
+		};
+		case "box": return {
+			kind: "box",
+			hx: shape.hx * s,
+			hy: shape.hy * s,
+			hz: shape.hz * s,
+			radius: (shape.radius ?? 0) * s
+		};
+		case "cylinder": return {
+			kind: "cylinder",
+			halfHeight: shape.halfHeight * s,
+			radius: shape.radius * s
+		};
+		case "hull": return {
+			kind: "hull",
+			points: shape.points.map((v) => v * s)
+		};
+	}
+}
+
+//#endregion
+//#region src/physics/index.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));
+* ```
+*/
+const Physics = {
+	async world2d(options) {
+		return new PhysicsWorld2D(await rapierBackend(2), options);
+	},
+	async world3d(options) {
+		return new PhysicsWorld3D(await rapierBackend(3), options);
+	}
+};
+
+//#endregion
+//#region src/styles.ts
+const look = (...effects) => effects;
+const Styles = {
+	pixelArt: (o = {}) => look(new Posterize({
+		palette: o.palette ?? "pico8",
+		pixelSize: o.pixelSize ?? 6,
+		dither: .4
+	})),
+	gameBoy: (o = {}) => look(new Posterize({
+		palette: "gameboy",
+		pixelSize: o.pixelSize ?? 4,
+		dither: .6
+	})),
+	teletext: (o = {}) => look(new Posterize({
+		palette: "teletext",
+		pixelSize: o.pixelSize ?? 10
+	})),
+	ledWall: (o = {}) => look(new Pixelate({
+		size: o.size ?? 14,
+		shape: "circle",
+		gap: .18
+	})),
+	ascii: (o = {}) => look(new Ascii({
+		cellSize: o.cellSize ?? 10,
+		colorMode: o.matrix ? "green" : "source",
+		bg: o.matrix ? "#020a04" : "#0b0b0b"
+	})),
+	oneBit: (o = {}) => look(new Dither({
+		mode: "bayer",
+		scale: o.scale ?? 2,
+		dark: o.dark ?? "#111111",
+		light: o.light ?? "#f2efe6"
+	})),
+	risograph: (o = {}) => {
+		const a = o.inkA ?? "#1d3fbb";
+		const b = o.inkB ?? "#ff5fa2";
+		const paper = o.paper ?? "#f4efe4";
+		return look(new GradientMap({ stops: [
+			{
+				position: 0,
+				color: a
+			},
+			{
+				position: .55,
+				color: b
+			},
+			{
+				position: 1,
+				color: paper
+			}
+		] }), new Posterize({
+			palette: "custom",
+			colors: [
+				a,
+				b,
+				paper
+			],
+			dither: .8,
+			pixelSize: 2
+		}), new FilmGrain({ strength: .2 }));
+	},
+	cartoon: (o = {}) => look(new Toon({
+		levels: o.levels ?? 4,
+		edgeColor: o.ink ?? "#111111",
+		saturation: 1.3
+	})),
+	comic: (o = {}) => look(new Toon({
+		levels: 4,
+		edgeWidth: 1.5,
+		saturation: 1.4
+	}), new HalftoneScreen({
+		frequency: o.dotFrequency ?? 70,
+		opacity: .35
+	})),
+	thermal: () => look(new GradientMap({ stops: [
+		{
+			position: 0,
+			color: "#000010"
+		},
+		{
+			position: .25,
+			color: "#3b0a7a"
+		},
+		{
+			position: .5,
+			color: "#c4205f"
+		},
+		{
+			position: .75,
+			color: "#ff9a1f"
+		},
+		{
+			position: 1,
+			color: "#fffbe0"
+		}
+	] })),
+	vhs: (o = {}) => look(new CRT({
+		tracking: o.tracking ?? .5,
+		chroma: 4,
+		curvature: .04,
+		scanlines: .25,
+		mask: .05,
+		noise: .15
+	}), new RGBSplit({ amount: 3 })),
+	crt: (o = {}) => look(new CRT({
+		curvature: o.curvature ?? .15,
+		scanlines: .5,
+		mask: .35
+	})),
+	glitch: (o = {}) => look(new RGBSplit({ amount: o.amount ?? 18 }), new CRT({
+		tracking: 1,
+		chroma: 6,
+		curvature: 0,
+		scanlines: .1,
+		mask: 0,
+		vignette: 0
+	})),
+	oilPainting: (o = {}) => look(new Painterly({
+		style: "oil",
+		radius: o.brush ?? 5
+	})),
+	watercolor: (o = {}) => look(new Painterly({
+		style: "watercolor",
+		radius: o.brush ?? 6,
+		paper: .5
+	})),
+	topographic: (o = {}) => look(new Contour({
+		levels: o.levels ?? 16,
+		fill: "flat",
+		lineColor: o.ink ?? "#5a3a1a",
+		fillColor: o.paper ?? "#f3ead8"
+	})),
+	kaleidoscope: (o = {}) => look(new Kaleidoscope({
+		segments: o.segments ?? 8,
+		rotation: o.rotation ?? 0
+	})),
+	opArt: (o = {}) => look(new OpArt({
+		pattern: o.pattern ?? "stripes",
+		frequency: o.frequency ?? 60
+	})),
+	holographic: (o = {}) => look(new Iridescence({
+		strength: o.strength ?? .7,
+		shift: o.shift ?? 0
+	})),
+	noir: () => look(new GradientMap({ stops: [
+		{
+			position: 0,
+			color: "#000000"
+		},
+		{
+			position: .55,
+			color: "#8a8a8a"
+		},
+		{
+			position: 1,
+			color: "#ffffff"
+		}
+	] }), new FilmGrain({ strength: .35 }), new Vignette({ strength: .6 })),
+	film: () => look(new FilmGrain({ strength: .25 }), new Vignette({ strength: .35 }))
+};
+
+//#endregion
+//#region src/index.ts
+function decorateTrackSignals(track, source) {
+	if (!track) return track;
+	if (source && !track.source) Object.defineProperty(track, "source", {
+		value: source,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	if (typeof track.section !== "function") Object.defineProperty(track, "section", {
+		value: (sourceOrOptions, options) => {
+			if (typeof sourceOrOptions === "object" && sourceOrOptions !== null && !("kind" in sourceOrOptions) && !("inputHandleId" in sourceOrOptions) && !("src" in sourceOrOptions)) {
+				const resolvedSource$1 = sourceOrOptions.source ?? track.source ?? source;
+				return Layer.section(resolvedSource$1, track, sourceOrOptions);
+			}
+			const resolvedSource = sourceOrOptions ?? track.source ?? source;
+			return Layer.section(resolvedSource, track, options);
+		},
+		enumerable: false,
 		writable: true,
 		configurable: true
 	});
@@ -2120,6 +5012,8 @@ var Composition = class Composition {
 	audioTracks = [];
 	signals = {};
 	_frameHooks = [];
+	_prepareHooks = [];
+	_clipVision = /* @__PURE__ */ new Map();
 	_visionConfig;
 	_visionBundle;
 	_effects = [];
@@ -2153,6 +5047,66 @@ var Composition = class Composition {
 		return this._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, options = {}) {
+		const key = `${source}\u0000${JSON.stringify(options)}`;
+		let clip = this._clipVision.get(key);
+		if (!clip) {
+			clip = new ClipVision(source, this.fps, options);
+			this._clipVision.set(key, clip);
+		}
+		return clip;
+	}
+	/**
+	* @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.
+	*/
+	async prepareVision(frame) {
+		this.linkClipMattes();
+		await Promise.all([...this._clipVision.values()].map((clip) => clip.ready(0, frame)));
+	}
+	/**
+	* 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.
+	*/
+	linkClipMattes() {
+		if (this._clipVision.size === 0) return;
+		const walk = (node) => {
+			if (!node || typeof node !== "object") return;
+			const n = node;
+			if (n.kind === "media" && n.dataType === "Video" && typeof n.inputHandleId === "string" && n.vision instanceof Vision && !(CLIP_SUBJECT in n.vision)) {
+				const clip = this.clipForMatte(n.inputHandleId, n.vision);
+				if (clip) {
+					clip.keepSubjects();
+					Object.defineProperty(n.vision, CLIP_SUBJECT, {
+						value: clip,
+						enumerable: false,
+						configurable: true
+					});
+				}
+			}
+			if (Array.isArray(n.children)) for (const c of n.children) walk(c);
+		};
+		for (const child of this.children) walk(child);
+	}
+	clipForMatte(source, v) {
+		const mode = v.mode ?? "passthrough";
+		if (mode !== "matte" && mode !== "mask" && mode !== "crop") return;
+		if (v.matteSource === "selfie" || v.keyBackground === true || v.classes !== void 0 || v.enablePose === true || v.enableMatte === true || v.visionBundle !== void 0 || (v.maskThreshold ?? .5) !== .5 || v.featherRadius !== void 0) return;
+		for (const clip of this._clipVision.values()) {
+			const o = clip.options;
+			if (clip.source === source && (o.variant ?? "s") === (v.variant ?? "s") && (o.confidence ?? .3) === (v.confidence ?? .3)) return clip;
+		}
+	}
+	/**
 	* One-shot, ffmpeg-free vision analysis of a media source.
 	*
 	* Decodes frames through the same mediabunny pipeline the renderer uses, runs the requested
@@ -2204,8 +5158,25 @@ var Composition = class Composition {
 		this._frameHooks.push(callback);
 		return this;
 	}
+	/**
+	* 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) {
+		this._prepareHooks.push(callback);
+		return this;
+	}
 	notifyFrame(ctx) {
 		for (const hook of this._frameHooks) hook(ctx);
+		if (this._clipVision.size === 0 && this._prepareHooks.length === 0) return;
+		return (async () => {
+			await this.prepareVision(ctx.frame);
+			for (const hook of this._prepareHooks) await hook(ctx);
+		})();
+	}
+	hasFrameHooks() {
+		return this._frameHooks.length > 0 || this._prepareHooks.length > 0 || this._clipVision.size > 0;
 	}
 	constructor(options) {
 		this.width = options.width;
@@ -2538,7 +5509,7 @@ var Composition = class Composition {
 			signals: this.signals,
 			...this._effects.length > 0 && { effects: this._effects },
 			...this._visionConfig && { vision: this._visionConfig },
-			...this._frameHooks.length > 0 && { onRequestFrame: (ctx) => this.notifyFrame(ctx) }
+			...this.hasFrameHooks() && { onRequestFrame: (ctx) => this.notifyFrame(ctx) }
 		};
 	}
 	/**
@@ -2576,9 +5547,9 @@ var Composition = class Composition {
 	* Can render either by timestamp in milliseconds (`atMs`) or by frame index (`frame`).
 	*/
 	async renderFrame(options = {}) {
-		if (this._frameHooks.length > 0) {
+		if (this.hasFrameHooks()) {
 			const targetFrame = options.frame ?? (options.atMs !== void 0 ? Math.round(options.atMs / 1e3 * this.fps) : 0);
-			this.notifyFrame({
+			await this.notifyFrame({
 				frame: targetFrame,
 				fps: this.fps,
 				time: this.fps > 0 ? targetFrame / this.fps : 0,
@@ -2641,7 +5612,13 @@ function withAnimation(node) {
 	Object.defineProperty(target, "animate", {
 		value: (...anims) => {
 			const incoming = anims.flat().flatMap((a) => a instanceof LayerAnimation ? a.tracks : a.tracks ?? []);
-			target.animation = { tracks: mergeAnimationTracks([...target.animation?.tracks ?? [], ...incoming]) };
+			const current = target.animation;
+			const existing = current?.tracks ?? [];
+			const frameStep = anims.flat().map((a) => a.frameStep).filter((n) => n !== void 0).at(-1) ?? current?.frameStep;
+			target.animation = {
+				tracks: mergeAnimationTracks([...existing, ...incoming]),
+				...frameStep !== void 0 && frameStep > 1 && { frameStep }
+			};
 			return target;
 		},
 		enumerable: false,
@@ -2910,6 +5887,68 @@ const Layer = {
 		children: options.children ?? [],
 		...options
 	}),
+	particles: (options) => {
+		const system = new Particles(options);
+		const source = {
+			metadata: {
+				width: options.width,
+				height: options.height
+			},
+			operation: {
+				...system.toOperation(),
+				effect: system,
+				dataType: "Video"
+			},
+			children: []
+		};
+		return withAnimation({
+			id: options.id ?? autoId("particles"),
+			kind: "media",
+			dataType: "Video",
+			src: source,
+			position: "absolute",
+			x: options.x ?? 0,
+			y: options.y ?? 0,
+			width: options.width,
+			height: options.height,
+			...options.startFrame !== void 0 && { startFrame: options.startFrame },
+			...options.durationFrames !== void 0 && { durationFrames: options.durationFrames },
+			...options.zIndex !== void 0 && { zIndex: options.zIndex }
+		});
+	},
+	vfx: (options) => {
+		const { x, y, id, startFrame, durationFrames, zIndex, ...props } = options;
+		const vfx = new ProceduralVFX({
+			outputType: "Video",
+			...props
+		});
+		const source = {
+			metadata: {
+				width: options.width,
+				height: options.height
+			},
+			operation: {
+				...vfx.toOperation(),
+				effect: vfx,
+				dataType: "Video"
+			},
+			children: []
+		};
+		return withAnimation({
+			id: id ?? autoId("vfx"),
+			kind: "media",
+			dataType: "Video",
+			src: source,
+			position: "absolute",
+			x: x ?? 0,
+			y: y ?? 0,
+			width: options.width,
+			height: options.height,
+			...startFrame !== void 0 && { startFrame },
+			...durationFrames !== void 0 && { durationFrames },
+			...zIndex !== void 0 && { zIndex }
+		});
+	},
 	section: (source, targetOrOptions = {}, options = {}) => {
 		let realSource = source;
 		if (source && typeof source === "object" && "toSpec" in source && "children" in source) {
@@ -3216,5 +6255,5 @@ const Effect = Object.assign(Effect$1, effectFactories, {
 });
 
 //#endregion
-export { AETextAnimatorSchema, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, AnchorGroupingSchema, AnchorPresetSchema, AnimatableGlyphPropsSchema, AnimationTypeSchema, AnyOutputUnionSchema, ApplyLUT, AudioCompressor, AudioDelay, AudioExtractorSignalDataSchema, AudioFade, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, AudioNoiseGate, AudioParametricEq, AudioReverb, AudioSignal, AudioSignalExtractor, AudioSpectrumTypographySchema, BaseMediaOperationPropsSchema, BaseVideoLayerPropsSchema, BloomConfigSchema, Blur, BoxNodeSchema, CAPTION_LAYER_DEFAULTS, COCO17_BONES, COCO17_KEYPOINTS, COCO17_KEYPOINT_NAMES, COCO_CLASSES, COMPOSITE_OPERATIONS, COMPOSITOR_DEFAULTS, Camera3D, CameraAnimation, CameraNodeSchema, CameraParallax3D, CannyComputePipeline, CarrierHandoffConfigSchema, ChannelMerger, ChannelSplitter, ChromaticGlitchConfigSchema, Color, ColorBalance, ColorKey, ColorStopSchema, Composition, CompositorProgramSchema, ConfigHandleSchema, ConfigSchemaRegistry, ControlNetMultiplexer, CornerPin, Crop, CubicBezierSegmentSchema, Curves, CustomEffect, DATA_TYPE_EXTENSIONS, DEFAULT_CHART_COLORS, DEFAULT_DURATION_MS, DEFAULT_FPS, DEFAULT_MEDIA_DIMENSION, DataType, DataTypeVal, DataTypes, DepthNormalsComputePipeline, DepthOfField, DisplacementMap, DynamicStrokePropertiesSchema, ENVIRONMENT_PRESETS, Easing, Effect, EffectPipeline, EnhancedTextNodeSchema, EnvironmentFogSchema, EnvironmentPresetSchema, ExportResultSchema, ExpressionSelectorSchema, ExtendedGlyphPropertiesSchema, ExtendedLayerSchema, ExtractLUT, FileAssetSchema, FileDataSchema, FilmGrain, FlexNodeSchema, Flip, FontManager, GeneratorSignalDataSchema, GlassPipeline, GlobalCompositeOperation, GlyphAnchorGroupingSchema, GlyphAnchorPointSchema, Gradient, GradientMap, HalftoneScreen, HandleTypeVal, HeadlessMediaRenderer, HeadlessWebGPURenderer, HighPass, JsonValueSchema, KenBurns, KineticMarqueeConfigSchema, LIGHT_UNIFORM_SIZE_BYTES, Layer, Layer3D, LayerAnimation, LayerStyle, LayoutNodeSchema, Levels, Light, Light3D, LightNodeSchema, LightTypeSchema, Lighting, LineSpacingDynamicsSchema, Liquify, LongShadowConfigSchema, MAX_GRADIENT_STOPS, MAX_LIGHTS, MIME_TYPES, MaskMath, MaterialTypeSchema, Matrix4Math, MatteModeSchema, Media, MediaMetadataSchema, MediaNodeSchema, MediaOperationSchema, MediaSourceSchema, MeshWarp, Model3DNodeSchema, ModerationError, ModerationUnrefundableError, Modulate, MotionBlur, MotionBlurPipeline, MultiOutputGenericSchema, NodeMetadataSchema, NodeResultSchema, NodeVisualConfigSchema, NoiseGenerator, OpticalFlowComputePipeline, OutputItemSchema, PBRGlass, Paint, ParticleDissolveConfigSchema, PatchHeal, Path3D, PoseSkeletonRenderer, ProceduralVFX, ProgrammaticSignal, RefineEdge, RefractionCaustics3D, Relight3D, Renderer2D, Renderer3D, ResizerScaler, Rotate, SSAO, SSAOPipeline, Scene, SceneDefinitionSchema, SceneTransitionTypeSchema, SegmentationTexturePool, SelectiveColor, SelectorBasedOnSchema, SelectorModeSchema, SelectorShapeSchema, SelectorUnitsSchema, Sequence, ShadowPipeline, ShadowsHighlights, ShapeNodeSchema, Signal, SignalChannelMetaSchema, SignalDataSchema, SignalGateDataSchema, SignalMathDataSchema, SignalStatsSchema, SingleOutputGenericSchema, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SourceOperationSchema, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, SpringPhysicsSchema, StereoPanning, TEXT_LAYER_DEFAULTS, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, TensorPipeline, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, TextCursorConfigSchema, TextCursorStyleSchema, TextNodeSchema, TextOperationSchema, TextPathBuilder, TextPathOptionsSchema, TextPathSourceSchema, TextRangeSelectorSchema, TextScrambleConfigSchema, TextSelectorSchema, TextSignalSelectorSchema, TextSpanMarkSchema, TextSpanSchema, TextWigglySelectorSchema, TileOffset, TimelineSegmentSchema, TimelineTransformSchema, ToneMappingSchema, Transition, TransitionSchema, TransitionTypeSchema, TypewriterAnimatorSchema, TypingCadenceSchema, UnsharpMask, VariableFontAxesSchema, Vec2Schema, Vector3Math, VideoAnimationSchema, VideoLayerTypeSchema, VideoSpatialPropsSchema, VideoStylePropsSchema, VideoTextPropsSchema, VideoTimingPropsSchema, Vignette, VirtualMediaDataSchema, Vision, VisionBundle, VisionNode, VisionRunner, VolumetricFormationConfigSchema, VolumetricFormationModeSchema, 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 { AETextAnimatorSchema, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, AnchorGroupingSchema, AnchorPresetSchema, AnimatableGlyphPropsSchema, AnimationTypeSchema, AnyOutputUnionSchema, ApplyLUT, Ascii, AudioCompressor, AudioDelay, AudioExtractorSignalDataSchema, AudioFade, AudioLatentEngine, AudioLatentTrackCache, AudioMeshDeformPipeline, AudioNoiseGate, AudioParametricEq, AudioReverb, AudioSignal, AudioSignalExtractor, AudioSpectrumTypographySchema, BaseMediaOperationPropsSchema, BaseVideoLayerPropsSchema, BloomConfigSchema, Blur, BoxNodeSchema, CAPTION_LAYER_DEFAULTS, COCO17_BONES, COCO17_KEYPOINTS, COCO17_KEYPOINT_NAMES, COCO_CLASSES, COMPOSITE_OPERATIONS, COMPOSITOR_DEFAULTS, CRT, Camera3D, CameraAnimation, CameraNodeSchema, CameraParallax3D, CannyComputePipeline, CarrierHandoffConfigSchema, ChannelMerger, ChannelSplitter, ChromaticGlitchConfigSchema, ClipVision, Color, ColorBalance, ColorKey, ColorStopSchema, Composition, CompositorProgramSchema, ConfigHandleSchema, ConfigSchemaRegistry, Contour, ControlNetMultiplexer, CornerPin, Crop, CubicBezierSegmentSchema, Curves, CustomEffect, DATA_TYPE_EXTENSIONS, DEFAULT_CHART_COLORS, DEFAULT_DURATION_MS, DEFAULT_FPS, DEFAULT_MEDIA_DIMENSION, DataType, DataTypeVal, DataTypes, Datamosh, DepthNormalsComputePipeline, DepthOfField, DisplacementMap, Dither, DynamicStrokePropertiesSchema, ENVIRONMENT_PRESETS, Easing, Effect, EffectPipeline, EnhancedTextNodeSchema, EnvironmentFogSchema, EnvironmentPresetSchema, ExportResultSchema, ExpressionSelectorSchema, ExtendedGlyphPropertiesSchema, ExtendedLayerSchema, ExtractLUT, FileAssetSchema, FileDataSchema, FilmGrain, FlexNodeSchema, Flip, FontManager, GeneratorSignalDataSchema, GlassPipeline, GlobalCompositeOperation, GlyphAnchorGroupingSchema, GlyphAnchorPointSchema, Gooey, Gradient, GradientMap, HalftoneScreen, HandleTypeVal, HeadlessMediaRenderer, HeadlessWebGPURenderer, HighPass, Iridescence, JsonValueSchema, Kaleidoscope, KenBurns, KineticMarqueeConfigSchema, LIGHT_UNIFORM_SIZE_BYTES, Layer, Layer3D, LayerAnimation, LayerStyle, LayoutNodeSchema, Levels, Light, Light3D, LightNodeSchema, LightTypeSchema, Lighting, LineSpacingDynamicsSchema, Liquify, LongShadowConfigSchema, MAX_GRADIENT_STOPS, MAX_LIGHTS, MIME_TYPES, MaskMath, MaterialTypeSchema, Matrix4Math, MatteModeSchema, Media, MediaMetadataSchema, MediaNodeSchema, MediaOperationSchema, MediaSourceSchema, MeshWarp, Model3DNodeSchema, ModerationError, ModerationUnrefundableError, Modulate, MotionBlur, MotionBlurPipeline, MultiOutputGenericSchema, NodeMetadataSchema, NodeResultSchema, NodeVisualConfigSchema, NoiseGenerator, OpArt, OpticalFlowComputePipeline, OutputItemSchema, PBRGlass, Paint, Painterly, ParticleDissolveConfigSchema, Particles, PatchHeal, Path3D, PersonTrack, Physics, PhysicsBody2D, PhysicsBody3D, PhysicsWorld2D, PhysicsWorld3D, Pixelate, PoseSkeletonRenderer, Posterize, ProceduralVFX, ProgrammaticSignal, RGBSplit, RefineEdge, RefractionCaustics3D, Relight3D, Renderer2D, Renderer3D, ResizerScaler, Rotate, SSAO, SSAOPipeline, Scene, SceneDefinitionSchema, SceneTransitionTypeSchema, SegmentationTexturePool, SelectiveColor, SelectorBasedOnSchema, SelectorModeSchema, SelectorShapeSchema, SelectorUnitsSchema, Sequence, ShadowPipeline, ShadowsHighlights, ShapeNodeSchema, Signal, SignalChannelMetaSchema, SignalDataSchema, SignalGateDataSchema, SignalMathDataSchema, SignalStatsSchema, SingleOutputGenericSchema, SkewPropertiesSchema, SlugFontCache, SlugPipeline, SourceOperationSchema, Spatial3DPropertiesSchema, SpatialLandmarkTransformer, SpringPhysicsSchema, StereoPanning, Styles, TEXT_LAYER_DEFAULTS, TemporalDeflicker, TemporalDeflickerPipeline, TemporalObjectTracker, TensorPipeline, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, TextCursorConfigSchema, TextCursorStyleSchema, TextNodeSchema, TextOperationSchema, TextPathBuilder, TextPathOptionsSchema, TextPathSourceSchema, TextRangeSelectorSchema, TextScrambleConfigSchema, TextSelectorSchema, TextSignalSelectorSchema, TextSpanMarkSchema, TextSpanSchema, TextWigglySelectorSchema, TileOffset, TimelineSegmentSchema, TimelineTransformSchema, ToneMappingSchema, Toon, Trails, Transition, TransitionSchema, TransitionTypeSchema, TypewriterAnimatorSchema, TypingCadenceSchema, UnsharpMask, VariableFontAxesSchema, Vec2Schema, Vector3Math, VideoAnimationSchema, VideoLayerTypeSchema, VideoSpatialPropsSchema, VideoStylePropsSchema, VideoTextPropsSchema, VideoTimingPropsSchema, Vignette, VirtualMediaDataSchema, Vision, VisionBundle, VisionNode, VisionRunner, VolumetricFormationConfigSchema, VolumetricFormationModeSchema, 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.mjs.map