π₯ Make videos programmatically with React
Clamp Studio trims to safe keyframe durations
JonnyBurger175bd1c5f277
diff --git a/packages/codemods/src/sequence-props.ts b/packages/codemods/src/sequence-props.tsindex f9966c3167..429c4465a8 100644--- a/packages/codemods/src/sequence-props.ts+++ b/packages/codemods/src/sequence-props.ts@@ -31,6 +31,7 @@ import {NoReactInternals} from 'remotion/no-react';import {getReadOnlySourceSnapshot} from './sequence-props-snapshot';import {computeEffectPropStatus} from './sequence-props/can-update-effect-props';import {getCssShorthandForLonghand} from './sequence-props/css-shorthand-properties';+import {getDurationDependentKeyframes} from './sequence-props/duration-dependent-keyframes';import {getAstNodePath} from './sequence-props/get-ast-node-path';import {toImportAgnosticNodePath} from './sequence-props/import-agnostic-node-path';import {@@ -2324,6 +2325,11 @@ const computeSequencePropsStatusFromAstAndIdentifiers = ({ast,videoConfigValues: videoConfigIdentifierValues,});+ const durationDependentKeyframes = getDurationDependentKeyframes({+ ast,+ jsxPath,+ videoConfigIdentifierValues,+ });const addDefaultKeyframeDisplayOffsetAdjustment = (status: CanUpdateSequencePropSource,): CanUpdateSequencePropSource => {@@ -2361,6 +2367,7 @@ const computeSequencePropsStatusFromAstAndIdentifiers = ({return {canUpdate: true as const,+ ...(durationDependentKeyframes ? {durationDependentKeyframes} : {}),props: Object.fromEntries(Object.entries(filteredProps).map(([key, status]) => [key,diff --git a/packages/codemods/src/sequence-props/duration-dependent-keyframes.ts b/packages/codemods/src/sequence-props/duration-dependent-keyframes.tsnew file mode 100644index 0000000000..ca1781dccd--- /dev/null+++ b/packages/codemods/src/sequence-props/duration-dependent-keyframes.ts@@ -0,0 +1,188 @@+import type {Expression, File, Identifier, Node} from '@babel/types';+import * as recast from 'recast';+import type {+ CanUpdateSequencePropsResponseTrue,+ SourceNumericValue,+} from 'remotion';+import {getNodePathForRecastPath} from '../sequence-props';+import {getKeyframeInterpolationFunctionForCallee} from './keyframe-interpolation-function';+import {parseVideoConfigNumericExpression} from './video-config-numeric-expression';+import type {VideoConfigIdentifierValues} from './video-config-values';++type DurationDependentKeyframes = NonNullable<+ CanUpdateSequencePropsResponseTrue['durationDependentKeyframes']+>;+const cache = new WeakMap<object, DurationDependentKeyframes | null>();+const functionTypes = new Set([+ 'FunctionDeclaration',+ 'FunctionExpression',+ 'ArrowFunctionExpression',+]);++const getConstantInitializer = (+ path: recast.types.NodePath,+): recast.types.NodePath | null => {+ const node = path.node as Node;+ if (node.type !== 'Identifier') return null;+ const binding = path.scope.lookup(node.name)?.getBindings()[node.name]?.[0];+ const declaration = binding?.parentPath;+ return declaration?.node.type === 'VariableDeclarator' &&+ declaration.node.id === binding.node &&+ declaration.parentPath.node.kind === 'const' &&+ declaration.node.init+ ? declaration.get('init')+ : null;+};++const parseFrame = (+ path: recast.types.NodePath,+ bindings: VideoConfigIdentifierValues,+ seen: Set<object>,+): SourceNumericValue | null => {+ const node = path.node as Expression;+ if (!node || seen.has(node)) return null;+ const nextSeen = new Set(seen).add(node);+ const parsed = parseVideoConfigNumericExpression({+ node,+ videoConfigValues: bindings,+ });+ if (parsed) return parsed;+ const initializer = getConstantInitializer(path);+ if (initializer) return parseFrame(initializer, bindings, nextSeen);+ if (node.type === 'TSAsExpression')+ return parseFrame(path.get('expression'), bindings, nextSeen);+ if (+ node.type === 'BinaryExpression' &&+ ['+', '-', '*', '/'].includes(node.operator)+ ) {+ const left = parseFrame(path.get('left'), bindings, nextSeen);+ const right = parseFrame(path.get('right'), bindings, nextSeen);+ return left !== null && right !== null+ ? {+ type: 'binary',+ operator: node.operator as '+' | '-' | '*' | '/',+ left,+ right,+ }+ : null;+ }++ return null;+};++export const getDurationDependentKeyframes = ({+ ast,+ jsxPath,+ videoConfigIdentifierValues,+}: {+ ast: File;+ jsxPath: recast.types.NodePath;+ videoConfigIdentifierValues: VideoConfigIdentifierValues;+}): DurationDependentKeyframes | null => {+ let scopePath: recast.types.NodePath | null = jsxPath;+ while (scopePath && !functionTypes.has((scopePath.node as Node).type)) {+ scopePath = scopePath.parentPath;+ }++ if (!scopePath) return null;+ const scopeNode = scopePath.node as Node;+ if (cache.has(scopeNode)) return cache.get(scopeNode)!;+ const inputRanges: (SourceNumericValue[] | null)[] = [];+ // Inspect the whole render scope, including variables, effects, and ordinary+ // JSX children with no editable schema. Source snapshots cache this per scope.+ recast.types.visit(scopePath as unknown as Node, {+ visitCallExpression(path) {+ const {callee} = path.node;+ if (+ callee.type !== 'Identifier' ||+ !path.node.arguments[1] ||+ getKeyframeInterpolationFunctionForCallee({+ ast,+ callee: callee as Identifier,+ }) === null+ ) {+ return this.traverse(path);+ }++ let dependsOnDuration = false;+ const pending = [path.get('arguments', 1)];+ const seen = new Set<object>();+ while (pending.length > 0) {+ const rangePath = pending.pop()!;+ if (seen.has(rangePath.node as Node)) continue;+ seen.add(rangePath.node as Node);+ recast.types.visit(rangePath as unknown as Node, {+ visitIdentifier(identifierPath) {+ const binding =+ videoConfigIdentifierValues instanceof Map+ ? videoConfigIdentifierValues.get(+ identifierPath.node as Identifier,+ )+ : videoConfigIdentifierValues[identifierPath.node.name];+ if (+ binding?.type === 'video-config' &&+ binding.field === 'durationInFrames'+ ) {+ const declaration = identifierPath.scope+ .lookup(identifierPath.node.name)+ ?.getBindings()[identifierPath.node.name]?.[0];+ let owner = declaration?.parentPath;+ while (+ owner &&+ owner.node !== scopeNode &&+ !functionTypes.has(owner.node.type)+ ) {+ owner = owner.parentPath;+ }++ // A nested component's hook has an independent duration.+ dependsOnDuration ||= owner?.node === scopeNode;+ } else {+ const initializer = getConstantInitializer(+ identifierPath as unknown as recast.types.NodePath,+ );+ if (initializer) pending.push(initializer);+ }++ return false;+ },+ });+ }++ if (dependsOnDuration) {+ let rangePath = path.get('arguments', 1);+ const seenRanges = new Set<object>();+ while (!seenRanges.has(rangePath.node as Node)) {+ seenRanges.add(rangePath.node as Node);+ const initializer = getConstantInitializer(rangePath);+ if (!initializer) break;+ rangePath = initializer;+ }++ const range = rangePath.node as Node;+ const expressions =+ range.type === 'ArrayExpression'+ ? range.elements.map((_, index) =>+ parseFrame(+ rangePath.get('elements', index),+ videoConfigIdentifierValues,+ new Set(),+ ),+ )+ : null;+ // Unknown duration arithmetic must not become an unsafe trim.+ inputRanges.push(+ expressions?.every((value) => value !== null) ? expressions : null,+ );+ }++ return this.traverse(path);+ },+ });+ const result =+ inputRanges.length > 0+ ? {scope: getNodePathForRecastPath(scopePath, ast), inputRanges}+ : null;+ cache.set(scopeNode, result);+ return result;+};diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsxindex cf8a577425..28e8963594 100644--- a/packages/core/src/SequenceManager.tsx+++ b/packages/core/src/SequenceManager.tsx@@ -197,6 +197,11 @@ export type CanUpdateSequencePropsResponseTrue<Numeric = SourceNumericValue> = {canUpdate: true;props: Record<string, CanUpdateSequencePropStatus<Numeric>>;effects: CanUpdateEffectPropsResponse<Numeric>[];+ /** Source ranges also include interpolations outside the editable schema. */+ durationDependentKeyframes?: {+ readonly scope: SequenceNodePath;+ readonly inputRanges: readonly (readonly SourceNumericValue[] | null)[];+ };};export type CanUpdateSequencePropsResponseFalse = {diff --git a/packages/example/src/KeyframeTrimTestbed.tsx b/packages/example/src/KeyframeTrimTestbed.tsxnew file mode 100644index 0000000000..b7a7c4e5d5--- /dev/null+++ b/packages/example/src/KeyframeTrimTestbed.tsx@@ -0,0 +1,545 @@+import {blur} from '@remotion/effects/blur';+import {Audio, Video} from '@remotion/media';+import {linearTiming, TransitionSeries} from '@remotion/transitions';+import {fade} from '@remotion/transitions/fade';+import type {ReactNode} from 'react';+import {+ AbsoluteFill,+ Easing,+ Interactive,+ Internals,+ interpolate,+ Sequence,+ Series,+ Solid,+ staticFile,+ Track,+ useCurrentFrame,+ useVideoConfig,+} from 'remotion';++const Card = ({+ title,+ limit,+ description,+ children,+}: {+ readonly title: string;+ readonly limit: string;+ readonly description: string;+ readonly children: ReactNode;+}) => (+ <div+ style={{+ backgroundColor: '#172033',+ border: '1px solid #34425a',+ borderRadius: 18,+ padding: 16,+ minHeight: 0,+ display: 'flex',+ flexDirection: 'column',+ gap: 8,+ }}+ >+ <div style={{fontSize: 21, fontWeight: 700}}>{title}</div>+ <div style={{fontSize: 18, color: '#8ee6c1', fontWeight: 600}}>{limit}</div>+ <div+ style={{fontSize: 16, color: '#bac5d6', lineHeight: 1.4, minHeight: 44}}+ >+ {description}+ </div>+ <div+ style={{+ position: 'relative',+ flex: 1,+ minHeight: 60,+ display: 'flex',+ justifyContent: 'center',+ alignItems: 'center',+ backgroundColor: '#0d1422',+ borderRadius: 12,+ }}+ >+ {children}+ </div>+ </div>+);++const Clock = () => {+ const frame = useCurrentFrame();+ const {durationInFrames} = useVideoConfig();+ return (+ <div+ style={{+ position: 'absolute',+ bottom: 10,+ left: 0,+ right: 0,+ textAlign: 'center',+ fontSize: 16,+ color: '#9eacc0',+ fontVariantNumeric: 'tabular-nums',+ }}+ >+ Local frame {Math.round(frame * 100) / 100} Β· duration {durationInFrames}+ </div>+ );+};++// Issue #12153: these four input frames stop increasing below 40 frames.+// The ordinary SVG circle deliberately has no editable property schema.+const CircleContent = () => {+ const frame = useCurrentFrame();+ const {durationInFrames, fps} = useVideoConfig();+ return (+ <>+ <Interactive.Svg+ name="SVG child with duration-dependent radius"+ viewBox="0 0 64 60"+ width={128}+ height={120}+ style={{marginBottom: 24}}+ premountFor={fps}+ >+ <circle+ cx="32"+ cy="30"+ r="22"+ fill="none"+ stroke="#34425a"+ strokeWidth="0.6"+ />+ <circle+ cx="32"+ cy="30"+ r={interpolate(+ frame,+ [10, 21, durationInFrames - 18, durationInFrames - 8],+ [0, 9, 9, 0],+ {+ easing: Easing.out(Easing.cubic),+ extrapolateLeft: 'clamp',+ extrapolateRight: 'clamp',+ },+ )}+ fill="#8ee6c1"+ />+ </Interactive.Svg>+ <Clock />+ </>+ );+};++const PropertyContent = () => {+ const frame = useCurrentFrame();+ const {durationInFrames, fps} = useVideoConfig();+ return (+ <>+ <Solid+ name="Opacity keyframes"+ width={120}+ height={100}+ color="#77b4ff"+ premountFor={fps}+ style={{+ borderRadius: 18,+ marginBottom: 24,+ opacity: interpolate(+ frame,+ [10, 21, durationInFrames - 18, durationInFrames - 8],+ [0.2, 1, 1, 0.2],+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},+ ),+ }}+ />+ <Clock />+ </>+ );+};++const EffectContent = () => {+ const frame = useCurrentFrame();+ const {durationInFrames, fps} = useVideoConfig();+ return (+ <>+ <Solid+ name="Blur effect keyframes"+ width={120}+ height={100}+ color="#ffbf83"+ premountFor={fps}+ style={{borderRadius: 18, marginBottom: 24}}+ effects={[+ blur({+ radius: interpolate(+ frame,+ [10, 21, durationInFrames - 18, durationInFrames - 8],+ [12, 0, 0, 12],+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},+ ),+ }),+ ]}+ />+ <Clock />+ </>+ );+};++const NestedContent = () => {+ const {fps} = useVideoConfig();+ return (+ <Sequence+ name="Child: from 10, playback rate 2"+ from={10}+ durationInFrames={120}+ playbackRate={2}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <CircleContent />+ </Sequence>+ );+};++const MaximumContent = () => {+ const frame = useCurrentFrame();+ const {durationInFrames, fps} = useVideoConfig();+ return (+ <>+ <Solid+ name="Bounded opacity keyframes"+ width={120}+ height={100}+ color="#cfabff"+ premountFor={fps}+ style={{+ borderRadius: 18,+ marginBottom: 24,+ opacity: interpolate(+ frame,+ [0, 10, durationInFrames, 90],+ [0.2, 1, 1, 0.2],+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},+ ),+ }}+ />+ <Clock />+ </>+ );+};++const UnknownArithmeticContent = () => {+ const frame = useCurrentFrame();+ const {durationInFrames, fps} = useVideoConfig();+ return (+ <>+ <Solid+ name="Computed input range"+ width={120}+ height={100}+ color="#ff8eac"+ premountFor={fps}+ style={{+ borderRadius: 18,+ marginBottom: 24,+ opacity: interpolate(+ frame,+ [0, 10, Math.max(11, durationInFrames - 18), durationInFrames - 8],+ [0.2, 1, 1, 0.2],+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},+ ),+ }}+ />+ <Clock />+ </>+ );+};++export const KeyframeTrimTestbed = () => {+ const {fps} = useVideoConfig();+ return (+ <AbsoluteFill+ style={{+ backgroundColor: '#0b1120',+ color: '#eef3fb',+ fontFamily: 'Arial, sans-serif',+ padding: 40,+ gap: 24,+ }}+ >+ <div style={{fontSize: 42, fontWeight: 700}}>Timeline trim limits</div>+ <div style={{fontSize: 22, color: '#bac5d6', lineHeight: 1.5}}>+ Each card names the expected feedback and the handle to drag. Rows 1β6+ exercise keyframes; rows 7β16 cover the remaining boundaries. Seek back+ inside shortened clips to see their content.+ </div>+ <div+ style={{+ display: 'grid',+ gridTemplateColumns: 'repeat(4, 1fr)',+ gridTemplateRows: 'repeat(4, minmax(0, 1fr))',+ gap: 18,+ minHeight: 0,+ flex: 1,+ }}+ >+ <Card+ title="1. Plain SVG child"+ limit="Keyframe constraint Β· minimum 40"+ description="Original circle-radius reproduction. No schema on the animated circle."+ >+ <Sequence+ name="1. SVG child β minimum 40"+ durationInFrames={40}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <CircleContent />+ </Sequence>+ </Card>+ <Card+ title="2. Element property"+ limit="Keyframe constraint Β· minimum 40"+ description="Opacity is animated on an editable Solid property."+ >+ <Sequence+ name="2. Property β minimum 40"+ durationInFrames={40}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <PropertyContent />+ </Sequence>+ </Card>+ <Card+ title="3. Effect property"+ limit="Keyframe constraint Β· minimum 40"+ description="The same input range drives a blur effect's radius."+ >+ <Sequence+ name="3. Effect β minimum 40"+ durationInFrames={54}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <EffectContent />+ </Sequence>+ </Card>+ <Card+ title="4. Nested child"+ limit="Keyframe constraint Β· parent minimum 30"+ description="Child starts at 10 and plays at 2Γ. Its local duration must stay at least 40."+ >+ <Sequence+ name="4. Nested parent β minimum 30"+ durationInFrames={38}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <NestedContent />+ </Sequence>+ </Card>+ <Card+ title="5. Maximum duration"+ limit="Keyframe constraint Β· range 11β89"+ description="Input range [0, 10, duration, 90]. Try extending the right edge past 89."+ >+ <Sequence+ name="5. Upper bound β maximum 89"+ durationInFrames={60}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <MaximumContent />+ </Sequence>+ </Card>+ <Card+ title="6. Unresolved arithmetic"+ limit="Computed keyframes Β· stays at 90"+ description="Math.max() in the range cannot be solved statically. Resizing stays locked."+ >+ <Sequence+ name="6. Computed range β locked at 90"+ durationInFrames={90}+ style={{justifyContent: 'center', alignItems: 'center'}}+ premountFor={fps}+ >+ <UnknownArithmeticContent />+ </Sequence>+ </Card>+ <Card+ title="7. One-frame minimum"+ limit="Green glow only Β· one-frame minimum"+ description="Drag the right edge left until only one frame remains."+ >+ <Sequence name="7. Minimum duration" durationInFrames={60}>+ <Clock />+ </Sequence>+ </Card>+ <Card+ title="8. Transition overlap"+ limit="Transition limit"+ description="Shorten clip A with its right edge. The 20-frame fade sets its minimum."+ >+ <Internals.ExperimentalTracksEnabledContext.Provider value={false}>+ <TransitionSeries name="8. Transition container">+ <TransitionSeries.Sequence+ name="8. Transition limit β clip A"+ durationInFrames={60}+ >+ <Clock />+ </TransitionSeries.Sequence>+ <TransitionSeries.Transition+ presentation={fade()}+ timing={linearTiming({durationInFrames: 20})}+ />+ <TransitionSeries.Sequence+ name="8. Transition clip B"+ durationInFrames={60}+ >+ <Clock />+ </TransitionSeries.Sequence>+ </TransitionSeries>+ </Internals.ExperimentalTracksEnabledContext.Provider>+ </Card>+ <Card+ title="9. Source beginning"+ limit="Green glow only Β· source start"+ description="Drag the left edge left. Its 15 trimmed frames can be restored, then it stops."+ >+ <Sequence+ name="9. Source start"+ from={20}+ trimBefore={15}+ durationInFrames={60}+ premountFor={fps}+ >+ <Clock />+ </Sequence>+ </Card>+ <Card+ title="10. Media ending"+ limit="Green glow only Β· source end"+ description="Extend the audio's right edge. The local 56-frame file ends before the composition."+ >+ <Audio+ name="10. Source end"+ src={staticFile('22khz.wav')}+ trimBefore={5}+ durationInFrames={51}+ muted+ />+ <Clock />+ </Card>+ <Card+ title="11. Parent boundary"+ limit="Green glow only Β· parent edge"+ description="Extend the child's right edge to frame 90, where its parent ends."+ >+ <Sequence name="11. Parent β 90 frames" durationInFrames={90}>+ <Sequence+ name="11. Parent edge β child"+ from={10}+ durationInFrames={40}+ >+ <Clock />+ </Sequence>+ </Sequence>+ </Card>+ <Card+ title="12. Composition boundary"+ limit="Green glow only Β· composition edge"+ description="Extend the right edge to frame 180, the end of this composition."+ >+ <Sequence name="12. Composition edge" from={15} durationInFrames={75}>+ <Clock />+ </Sequence>+ </Card>+ <Card+ title="13. Neighboring clips"+ limit="Green glow only Β· adjacent clip"+ description="Extend clip A to frame 80, where clip B starts on the same track."+ >+ <Internals.ExperimentalTracksEnabledContext.Provider value>+ <Track name="13. Adjacent clips">+ <Sequence name="13. Adjacent clip β A" durationInFrames={50}>+ <Clock />+ </Sequence>+ <Sequence+ name="13. Adjacent clip β B"+ from={80}+ durationInFrames={50}+ premountFor={fps * 6}+ >+ <Clock />+ </Sequence>+ </Track>+ </Internals.ExperimentalTracksEnabledContext.Provider>+ </Card>+ <Card+ title="14. Inferred content ending"+ limit="Green glow only Β· content end"+ description="Extend the Series wrapper's right edge. Its two 45-frame children end at 90."+ >+ <Internals.ExperimentalTracksEnabledContext.Provider value={false}>+ <Series name="14. Content end" durationInFrames={50}>+ <Series.Sequence name="14. Content A" durationInFrames={45}>+ <Clock />+ </Series.Sequence>+ <Series.Sequence name="14. Content B" durationInFrames={45}>+ <Clock />+ </Series.Sequence>+ </Series>+ </Internals.ExperimentalTracksEnabledContext.Provider>+ </Card>+ <Card+ title="15. Unavailable media metadata"+ limit="Unknown media duration"+ description="Drag the inner source-start handle left. This deliberately invalid media has no known end."+ >+ <Video+ name="15. Unknown media duration"+ src={staticFile('example.txt')}+ trimBefore={15}+ durationInFrames={60}+ onError={() => 'fallback'}+ fallbackOffthreadVideoProps={{+ onError: () => undefined,+ pauseWhenBuffering: false,+ }}+ muted+ style={{width: 1, height: 1}}+ />+ <Clock />+ </Card>+ <Card+ title="16. Clipped-start fallback"+ limit="Green glow only Β· fallback"+ description="Cmd/Ctrl-select the clipped child and handle row, then drag the handle row's left edge left by 30 frames."+ >+ <Sequence name="16. Clipped parent" from={-30} durationInFrames={150}>+ <Sequence+ name="16. Trim limit β child"+ from={20}+ trimBefore={60}+ durationInFrames={60}+ >+ <Clock />+ </Sequence>+ </Sequence>+ <Sequence+ name="16. Trim limit β drag handle"+ from={45}+ trimBefore={100}+ durationInFrames={60}+ premountFor={fps * 6}+ />+ </Card>+ </div>+ <div style={{fontSize: 18, color: '#8495ad'}}>+ Also try values outside the allowed range in the Duration inspector, or+ select several numbered rows and trim them together.+ </div>+ </AbsoluteFill>+ );+};diff --git a/packages/example/src/Root.tsx b/packages/example/src/Root.tsxindex b7b20dcb11..c57119cd2b 100644--- a/packages/example/src/Root.tsx+++ b/packages/example/src/Root.tsx@@ -118,6 +118,7 @@ import {import {HugeImage} from './HugeImage';import {HugePayload, hugePayloadSchema} from './HugePayload';import {IntrinsicDurationLoopTestbed} from './IntrinsicDurationLoopTestbed';+import {KeyframeTrimTestbed} from './KeyframeTrimTestbed';import {Layers} from './Layers';import {LongAudio} from './LongAudio';import {ManyAudio} from './ManyAudio';@@ -3127,6 +3128,14 @@ export const Index: React.FC = () => {durationInFrames={300}/><Folder name="VisualModeTests">+ <Composition+ id="keyframe-trim-testbed"+ component={KeyframeTrimTestbed}+ width={1920}+ height={1440}+ fps={30}+ durationInFrames={180}+ /><Compositionid="SourceSubscriptionChurn"component={SourceSubscriptionChurn}diff --git a/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts b/packages/studio-shared/src/optimistic-update-for-prop-statuses.tsindex 60ac30889a..a31db11f38 100644--- a/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts+++ b/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts@@ -49,7 +49,7 @@ export const optimisticUpdateForPropStatuses = ({}return {- canUpdate: true,+ ...previous,props,effects: previous.effects,};diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsxindex 5308d411d5..db85b0cb5c 100644--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx@@ -19,6 +19,7 @@ import {StudioServerConnectionCtx} from '../../helpers/client-id';import {BLACK_ALPHA_22,BLUE,+ RED,TIMELINE_AUDIO_GRADIENT,TIMELINE_BACKGROUND_COLOR,TIMELINE_CAPTIONS_GRADIENT,@@ -137,16 +138,22 @@ type TimelineEdgeHighlight = {readonly edge: TimelineEdgeHighlightEdge;};+type TimelineEdgeHighlightState = {+ readonly edge: TimelineEdgeHighlightEdge;+ readonly isAtLimit: boolean;+};+const TimelineEdgeHighlightContext = React.createContext<{readonly register: (nodePathKey: string,listener: React.Dispatch<- React.SetStateAction<TimelineEdgeHighlightEdge | null>+ React.SetStateAction<TimelineEdgeHighlightState | null>>,) => () => void;readonly setHighlights: (highlights: readonly TimelineEdgeHighlight[],) => void;+ readonly setLimitReached: (isAtLimit: boolean) => void;} | null>(null);export const TimelineEdgeHighlightProvider: React.FC<{@@ -155,11 +162,11 @@ export const TimelineEdgeHighlightProvider: React.FC<{// Keep the context value stable so highlighting boundaries does not re-render// every timeline sequence through a context broadcast.const value = useMemo(() => {- let highlights = new Map<string, TimelineEdgeHighlightEdge>();+ let highlights = new Map<string, TimelineEdgeHighlightState>();const listeners = new Map<string,Set<- React.Dispatch<React.SetStateAction<TimelineEdgeHighlightEdge | null>>+ React.Dispatch<React.SetStateAction<TimelineEdgeHighlightState | null>>>>();@@ -167,7 +174,7 @@ export const TimelineEdgeHighlightProvider: React.FC<{register: (nodePathKey: string,listener: React.Dispatch<- React.SetStateAction<TimelineEdgeHighlightEdge | null>+ React.SetStateAction<TimelineEdgeHighlightState | null>>,) => {const listenersForNodePath = listeners.get(nodePathKey) ?? new Set();@@ -187,7 +194,7 @@ export const TimelineEdgeHighlightProvider: React.FC<{const nextHighlightMap = new Map(nextHighlights.map((highlight) => [highlight.nodePathKey,- highlight.edge,+ {edge: highlight.edge, isAtLimit: false},]),);const changedNodePathKeys = new Set([@@ -197,7 +204,10 @@ export const TimelineEdgeHighlightProvider: React.FC<{for (const nodePathKey of changedNodePathKeys) {const previousEdge = highlights.get(nodePathKey) ?? null;const nextEdge = nextHighlightMap.get(nodePathKey) ?? null;- if (previousEdge !== nextEdge) {+ if (+ previousEdge?.edge !== nextEdge?.edge ||+ previousEdge?.isAtLimit !== nextEdge?.isAtLimit+ ) {for (const listener of listeners.get(nodePathKey) ?? []) {listener(nextEdge);}@@ -206,6 +216,16 @@ export const TimelineEdgeHighlightProvider: React.FC<{highlights = nextHighlightMap;},+ setLimitReached: (isAtLimit: boolean) => {+ for (const [nodePathKey, highlight] of highlights) {+ if (highlight.isAtLimit === isAtLimit) continue;+ const next = {...highlight, isAtLimit};+ highlights.set(nodePathKey, next);+ for (const listener of listeners.get(nodePathKey) ?? []) {+ listener(next);+ }+ }+ },};}, []);@@ -327,6 +347,7 @@ const TimelineSequenceBar: React.FC<{readonly hasCaptionsSchema: boolean;readonly connectedComposition: _InternalTypes['AnyComposition'] | null;readonly activeTrimEdge: 'left' | 'right' | null;+ readonly isAtTrimLimit: boolean;readonly leftTrimHighlight: {readonly left: number;readonly width: number;@@ -368,6 +389,7 @@ const TimelineSequenceBar: React.FC<{hasCaptionsSchema,connectedComposition,activeTrimEdge,+ isAtTrimLimit,leftTrimHighlight,displayDurationInFrames,selectionBounds,@@ -457,11 +479,12 @@ const TimelineSequenceBar: React.FC<{Math.min(1, Math.max(0, paintedEnd - paintedStart - 1)): 0;// Back the antialiased rounded edge only when the glow is at the painted layer edge.+ const trimHighlightColor = isAtTrimLimit ? RED : '#00E500';const sequenceBackground =activeTrimEdge === null ||(activeTrimEdge === 'left' && leftTrimHighlight?.left !== negativeStartEnd)? style.background- : `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, #00E500 0 2px, #00E50000 2px), ${style.background ?? TRANSPARENT}`;+ : `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, ${trimHighlightColor} 0 2px, transparent 2px), ${style.background ?? TRANSPARENT}`;const actualStyle: React.CSSProperties = useMemo(() => {return {@@ -640,7 +663,7 @@ const TimelineSequenceBar: React.FC<{? Math.min(EDGE_DRAG_HIGHLIGHT_WIDTH, leftTrimHighlight.width): `min(${EDGE_DRAG_HIGHLIGHT_WIDTH}px, 100%)`,pointerEvents: 'none',- background: `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, #00E500, #00E50000)`,+ background: `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, ${trimHighlightColor}, transparent)`,}}/>)}@@ -764,8 +787,10 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {() => createDragAwareDoubleClickTracker(),[],);- const [activeEdgeHighlight, setActiveEdgeHighlight] =- useState<TimelineEdgeHighlightEdge | null>(null);+ const [activeHighlight, setActiveHighlight] =+ useState<TimelineEdgeHighlightState | null>(null);+ const activeEdgeHighlight = activeHighlight?.edge ?? null;+ const isAtTrimLimit = activeHighlight?.isAtLimit ?? false;const activeTrimEdge =activeEdgeHighlight === 'source-only' ? 'left' : activeEdgeHighlight;useEffect(() => {@@ -775,7 +800,7 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {return edgeHighlightController?.register(stringifySequenceSubscriptionKey(nodePath),- setActiveEdgeHighlight,+ setActiveHighlight,);}, [edgeHighlightController, nodePath]);const naturalSequenceDuration = useTimelineSequenceNaturalDuration({@@ -860,6 +885,12 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {},[dragAwareDoubleClick, edgeHighlightController],);+ const onTrimLimitChange = useCallback(+ (isAtLimit: boolean) => {+ edgeHighlightController?.setLimitReached(isAtLimit);+ },+ [edgeHighlightController],+ );const mediaMetadata = useMediaMetadata(s.type === 'audio' || s.type === 'video' ? s.src : null,@@ -1380,10 +1411,6 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {const timelineVolume = keyframedTimelineVolume ?? 1;const isMedia = s.type === 'audio' || s.type === 'video';- const hasImplicitMediaDuration =- (s.type === 'audio' || s.type === 'video') &&- propStatusesForOverride?.durationInFrames?.status === 'static' &&- propStatusesForOverride.durationInFrames.codeValue === undefined;const durationInFramesCodeValue =propStatusesForOverride?.durationInFrames?.status === 'static'? propStatusesForOverride.durationInFrames.codeValue@@ -1403,7 +1430,6 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {explicitDurationInFrames === null? null: explicitDurationInFrames / s.playbackRate,- hasImplicitDuration: hasImplicitMediaDuration,naturalMediaDuration,timelineDurationInFrames: video.durationInFrames,})@@ -1458,6 +1484,8 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {dragAwareDoubleClick,activeEdgeHighlight,activeTrimEdge,+ isAtTrimLimit,+ onTrimLimitChange,naturalSequenceDuration,startLeftEdgeDrag,startRightEdgeDrag,@@ -1534,6 +1562,8 @@ const TimelineSequenceLayoutInner: React.FC<{dragAwareDoubleClick,activeEdgeHighlight,activeTrimEdge,+ isAtTrimLimit,+ onTrimLimitChange,naturalSequenceDuration,startLeftEdgeDrag,startRightEdgeDrag,@@ -1871,6 +1901,7 @@ const TimelineSequenceLayoutInner: React.FC<{}connectedComposition={connectedCompositions[0] ?? null}activeTrimEdge={activeTrimEdge}+ isAtTrimLimit={isAtTrimLimit}leftTrimHighlight={visibleLayout.media?.offset === 0 ? visibleLayout.media : null}@@ -1923,6 +1954,7 @@ const TimelineSequenceLayoutInner: React.FC<{fps={video.fps}onDragStart={startLeftEdgeDrag}onDragEnd={endEdgeDrag}+ onLimitChange={onTrimLimitChange}onSelect={onSelect}selected={selected}/>@@ -1952,6 +1984,7 @@ const TimelineSequenceLayoutInner: React.FC<{fps={video.fps}onDragStart={startRightEdgeDrag}onDragEnd={endEdgeDrag}+ onLimitChange={onTrimLimitChange}onSelect={onSelect}selected={selected}/>diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsxindex d64e717966..83180d4780 100644--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx@@ -58,6 +58,11 @@ import {saveSequenceProps,type SaveSequencePropChange,} from './save-sequence-prop';+import {+ getTimelineTrimLimitReason,+ getVisibleTimelineTrimLimitReason,+ type TimelineTrimLimitReason,+} from './timeline-trim-limit-reason';import {getTimelineSequenceSelectionKey,shouldSelectTimelineRowOnPointerDown,@@ -110,7 +115,6 @@ export const getTimelineSequenceMediaDurationDragLimits = ({displayStart,effectiveMaxMediaDuration,explicitDurationInFrames,- hasImplicitDuration,naturalMediaDuration,timelineDurationInFrames,}: {@@ -119,7 +123,6 @@ export const getTimelineSequenceMediaDurationDragLimits = ({readonly displayStart: number;readonly effectiveMaxMediaDuration: number | null;readonly explicitDurationInFrames: number | null;- readonly hasImplicitDuration: boolean;readonly naturalMediaDuration: number | null;readonly timelineDurationInFrames: number;}): TimelineSequenceMediaDurationDragLimits | null => {@@ -160,19 +163,13 @@ export const getTimelineSequenceMediaDurationDragLimits = ({const initialDuration = hasInvisibleExplicitTail? containerEdgeDuration: (explicitDurationInFrames ?? displayedMediaEdgeDuration);- const naturalMaximumDuration =- // Keeping duration omitted represents the media's natural end. An- // explicit duration is only useful once its edge is before that end.- Math.ceil(displayStart + naturalMediaDuration - cascadedStart) -- (hasImplicitDuration ? 1 : 0);+ const naturalMaximumDuration = Math.ceil(+ displayStart + naturalMediaDuration - cascadedStart,+ );const maximumDuration = hasInvisibleExplicitTail? Math.min(naturalMaximumDuration, containerEdgeDuration): naturalMaximumDuration;- if (hasImplicitDuration && initialDuration > maximumDuration) {- return null;- }-return {initialDuration, maximumDuration};};@@ -228,6 +225,8 @@ type TimelineSequenceDurationDragTargetBase = {readonly initialDuration: number;readonly maximumDuration: number;readonly minimumDuration: number;+ readonly minimumDurationReason: TimelineTrimLimitReason;+ readonly maximumDurationReason: TimelineTrimLimitReason;readonly nodePath: SequencePropsSubscriptionKey;readonly schema: InteractivitySchema;readonly endField: TimelineSequenceEndField;@@ -1015,10 +1014,19 @@ export const getTimelineSequenceDurationDragTargets = ({return null;}+ const timingLimits = getTimelineSequenceTimingLimits({+ propStatuses,+ movingSequenceIds: null,+ track,+ tracks,+ sequences,+ timelineDurationInFrames,+ });const minimumDuration = Math.max((track.sequence.from + 1 - track.cascadedStart) *track.keyframePlaybackRate,getMinimumSequenceDuration({sequence: originalSequence, sequences}),+ timingLimits.minimumDuration,);const initialDuration = mediaDurationDragLimits? mediaDurationDragLimits.initialDuration * track.keyframePlaybackRate@@ -1055,28 +1063,25 @@ export const getTimelineSequenceDurationDragTargets = ({}}- const timingLimits = getTimelineSequenceTimingLimits({- propStatuses,- movingSequenceIds: null,- track,- tracks,- sequences,- timelineDurationInFrames,- });- const constrainedMaximumDuration = Math.min(- timingLimits.maximumDuration,- mediaDurationDragLimits- ? Math.max(- initialDuration,- mediaDurationDragLimits.maximumDuration *- track.keyframePlaybackRate,- )- : Infinity,+ const mediaMaximumDuration = mediaDurationDragLimits+ ? Math.max(+ initialDuration,+ mediaDurationDragLimits.maximumDuration *+ track.keyframePlaybackRate,+ )+ : Infinity;+ const compositionMaximumDuration =(timelineDurationInFrames - track.cascadedStart) *- track.keyframePlaybackRate,+ track.keyframePlaybackRate;+ const naturalMaximumDuration =naturalDuration !== null && naturalDuration >= minimumDuration? naturalDuration- : Infinity,+ : Infinity;+ const constrainedMaximumDuration = Math.min(+ timingLimits.maximumDuration,+ mediaMaximumDuration,+ compositionMaximumDuration,+ naturalMaximumDuration,parentDurationLimit,);const maximumDuration = Math.max(@@ -1092,6 +1097,17 @@ export const getTimelineSequenceDurationDragTargets = ({fileName: nodePath.absolutePath,initialDuration,maximumDuration,+ minimumDurationReason: timingLimits.limitReasons.minimumDuration,+ maximumDurationReason: getTimelineTrimLimitReason(maximumDuration, [+ [+ timingLimits.maximumDuration,+ timingLimits.limitReasons.maximumDuration,+ ],+ [mediaMaximumDuration, 'Source end'],+ [compositionMaximumDuration, 'Composition edge'],+ [naturalMaximumDuration, 'Content end'],+ [parentDurationLimit, 'Parent edge'],+ ]),...(naturalDuration !== null && maximumDuration === naturalDuration? {naturalDuration, initiallyExplicit: !originalSequence.autoDuration}: {}),@@ -1606,6 +1622,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{targetNodePaths: readonly SequencePropsSubscriptionKey[],) => void;readonly onDragEnd: (wasDragged: boolean) => void;+ readonly onLimitChange: (isAtLimit: boolean) => void;readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;readonly selected: boolean;}> = ({@@ -1621,6 +1638,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{fps,onDragStart,onDragEnd,+ onLimitChange,onSelect,selected,}) => {@@ -1647,6 +1665,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{lastPreviewDeltaFrames: number;previousPreviewValues: Map<string, Map<string, number>>;lastTooltipDelta: number | null;+ lastTooltipReason: TimelineTrimLimitReason | null;didMove: boolean;pxPerFrame: number;pointerId: number;@@ -1664,6 +1683,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{clearDragOverrides,previewServerState,onDragEnd,+ onLimitChange,onSelect,});latestRef.current = {@@ -1675,6 +1695,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{clearDragOverrides,previewServerState,onDragEnd,+ onLimitChange,onSelect,};@@ -1830,6 +1851,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{lastPreviewDeltaFrames: 0,previousPreviewValues: new Map(),lastTooltipDelta: null,+ lastTooltipReason: null,didMove: false,pxPerFrame: canCalculateDelta ? pxPerFrame : 1,pointerId: e.pointerId,@@ -1877,6 +1899,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{dragState.lastPreviewDeltaFrames = deltaFrames;const updates: DragOverrideUpdate[] = [];+ let limitReason: TimelineTrimLimitReason | null = null;for (const target of dragState.targets) {if (target.ripplePrevious) {const previous = target.ripplePrevious;@@ -1886,6 +1909,14 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{maximumDuration: previous.maximumDuration,minimumDuration: previous.minimumDuration,});+ if (nextDuration === previous.minimumDuration)+ limitReason ??= getVisibleTimelineTrimLimitReason(+ previous.minimumDurationReason,+ );+ if (nextDuration === previous.maximumDuration)+ limitReason ??= getVisibleTimelineTrimLimitReason(+ previous.maximumDurationReason,+ );queueStaticDragOverrideIfChanged({updates,previousValues: dragState.previousPreviewValues,@@ -1908,6 +1939,49 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{deltaFrames,trimBeforeOnly: dragState.mode === 'source-only',});+ // Probe both directions through the same clamp, including source-only+ // trims and parent/neighbor bounds. No separate limit math to drift.+ const targetIsAtLimit = [-1, 1].some((direction) => {+ const adjacent = getTimelineSequenceLeftEdgeDragValuesForTarget({+ target,+ deltaFrames: deltaFrames + direction / target.parentPlaybackRate,+ trimBeforeOnly: dragState.mode === 'source-only',+ });+ return (+ adjacent.durationInFrames === nextValues.durationInFrames &&+ adjacent.from === nextValues.from &&+ adjacent.trimBefore === nextValues.trimBefore+ );+ });+ if (targetIsAtLimit) {+ const limits = target.timingLimits;+ const targetLimitReason =+ dragState.mode === 'source-only'+ ? getTimelineTrimLimitReason(nextValues.trimBefore, [+ [+ limits?.minimumTrimBefore ?? NaN,+ limits?.limitReasons.minimumTrimBefore ?? null,+ ],+ [+ limits?.maximumTrimBefore ?? NaN,+ limits?.limitReasons.maximumTrimBefore ?? null,+ ],+ ])+ : nextValues.durationInFrames === target.minimumDuration+ ? target.minimumDuration > 1+ ? 'Transition limit'+ : 'Minimum duration'+ : nextValues.trimBefore === 0+ ? 'Source start'+ : getTimelineTrimLimitReason(nextValues.from, [+ [+ limits?.minimumFrom ?? NaN,+ limits?.limitReasons.minimumFrom ?? null,+ ],+ ]);+ limitReason ??=+ getVisibleTimelineTrimLimitReason(targetLimitReason);+ }if (dragState.mode !== 'source-only' &&@@ -1944,6 +2018,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{});}+ latestRef.current.onLimitChange(limitReason !== null);if (updates.length > 0) {if (latestRef.current.batchSetters) {latestRef.current.batchSetters.setDragOverridesBatch(updates);@@ -1989,9 +2064,14 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{(draggedTarget.positionField === null && ripplePrevious === null)? 0: appliedDelta;- if (dragState.lastTooltipDelta !== appliedDelta) {+ if (+ dragState.lastTooltipDelta !== appliedDelta ||+ dragState.lastTooltipReason !== limitReason+ ) {dragState.lastTooltipDelta = appliedDelta;+ dragState.lastTooltipReason = limitReason;setTrimTooltip({+ limitReason,deltaFrames: appliedDelta,edgeFrame: initialTimelineEdge + edgeDelta,x:@@ -2470,6 +2550,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{targetNodePaths: readonly SequencePropsSubscriptionKey[],) => void;readonly onDragEnd: (wasDragged: boolean) => void;+ readonly onLimitChange: (isAtLimit: boolean) => void;readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;readonly selected: boolean;}> = ({@@ -2482,6 +2563,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{fps,onDragStart,onDragEnd,+ onLimitChange,onSelect,selected,}) => {@@ -2512,6 +2594,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{lastPreviewDeltaFrames: number;previousPreviewValues: Map<string, Map<string, number>>;lastTooltipDelta: number | null;+ lastTooltipReason: TimelineTrimLimitReason | null;didMove: boolean;pxPerFrame: number;pointerId: number;@@ -2530,6 +2613,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{clearDragOverrides,previewServerState,onDragEnd,+ onLimitChange,onSelect,updateSnapFrameRef,});@@ -2543,6 +2627,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{clearDragOverrides,previewServerState,onDragEnd,+ onLimitChange,onSelect,updateSnapFrameRef,};@@ -2682,6 +2767,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{lastPreviewDeltaFrames: 0,previousPreviewValues: new Map(),lastTooltipDelta: null,+ lastTooltipReason: null,didMove: false,pxPerFrame: canCalculateDelta ? pxPerFrame : 1,pointerId: e.pointerId,@@ -2723,6 +2809,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{dragState.lastPreviewDeltaFrames = deltaFrames;const updates: DragOverrideUpdate[] = [];+ let limitReason: TimelineTrimLimitReason | null = null;for (const target of dragState.targets) {const previewValue = getTimelineSequenceDurationDragValue({initialDuration: target.initialDuration,@@ -2730,6 +2817,14 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{maximumDuration: target.maximumDuration,minimumDuration: target.minimumDuration,});+ if (previewValue === target.minimumDuration)+ limitReason ??= getVisibleTimelineTrimLimitReason(+ target.minimumDurationReason,+ );+ if (previewValue === target.maximumDuration)+ limitReason ??= getVisibleTimelineTrimLimitReason(+ target.maximumDurationReason,+ );queueStaticDragOverrideIfChanged({updates,@@ -2747,6 +2842,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{});}+ latestRef.current.onLimitChange(limitReason !== null);if (updates.length > 0) {if (latestRef.current.batchSetters) {latestRef.current.batchSetters.setDragOverridesBatch(updates);@@ -2777,9 +2873,14 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{? initialTimelineEdge + appliedDelta: null,);- if (dragState.lastTooltipDelta !== appliedDelta) {+ if (+ dragState.lastTooltipDelta !== appliedDelta ||+ dragState.lastTooltipReason !== limitReason+ ) {dragState.lastTooltipDelta = appliedDelta;+ dragState.lastTooltipReason = limitReason;setTrimTooltip({+ limitReason,deltaFrames: appliedDelta,edgeFrame: initialTimelineEdge + appliedDelta,x:diff --git a/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx b/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsxindex fe90f387f6..9b20536cb4 100644--- a/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx+++ b/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx@@ -4,6 +4,10 @@ import {BLACK_ALPHA_85, LIGHT_TEXT, WHITE} from '../../helpers/colors';import {renderFrame} from '../../state/render-frame';import {useZIndex} from '../../state/z-index';import {getPortal} from '../Menu/portals';+import {+ getVisibleTimelineTrimLimitReason,+ type TimelineTrimLimitReason,+} from './timeline-trim-limit-reason';import {TimelineTickFormatContext} from './TimelineTickFormatProvider';export type TimelineTrimTooltipState = {@@ -11,6 +15,7 @@ export type TimelineTrimTooltipState = {readonly edgeFrame: number;readonly x: number;readonly y: number;+ readonly limitReason: TimelineTrimLimitReason | null;};const tooltip: React.CSSProperties = {@@ -50,15 +55,27 @@ export const TimelineTrimTooltip: React.FC<{? format(0): `${delta < 0 ? 'β' : '+'}${format(Math.abs(delta))}`;const edgeLabel = format(edge);+ const limitReason = getVisibleTimelineTrimLimitReason(state.limitReason);const tooltipWidth = Math.max(82,- Math.ceil(Math.max(deltaLabel.length, edgeLabel.length) * 7 + 14),+ Math.ceil(+ Math.max(deltaLabel.length, edgeLabel.length, limitReason?.length ?? 0) *+ 7 ++ 14,+ ),);+ const tooltipHeight = limitReason === null ? 36 : 50;const left = Math.max(8,Math.min(state.x - tooltipWidth / 2, window.innerWidth - tooltipWidth - 8),);- const top = Math.max(8, Math.min(state.y - 40, window.innerHeight - 44));+ const top = Math.max(+ 8,+ Math.min(+ state.y - tooltipHeight - 4,+ window.innerHeight - tooltipHeight - 8,+ ),+ );return createPortal(<div@@ -67,7 +84,10 @@ export const TimelineTrimTooltip: React.FC<{style={{...tooltip, left, top, width: tooltipWidth}}data-remotion-timeline-trim-tooltip="true">- <div style={line}>{deltaLabel}</div>+ {limitReason === null ? null : (+ <div style={{...line, color: WHITE}}>{limitReason}</div>+ )}+ <div style={{...line, color: WHITE}}>{deltaLabel}</div><div style={{...line, color: LIGHT_TEXT}}>{edgeLabel}</div></div>,getPortal(currentZIndex),diff --git a/packages/studio/src/components/Timeline/get-keyframe-duration-limits.ts b/packages/studio/src/components/Timeline/get-keyframe-duration-limits.tsnew file mode 100644index 0000000000..671b0e857a--- /dev/null+++ b/packages/studio/src/components/Timeline/get-keyframe-duration-limits.ts@@ -0,0 +1,243 @@+import {+ Internals,+ type PropStatuses,+ type SourceNumericValue,+ type TSequence,+ type VideoConfigValues,+} from 'remotion';+import {NoReactInternals} from 'remotion/no-react';+import type {TimelineTrackData} from '../../helpers/get-timeline-sequence-sort-key';+import type {TimelineTrimLimitReason} from './timeline-trim-limit-reason';++const getDurationCoefficients = (+ expression: SourceNumericValue,+ config: VideoConfigValues,+): {factor: number; offset: number} | null => {+ if (typeof expression === 'number' || expression.type === 'literal') {+ return {+ factor: 0,+ offset: typeof expression === 'number' ? expression : expression.value,+ };+ }++ if (expression.type !== 'binary') {+ if (+ expression.binding.type !== 'video-config' ||+ expression.binding.field !== 'durationInFrames'+ ) {+ return {+ factor: 0,+ offset: NoReactInternals.evaluateSourceNumericValue(expression, config),+ };+ }++ return {+ factor:+ expression.type === 'video-config-multiplication'+ ? expression.multiplier+ : 1,+ offset:+ expression.type === 'video-config-subtraction'+ ? -expression.subtrahend+ : 0,+ };+ }++ const left = getDurationCoefficients(expression.left, config);+ const right = getDurationCoefficients(expression.right, config);+ if (!left || !right) return null;+ if (expression.operator === '+' || expression.operator === '-') {+ const sign = expression.operator === '+' ? 1 : -1;+ return {+ factor: left.factor + sign * right.factor,+ offset: left.offset + sign * right.offset,+ };+ }++ if (expression.operator === '*') {+ return left.factor !== 0 && right.factor !== 0+ ? null+ : {+ factor: left.factor * right.offset + right.factor * left.offset,+ offset: left.offset * right.offset,+ };+ }++ return right.factor !== 0 || right.offset === 0+ ? null+ : {+ factor: left.factor / right.offset,+ offset: left.offset / right.offset,+ };+};++export const getKeyframeDurationLimits = ({+ sequence,+ sequences,+ tracks,+ propStatuses,+}: {+ readonly sequence: TSequence;+ readonly sequences: readonly TSequence[];+ readonly tracks: readonly TimelineTrackData[];+ readonly propStatuses: PropStatuses;+}) => {+ const sequencesById = new Map(sequences.map((item) => [item.id, item]));+ const tracksById = new Map(tracks.map((item) => [item.sequence.id, item]));+ const visited = new Set<string>();+ let minimumEnd = -Infinity;+ let maximumEnd = Infinity;+ let minimumReason: TimelineTrimLimitReason | null = null;+ let maximumReason: TimelineTrimLimitReason | null = null;+ for (const track of tracks) {+ const nodePath = track.nodePathInfo?.sequenceSubscriptionKey;+ if (!nodePath) continue;+ const status =+ propStatuses[Internals.makeSequencePropsSubscriptionKey(nodePath)];+ const constraints = status?.canUpdate+ ? status.durationDependentKeyframes+ : null;+ if (!constraints) continue;++ // A hook in the render function reads the context outside its outermost+ // JSX element. Nested JSX sequences do not change that hook's clock.+ let scopeTrack = track;+ let owner = sequencesById.get(scopeTrack.sequence.parent ?? '');+ while (owner) {+ const parentTrack = tracksById.get(owner.id);+ const parentPath = parentTrack?.nodePathInfo?.sequenceSubscriptionKey;+ if (+ !parentTrack ||+ !parentPath ||+ parentPath.absolutePath !== nodePath.absolutePath ||+ !constraints.scope.every(+ (part, index) => parentPath.nodePath[index] === part,+ )+ )+ break;+ scopeTrack = parentTrack;+ owner = sequencesById.get(owner.parent ?? '');+ }++ if (!owner) continue;+ const chain: TSequence[] = [];+ let ancestor: TSequence | undefined = owner;+ while (ancestor && ancestor.id !== sequence.id) {+ chain.push(ancestor);+ ancestor = sequencesById.get(ancestor.parent ?? '');+ }++ if (!ancestor) continue;+ const key = `${owner.id}\0${nodePath.absolutePath}\0${constraints.scope.join('.')}`;+ if (visited.has(key)) continue;+ visited.add(key);+ const config = scopeTrack.sequence.controls?.videoConfigValues;+ if (!config) continue;++ let minimum = -Infinity;+ let maximum = Infinity;+ let locked = false;+ for (const range of constraints.inputRanges) {+ const coefficients = range?.map((expression) =>+ getDurationCoefficients(expression, config),+ );+ if (!coefficients || coefficients.some((value) => value === null)) {+ locked = true;+ minimum = Math.max(minimum, config.durationInFrames);+ maximum = Math.min(maximum, config.durationInFrames);+ continue;+ }++ for (let index = 1; index < coefficients.length; index++) {+ const previous = coefficients[index - 1]!;+ const current = coefficients[index]!;+ const factor = current.factor - previous.factor;+ const offset = current.offset - previous.offset;+ if (+ !Number.isFinite(factor) ||+ !Number.isFinite(offset) ||+ (factor === 0 && offset <= 0)+ ) {+ locked = true;+ minimum = Math.max(minimum, config.durationInFrames);+ maximum = Math.min(maximum, config.durationInFrames);+ } else if (factor > 0) {+ minimum = Math.max(minimum, Math.floor(-offset / factor) + 1);+ } else if (factor < 0) {+ maximum = Math.min(maximum, Math.ceil(-offset / factor) - 1);+ }+ }+ }++ for (const child of chain) {+ const childPath = tracksById.get(child.id)?.nodePathInfo+ ?.sequenceSubscriptionKey;+ const childProps = childPath+ ? Internals.getPropStatusesCtx(propStatuses, childPath)+ : null;+ const childConfig = child.controls?.videoConfigValues;+ const hasDependentTiming = [+ 'from',+ 'durationInFrames',+ 'trimBefore',+ 'playbackRate',+ ].some((field) => {+ const prop = childProps?.[field];+ if (!prop) return false;+ if (prop.status !== 'static') return true;+ if (!prop.numericExpression || !childConfig) return false;+ const coefficients = getDurationCoefficients(+ prop.numericExpression,+ childConfig,+ );+ return !coefficients || coefficients.factor !== 0;+ });+ if (child.loopDisplay || hasDependentTiming) {+ locked = true;+ // Partial loops and duration-dependent child timings are not affine+ // in the ancestor's end. Preserve the current safe duration.+ minimum =+ sequence.duration * sequence.sequencePlaybackRate ++ (sequence.trimBefore ?? 0);+ maximum = minimum;+ break;+ }++ const trimBefore = child.trimBefore ?? 0;+ const runtimeDuration =+ child.controls?.runtimeValues.getSnapshot().durationInFrames;+ const ownDuration =+ typeof runtimeDuration === 'number'+ ? runtimeDuration+ : child.unclippedDuration !== undefined &&+ child.unclippedDuration !== null+ ? child.unclippedDuration * child.sequencePlaybackRate+ : Infinity;+ // Once a child's explicit duration caps its clock, extending an+ // ancestor cannot cross the child's upper interpolation bound.+ if (ownDuration + trimBefore <= maximum) maximum = Infinity;+ minimum =+ child.from + (minimum - trimBefore) / child.sequencePlaybackRate;+ maximum =+ child.from + (maximum - trimBefore) / child.sequencePlaybackRate;+ }++ if (+ Number.isFinite(minimum) &&+ (minimum > minimumEnd || (minimum === minimumEnd && locked))+ ) {+ minimumEnd = minimum;+ minimumReason = locked ? 'Computed keyframes' : 'Keyframe constraint';+ }++ if (+ Number.isFinite(maximum) &&+ (maximum < maximumEnd || (maximum === maximumEnd && locked))+ ) {+ maximumEnd = maximum;+ maximumReason = locked ? 'Computed keyframes' : 'Keyframe constraint';+ }+ }++ return {minimumEnd, maximumEnd, minimumReason, maximumReason};+};diff --git a/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts b/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.tsindex 872bb054f4..29d34db40d 100644--- a/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts+++ b/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts@@ -7,7 +7,12 @@ import type {import {Internals} from 'remotion';import type {TimelineTrackData} from '../../helpers/get-timeline-sequence-sort-key';import {getCachedMediaMetadata} from '../../helpers/use-media-metadata';+import {getKeyframeDurationLimits} from './get-keyframe-duration-limits';import {getTimelineSequenceNaturalDuration} from './get-timeline-sequence-natural-duration';+import {+ getTimelineTrimLimitReason,+ type TimelineTrimLimitReason,+} from './timeline-trim-limit-reason';const {sortItemsByCommitOrder} = CanvasInternals;const isTransitionSeriesTransition = (sequence: TSequence | undefined) =>sequence?.controls?.componentIdentity ===@@ -129,10 +134,27 @@ export const getTimelineSequenceTimingLimits = ({typeof runtimeValues.trimBefore === 'number'? runtimeValues.trimBefore: (sequence.trimBefore ?? 0);+ const keyframeLimits = getKeyframeDurationLimits({+ sequence,+ sequences,+ tracks,+ propStatuses,+ });+ const transitionMinimumDuration = getMinimumSequenceDuration({+ sequence,+ sequences,+ });+ const keyframeMinimumDuration = Math.ceil(+ (keyframeLimits.minimumEnd - trimBefore) / sequence.sequencePlaybackRate,+ );+ const keyframeMaximumDuration = Math.floor(+ (keyframeLimits.maximumEnd - trimBefore) / sequence.sequencePlaybackRate,+ );const minimumDuration = Math.max((track.sequence.from + 1 - track.cascadedStart) *track.keyframePlaybackRate,- getMinimumSequenceDuration({sequence, sequences}),+ transitionMinimumDuration,+ keyframeMinimumDuration,);let initialDuration =typeof runtimeValues.durationInFrames === 'number' &&@@ -229,6 +251,7 @@ export const getTimelineSequenceTimingLimits = ({const reservedDuration =inferredDuration || loops ? minimumDuration : initialDuration;const maximumDuration = Math.min(+ keyframeMaximumDuration,spatialMaximumDuration,loops? Infinity@@ -252,30 +275,98 @@ export const getTimelineSequenceTimingLimits = ({? parentEnd + (initialDuration - 1) / track.keyframePlaybackRate: parentEnd,);+ const minimumFrom =+ sequence.from ++ (minimumMoveStart - track.cascadedStart) * track.keyframePlaybackRate;+ const minimumTrimBefore = Math.max(+ keyframeLimits.minimumEnd - initialDuration * sequence.sequencePlaybackRate,+ isMedia && inferredDuration && !Number.isFinite(sourceEnd)+ ? trimBefore+ : inferredDuration && !loops && Number.isFinite(sourceEnd)+ ? Math.max(0, sourceEnd - spatialMaximumDuration * playbackRate)+ : 0,+ );+ const maximumTrimBefore = Math.min(+ keyframeLimits.maximumEnd - initialDuration * sequence.sequencePlaybackRate,+ isMedia && !Number.isFinite(sourceEnd)+ ? trimBefore+ : Math.max(0, sourceEnd - reservedDuration * playbackRate),+ );+ const spatialLimitReason: TimelineTrimLimitReason =+ maximumEnd === maximumNeighbourEnd+ ? 'Adjacent clip'+ : parentEnd === timelineDurationInFrames+ ? 'Composition edge'+ : 'Parent edge';+ const minimumDurationReason = getTimelineTrimLimitReason(minimumDuration, [+ [keyframeMinimumDuration, keyframeLimits.minimumReason],+ [+ transitionMinimumDuration,+ transitionMinimumDuration > 1 ? 'Transition limit' : 'Minimum duration',+ ],+ [minimumDuration, 'Minimum duration'],+ ]);+ const minimumFromReason: TimelineTrimLimitReason =+ minimumMoveStart === minimumNeighbourStart+ ? 'Adjacent clip'+ : sequence.parent === null+ ? 'Composition edge'+ : 'Parent edge';return {playbackRate,minimumDuration,maximumDuration: Math.max(minimumDuration, maximumDuration),- minimumFrom:- sequence.from +- (minimumMoveStart - track.cascadedStart) * track.keyframePlaybackRate,+ minimumFrom,maximumFrom:sequence.from +(maximumMoveEnd - track.cascadedStart) * track.keyframePlaybackRate -initialDuration,- minimumTrimBefore:- isMedia && inferredDuration && !Number.isFinite(sourceEnd)- ? trimBefore- : inferredDuration && !loops && Number.isFinite(sourceEnd)- ? Math.max(0, sourceEnd - spatialMaximumDuration * playbackRate)- : 0,- maximumTrimBefore:- isMedia && !Number.isFinite(sourceEnd)- ? trimBefore- : Math.max(0, sourceEnd - reservedDuration * playbackRate),+ minimumTrimBefore,+ maximumTrimBefore,+ limitReasons: {+ minimumDuration: minimumDurationReason,+ maximumDuration: getTimelineTrimLimitReason(+ Math.max(minimumDuration, maximumDuration),+ [+ [keyframeMaximumDuration, keyframeLimits.maximumReason],+ [spatialMaximumDuration, spatialLimitReason],+ [minimumDuration, minimumDurationReason],+ [maximumDuration, isMedia ? 'Source end' : 'Content end'],+ ],+ ),+ minimumFrom: minimumFromReason,+ minimumTrimBefore: getTimelineTrimLimitReason(minimumTrimBefore, [+ [+ keyframeLimits.minimumEnd -+ initialDuration * sequence.sequencePlaybackRate,+ keyframeLimits.minimumReason,+ ],+ [0, 'Source start'],+ [+ minimumTrimBefore,+ isMedia && !Number.isFinite(sourceEnd)+ ? 'Unknown media duration'+ : spatialLimitReason,+ ],+ ]),+ maximumTrimBefore: getTimelineTrimLimitReason(maximumTrimBefore, [+ [+ keyframeLimits.maximumEnd -+ initialDuration * sequence.sequencePlaybackRate,+ keyframeLimits.maximumReason,+ ],+ [+ maximumTrimBefore,+ isMedia && !Number.isFinite(sourceEnd)+ ? 'Unknown media duration'+ : 'Source end',+ ],+ ]),+ },maximumTrimAfter:inferredDuration && !loops? Math.min(+ keyframeLimits.maximumEnd,sourceMaximumTrimAfter,trimBefore + spatialMaximumDuration * playbackRate,)diff --git a/packages/studio/src/components/Timeline/timeline-trim-limit-reason.ts b/packages/studio/src/components/Timeline/timeline-trim-limit-reason.tsnew file mode 100644index 0000000000..81cd555308--- /dev/null+++ b/packages/studio/src/components/Timeline/timeline-trim-limit-reason.ts@@ -0,0 +1,43 @@+export const TIMELINE_TRIM_LIMIT_REASONS = [+ 'Keyframe constraint',+ 'Computed keyframes',+ 'Unknown media duration',+ 'Minimum duration',+ 'Transition limit',+ 'Source start',+ 'Source end',+ 'Parent edge',+ 'Composition edge',+ 'Adjacent clip',+ 'Content end',+ 'Trim limit',+] as const;++export type TimelineTrimLimitReason =+ (typeof TIMELINE_TRIM_LIMIT_REASONS)[number];++export const getVisibleTimelineTrimLimitReason = (+ reason: TimelineTrimLimitReason | null,+): TimelineTrimLimitReason | null => {+ return reason === 'Keyframe constraint' ||+ reason === 'Computed keyframes' ||+ reason === 'Unknown media duration' ||+ reason === 'Transition limit'+ ? reason+ : null;+};++export const getTimelineTrimLimitReason = (+ value: number,+ candidates: readonly (readonly [number, TimelineTrimLimitReason | null])[],+): TimelineTrimLimitReason => {+ return (+ candidates.find(+ ([limit, reason]) =>+ reason !== null &&+ Number.isFinite(limit) &&+ Math.abs(value - limit) <=+ Number.EPSILON * Math.max(1, Math.abs(value), Math.abs(limit)) * 8,+ )?.[1] ?? 'Trim limit'+ );+};diff --git a/packages/studio/src/test/timeline-selection.test.ts b/packages/studio/src/test/timeline-selection.test.tsindex 1a2826f617..c6060ce09e 100644--- a/packages/studio/src/test/timeline-selection.test.ts+++ b/packages/studio/src/test/timeline-selection.test.ts@@ -2105,6 +2105,8 @@ test('Timeline duration drag supports interactive video clips', () => {initialDuration: 78,maximumDuration: 1000,minimumDuration: 1,+ minimumDurationReason: 'Minimum duration',+ maximumDurationReason: 'Composition edge',nodePath: nodePathInfo.sequenceSubscriptionKey,schema: Internals.baseSchema,endField: {fieldKey: 'durationInFrames', trimBefore: 0, playbackRate: 1},@@ -2256,7 +2258,6 @@ test('Media duration drag limits account for a negative from', () => {displayDurationInFrames: 108,displayStart: 0,explicitDurationInFrames: 300,- hasImplicitDuration: false,naturalMediaDuration: 33,timelineDurationInFrames: 1000,};@@ -2277,14 +2278,13 @@ test('Media duration drag limits account for a negative from', () => {).toEqual({initialDuration: 300, maximumDuration: 225});});-test('Implicit media cannot be resized once its edge reaches the asset end', () => {+test('Implicit media can be shortened once its edge reaches the asset end', () => {const common = {cascadedStart: -34,displayDurationInFrames: 266,displayStart: 0,effectiveMaxMediaDuration: null,explicitDurationInFrames: null,- hasImplicitDuration: true,timelineDurationInFrames: 300,};@@ -2294,14 +2294,14 @@ test('Implicit media cannot be resized once its edge reaches the asset end', ()// The video holds its last frame until the composition ends.naturalMediaDuration: 220,}),- ).toBe(null);+ ).toEqual({initialDuration: 300, maximumDuration: 254});expect(getTimelineSequenceMediaDurationDragLimits({...common,// The composition ends before the source video does.naturalMediaDuration: 400,}),- ).toEqual({initialDuration: 300, maximumDuration: 433});+ ).toEqual({initialDuration: 300, maximumDuration: 434});});test('Timeline duration drag clamps explicit audio and video to the asset end', () => {