@cueframe/kernel 0.0.1

package/dist/chunk-TWQOKKAF.js

@@ -0,0 +1,859 @@
+import {
+  expandClipIdsToLinkGroups,
+  linkPartners
+} from "./chunk-KYRDKK2D.js";
+import {
+  InvariantError,
+  isSourceKindCompatible
+} from "./chunk-DENF4TPI.js";
+
+// ../composition/src/timeline/occupancy.ts
+var excluded = (span, id) => !!span.excludeClipIds && span.excludeClipIds.includes(id);
+function spansOverlap(aStart, aDuration, bStart, bDuration) {
+  return aStart < bStart + bDuration && aStart + aDuration > bStart;
+}
+function spansFit(track, spans) {
+  return spans.every(
+    (span) => collidingClips(track, span).length === 0
+  );
+}
+function collidingClips(track, span) {
+  return track.contents.filter(
+    (c) => !excluded(span, c.id) && c.duration > 0 && spansOverlap(span.startTime, span.duration, c.startTime, c.duration)
+  ).slice().sort((a, b) => a.startTime - b.startTime);
+}
+function classifyOverlap(span, clip) {
+  const spanEnd = span.startTime + span.duration;
+  const clipEnd = clip.startTime + clip.duration;
+  const startsAtOrBefore = span.startTime <= clip.startTime;
+  const endsAtOrAfter = spanEnd >= clipEnd;
+  if (startsAtOrBefore && endsAtOrAfter) return "covers";
+  if (startsAtOrBefore) return "trims-head";
+  if (endsAtOrAfter) return "trims-tail";
+  return "engulfed-by";
+}
+
+// ../composition/src/timeline/plan.ts
+var entityKey = (e) => {
+  switch (e.kind) {
+    case "clip":
+      return `clip:${e.clipId}`;
+    case "keyframe":
+      return `kf:${e.clipId}:${e.param}:${e.index}`;
+    case "transition":
+      return `tr:${e.clipId}`;
+    case "marker":
+      return `mk:${e.markerId}`;
+  }
+};
+var REFUSAL_TEXT = {
+  "incompatible-track": "That track cannot hold this kind of clip",
+  "track-not-found": "That track is no longer on the timeline",
+  "no-compatible-track-kind": "Nothing on this timeline can hold this kind of clip",
+  "clip-not-found": "That clip is no longer on the timeline",
+  "occupied-and-unresolvable": "There is no room there, and nothing that can be moved aside",
+  "zero-duration": "A clip needs a duration greater than zero"
+};
+function refusalText(reason) {
+  return REFUSAL_TEXT[reason];
+}
+var emptyPlan = (label) => ({
+  ops: [],
+  resultingSelection: [],
+  refusals: [],
+  label
+});
+var planIsNoop = (plan) => plan.ops.length === 0;
+
+// ../composition/src/timeline/placement.ts
+function trackKindForSource(sourceKind) {
+  const kinds = ["video", "audio", "image", "overlay", "effect"];
+  return kinds.find((k) => isSourceKindCompatible(k, sourceKind)) ?? null;
+}
+function resolvePlacement(args) {
+  const { tracks, sourceKind, trackKind, spans, strategy, allowOccupied = false } = args;
+  const preferredKind = trackKind ?? trackKindForSource(sourceKind);
+  if (!preferredKind) return { kind: "refused", reason: "no-compatible-track-kind" };
+  const fits = (t) => trackKind ? t.kind === trackKind : isSourceKindCompatible(t.kind, sourceKind);
+  const asExisting = (index) => ({
+    kind: "existingTrack",
+    trackId: tracks[index].id,
+    trackIndex: index,
+    trackKind: tracks[index].kind
+  });
+  switch (strategy.type) {
+    case "explicit": {
+      const index = tracks.findIndex((t) => t.id === strategy.trackId);
+      if (index < 0) return { kind: "refused", reason: "track-not-found" };
+      if (!fits(tracks[index])) {
+        return { kind: "refused", reason: "incompatible-track" };
+      }
+      if (!allowOccupied && !spansFit(tracks[index], spans)) {
+        return { kind: "newTrack", insertIndex: index + 1, trackKind: tracks[index].kind };
+      }
+      return asExisting(index);
+    }
+    case "firstAvailable": {
+      const index = tracks.findIndex((t) => fits(t) && spansFit(t, spans));
+      if (index >= 0) return asExisting(index);
+      return { kind: "newTrack", insertIndex: tracks.length, trackKind: preferredKind };
+    }
+    case "preferIndex": {
+      const hovered = tracks[strategy.trackIndex];
+      if (hovered && fits(hovered) && spansFit(hovered, spans)) {
+        return asExisting(strategy.trackIndex);
+      }
+      const insertIndex = strategy.hoverDirection === "above" ? strategy.trackIndex : strategy.trackIndex + 1;
+      return {
+        kind: "newTrack",
+        insertIndex: Math.max(0, Math.min(tracks.length, insertIndex)),
+        trackKind: hovered && fits(hovered) ? hovered.kind : preferredKind
+      };
+    }
+    case "alwaysNew":
+      return {
+        kind: "newTrack",
+        insertIndex: strategy.position === "highest" ? 0 : tracks.length,
+        trackKind: preferredKind
+      };
+  }
+}
+
+// ../composition/src/timeline/keyframes.ts
+var EASING_CONTROL_POINTS = {
+  linear: [0, 0, 1, 1],
+  ease: [0.25, 0.1, 0.25, 1],
+  easeIn: [0.42, 0, 1, 1],
+  easeOut: [0, 0, 0.58, 1],
+  easeInOut: [0.42, 0, 0.58, 1]
+};
+function controlPoints(easing) {
+  if (!easing) return EASING_CONTROL_POINTS.linear;
+  if (typeof easing === "string") return EASING_CONTROL_POINTS[easing] ?? EASING_CONTROL_POINTS.linear;
+  return easing.cubicBezier;
+}
+function bezierEasing(t, [x1, y1, x2, y2]) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  if (x1 === y1 && x2 === y2) return t;
+  const curveX = (u2) => {
+    const v = 1 - u2;
+    return 3 * v * v * u2 * x1 + 3 * v * u2 * u2 * x2 + u2 * u2 * u2;
+  };
+  const curveY = (u2) => {
+    const v = 1 - u2;
+    return 3 * v * v * u2 * y1 + 3 * v * u2 * u2 * y2 + u2 * u2 * u2;
+  };
+  const slopeX = (u2) => {
+    const v = 1 - u2;
+    return 3 * v * v * x1 + 6 * v * u2 * (x2 - x1) + 3 * u2 * u2 * (1 - x2);
+  };
+  let u = t;
+  for (let i = 0; i < 8; i++) {
+    const x = curveX(u) - t;
+    if (Math.abs(x) < 1e-6) return curveY(u);
+    const d = slopeX(u);
+    if (Math.abs(d) < 1e-6) break;
+    u -= x / d;
+  }
+  let lo = 0;
+  let hi = 1;
+  u = t;
+  for (let i = 0; i < 20; i++) {
+    const x = curveX(u);
+    if (Math.abs(x - t) < 1e-6) break;
+    if (x < t) lo = u;
+    else hi = u;
+    u = (lo + hi) / 2;
+  }
+  return curveY(u);
+}
+function sortedChannel(channel) {
+  return [...channel].sort((a, b) => a.time - b.time);
+}
+function valueAt(channel, clipTime) {
+  const points = sortedChannel(channel);
+  if (points.length === 0) return 0;
+  if (clipTime <= points[0].time) return points[0].value;
+  const last = points[points.length - 1];
+  if (clipTime >= last.time) return last.value;
+  let i = 0;
+  while (i < points.length - 1 && points[i + 1].time <= clipTime) i++;
+  const a = points[i];
+  const b = points[i + 1];
+  const span = b.time - a.time;
+  if (span <= 0) return b.value;
+  const eased = bezierEasing((clipTime - a.time) / span, controlPoints(b.easing));
+  return a.value + (b.value - a.value) * eased;
+}
+function isAnimated(animate, param) {
+  const channel = animate?.[param];
+  return !!channel && channel.length >= 2;
+}
+function retimeChannel(channel, headDelta, newDuration) {
+  return sortedChannel(channel).map((k) => ({ ...k, time: k.time - headDelta })).filter((k) => k.time >= 0 && k.time <= newDuration);
+}
+
+// ../composition/src/timeline/resolve.ts
+var MIN_RESIDUE_SECONDS = 0.04;
+function trimForSubRange(clip, newStartTime, newDuration) {
+  const source = clip.source;
+  if (source.kind !== "media" || !source.trim) return void 0;
+  const rate = source.playbackRate ?? 1;
+  const headDelta = (newStartTime - clip.startTime) * rate;
+  const start = source.trim.start + headDelta;
+  const end = start + newDuration * rate;
+  const clampedStart = Math.max(source.trim.start, start);
+  const clampedEnd = Math.min(source.trim.end, end);
+  if (!(clampedEnd > clampedStart)) return void 0;
+  return { ...source, trim: { ...source.trim, start: clampedStart, end: clampedEnd } };
+}
+function animateForSubRange(clip, newStartTime, newDuration) {
+  if (!clip.animate) return void 0;
+  const headDelta = newStartTime - clip.startTime;
+  const out = {};
+  for (const [param, channel] of Object.entries(clip.animate)) {
+    if (!channel) continue;
+    const retimed = retimeChannel(channel, headDelta, newDuration);
+    if (retimed.length >= 2) out[param] = retimed;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function resolveOverlaps(args) {
+  const { track, trackKind, span, policy, clipsById, newClipId } = args;
+  const collisions = collidingClips(track, span);
+  if (collisions.length === 0) return { ops: [], refusals: [] };
+  if (policy === "refuse") {
+    return {
+      ops: [],
+      refusals: [{ reason: "occupied-and-unresolvable" }]
+    };
+  }
+  const ops = [];
+  const refusals = [];
+  const spanEnd = span.startTime + span.duration;
+  for (const collision of collisions) {
+    const clip = clipsById.get(collision.id);
+    if (!clip) {
+      refusals.push({ reason: "clip-not-found", entity: { kind: "clip", clipId: collision.id } });
+      continue;
+    }
+    const clipEnd = clip.startTime + clip.duration;
+    switch (classifyOverlap(span, clip)) {
+      case "covers":
+        ops.push({ op: "removeClip", clipId: clip.id });
+        break;
+      case "trims-head": {
+        const newStart = spanEnd;
+        const newDuration = clipEnd - newStart;
+        if (newDuration < MIN_RESIDUE_SECONDS) {
+          ops.push({ op: "removeClip", clipId: clip.id });
+          break;
+        }
+        ops.push({
+          op: "updateClip",
+          clipId: clip.id,
+          trackKind,
+          patch: {
+            startTime: newStart,
+            duration: newDuration,
+            source: trimForSubRange(clip, newStart, newDuration),
+            animate: animateForSubRange(clip, newStart, newDuration)
+          }
+        });
+        break;
+      }
+      case "trims-tail": {
+        const newDuration = span.startTime - clip.startTime;
+        if (newDuration < MIN_RESIDUE_SECONDS) {
+          ops.push({ op: "removeClip", clipId: clip.id });
+          break;
+        }
+        ops.push({
+          op: "updateClip",
+          clipId: clip.id,
+          trackKind,
+          patch: {
+            duration: newDuration,
+            source: trimForSubRange(clip, clip.startTime, newDuration),
+            animate: animateForSubRange(clip, clip.startTime, newDuration)
+          }
+        });
+        break;
+      }
+      case "engulfed-by": {
+        const headDuration = span.startTime - clip.startTime;
+        const tailStart = spanEnd;
+        const tailDuration = clipEnd - tailStart;
+        const keepHead = headDuration >= MIN_RESIDUE_SECONDS;
+        const keepTail = tailDuration >= MIN_RESIDUE_SECONDS;
+        if (!keepHead && !keepTail) {
+          ops.push({ op: "removeClip", clipId: clip.id });
+          break;
+        }
+        if (keepHead) {
+          ops.push({
+            op: "updateClip",
+            clipId: clip.id,
+            trackKind,
+            patch: {
+              duration: headDuration,
+              source: trimForSubRange(clip, clip.startTime, headDuration),
+              animate: animateForSubRange(clip, clip.startTime, headDuration)
+            }
+          });
+        } else {
+          ops.push({ op: "removeClip", clipId: clip.id });
+        }
+        if (keepTail) {
+          const tailSource = trimForSubRange(clip, tailStart, tailDuration) ?? clip.source;
+          ops.push({
+            op: "insertClip",
+            trackId: track.id,
+            clip: {
+              ...clip,
+              id: newClipId(),
+              startTime: tailStart,
+              duration: tailDuration,
+              source: tailSource,
+              ...animateForSubRange(clip, tailStart, tailDuration) ? { animate: animateForSubRange(clip, tailStart, tailDuration) } : {}
+            }
+          });
+        }
+        break;
+      }
+    }
+  }
+  return { ops, refusals };
+}
+
+// ../composition/src/timeline/compound.ts
+var MAX_COMPOUND_DEPTH = 4;
+function hasCompoundClips(composition) {
+  for (const track of composition.tracks) {
+    for (const item of track.contents) {
+      if ("source" in item && item.source.kind === "composition") return true;
+    }
+  }
+  return false;
+}
+function flattenCompoundClips(composition, resolve) {
+  return flatten(composition, resolve, [], 0);
+}
+function flatten(composition, resolve, path, depth) {
+  if (!hasCompoundClips(composition)) return composition;
+  if (depth >= MAX_COMPOUND_DEPTH) {
+    throw new InvariantError({
+      code: "compound_depth_exceeded",
+      message: `compound clips nest deeper than ${MAX_COMPOUND_DEPTH} (path: ${path.join(" \u2192 ") || "(root)"}) \u2014 flattening refused`,
+      details: { path, maxDepth: MAX_COMPOUND_DEPTH }
+    });
+  }
+  const outTracks = [];
+  for (const track of composition.tracks) {
+    const kept = [];
+    const minted = [];
+    for (const item of track.contents) {
+      if (!("source" in item) || item.source.kind !== "composition") {
+        kept.push(item);
+        continue;
+      }
+      const compound = item;
+      const source = compound.source;
+      if (path.includes(source.compositionId)) {
+        throw new InvariantError({
+          code: "compound_cycle",
+          message: `composition "${source.compositionId}" embeds itself (${[...path, source.compositionId].join(" \u2192 ")}) \u2014 there is no finite flattening`,
+          details: { cycle: [...path, source.compositionId] }
+        });
+      }
+      const child = resolve(source.compositionId);
+      if (!child) {
+        throw new InvariantError({
+          code: "compound_unresolved",
+          message: `clip "${compound.id}" embeds composition "${source.compositionId}", which the caller could not resolve \u2014 rendering without it would ship a deliverable missing a sequence`,
+          details: { clipId: compound.id, compositionId: source.compositionId }
+        });
+      }
+      const flatChild = flatten(child, resolve, [...path, source.compositionId], depth + 1);
+      const projected = projectChild(flatChild, compound, source);
+      minted.push(
+        ...track.enabled === false ? projected.map((t) => ({ ...t, enabled: false })) : projected
+      );
+    }
+    outTracks.push({ ...track, contents: kept });
+    outTracks.push(...minted);
+  }
+  return { ...composition, tracks: outTracks };
+}
+function projectChild(child, compound, source) {
+  const windowStart = source.trim?.start ?? 0;
+  const windowEnd = Math.min(
+    source.trim?.end ?? Number.POSITIVE_INFINITY,
+    windowStart + compound.duration
+  );
+  const out = [];
+  for (const track of child.tracks) {
+    const contents = [];
+    for (const item of track.contents) {
+      if (!("source" in item)) continue;
+      const clip = item;
+      const clipEnd = clip.startTime + clip.duration;
+      const start = Math.max(clip.startTime, windowStart);
+      const end = Math.min(clipEnd, windowEnd);
+      if (end - start <= 1e-6) continue;
+      const headDelta = start - clip.startTime;
+      const duration = end - start;
+      const projected = {
+        ...clip,
+        id: `${compound.id}:${clip.id}`,
+        startTime: compound.startTime + (start - windowStart),
+        duration,
+        source: windowedSource(clip, headDelta, duration),
+        ...clip.animate ? { animate: windowedAnimate(clip, headDelta, duration) } : {},
+        // A child's link group must not merge with an identically-named one in
+        // the host or a sibling instance — scope it like the ids.
+        ...clip.linkGroupId ? { linkGroupId: `${compound.id}:${clip.linkGroupId}` } : {}
+      };
+      contents.push(projected);
+    }
+    if (contents.length > 0) {
+      out.push({
+        ...track,
+        id: `${compound.id}:${track.id}`,
+        contents
+      });
+    }
+  }
+  return out;
+}
+function windowedSource(clip, headDelta, duration) {
+  const source = clip.source;
+  if (source.kind !== "media" || !source.trim) return source;
+  const rate = source.playbackRate ?? 1;
+  const start = source.trim.start + headDelta * rate;
+  return { ...source, trim: { start, end: start + duration * rate } };
+}
+function windowedAnimate(clip, headDelta, duration) {
+  if (!clip.animate) return void 0;
+  const out = {};
+  for (const [param, channel] of Object.entries(clip.animate)) {
+    if (!channel) continue;
+    const retimed = retimeChannel(channel, headDelta, duration);
+    if (retimed.length >= 2) out[param] = retimed;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+// ../composition/src/timeline/trims.ts
+var MIN_SECONDS = 0.04;
+function contextFor(composition, clipId) {
+  for (const track of composition.tracks) {
+    const clips = track.contents.filter((c) => "source" in c);
+    const ordered = [...clips].sort((a, b) => a.startTime - b.startTime);
+    const index = ordered.findIndex((c) => c.id === clipId);
+    if (index >= 0) {
+      return { trackKind: track.kind, ordered, index, clip: ordered[index] };
+    }
+  }
+  return null;
+}
+function trimOf(clip) {
+  const source = clip.source;
+  if (source.kind !== "media" || !source.trim) return null;
+  return { start: source.trim.start, end: source.trim.end, rate: source.playbackRate ?? 1 };
+}
+function planSlip(composition, clipId, deltaSeconds, sourceDuration) {
+  const ctx = contextFor(composition, clipId);
+  if (!ctx) return null;
+  const trim = trimOf(ctx.clip);
+  if (!trim) return null;
+  const shift = deltaSeconds * trim.rate;
+  const start = trim.start + shift;
+  const end = trim.end + shift;
+  if (start < 0 || end > sourceDuration) return null;
+  if (Math.abs(shift) < 1e-6) return null;
+  const plan = emptyPlan("Slip clip");
+  const source = ctx.clip.source;
+  plan.ops.push({
+    op: "updateClip",
+    clipId,
+    trackKind: ctx.trackKind,
+    patch: {
+      // startTime and duration are DELIBERATELY absent: that is what makes this
+      // a slip rather than a move.
+      source: { ...source, trim: { ...source.trim, start, end } }
+    }
+  });
+  for (const partnerId of linkPartners(composition, clipId)) {
+    const partnerCtx = contextFor(composition, partnerId);
+    if (!partnerCtx) return null;
+    const partnerTrim = trimOf(partnerCtx.clip);
+    if (!partnerTrim) return null;
+    const pShift = deltaSeconds * partnerTrim.rate;
+    const pStart = partnerTrim.start + pShift;
+    const pEnd = partnerTrim.end + pShift;
+    if (pStart < 0 || pEnd > sourceDuration) return null;
+    const pSource = partnerCtx.clip.source;
+    plan.ops.push({
+      op: "updateClip",
+      clipId: partnerId,
+      trackKind: partnerCtx.trackKind,
+      patch: {
+        source: {
+          ...pSource,
+          trim: { ...pSource.trim, start: pStart, end: pEnd }
+        }
+      }
+    });
+  }
+  plan.resultingSelection = [{ kind: "clip", clipId }];
+  return plan;
+}
+function planRoll(composition, clipId, side, deltaSeconds, sourceDurations) {
+  const ctx = contextFor(composition, clipId);
+  if (!ctx) return null;
+  if (linkPartners(composition, clipId).length > 0) return null;
+  const neighbour = side === "left" ? ctx.ordered[ctx.index - 1] : ctx.ordered[ctx.index + 1];
+  if (!neighbour) return null;
+  const seamOk = side === "left" ? Math.abs(neighbour.startTime + neighbour.duration - ctx.clip.startTime) < 1e-6 : Math.abs(ctx.clip.startTime + ctx.clip.duration - neighbour.startTime) < 1e-6;
+  if (!seamOk) return null;
+  const ops = [];
+  const clipPatch = {};
+  const neighbourPatch = {};
+  if (side === "left") {
+    const clipStart = ctx.clip.startTime + deltaSeconds;
+    const clipDuration = ctx.clip.duration - deltaSeconds;
+    const neighbourDuration = neighbour.duration + deltaSeconds;
+    if (clipDuration < MIN_SECONDS || neighbourDuration < MIN_SECONDS) return null;
+    if (!windowCovers(ctx.clip, deltaSeconds, clipDuration, sourceDurations, "head")) return null;
+    if (!windowCovers(neighbour, 0, neighbourDuration, sourceDurations, "tail")) return null;
+    Object.assign(clipPatch, {
+      startTime: clipStart,
+      duration: clipDuration,
+      ...subRange(ctx.clip, deltaSeconds, clipDuration)
+    });
+    Object.assign(neighbourPatch, {
+      duration: neighbourDuration,
+      ...subRange(neighbour, 0, neighbourDuration)
+    });
+  } else {
+    const clipDuration = ctx.clip.duration + deltaSeconds;
+    const neighbourStart = neighbour.startTime + deltaSeconds;
+    const neighbourDuration = neighbour.duration - deltaSeconds;
+    if (clipDuration < MIN_SECONDS || neighbourDuration < MIN_SECONDS) return null;
+    if (!windowCovers(ctx.clip, 0, clipDuration, sourceDurations, "tail")) return null;
+    if (!windowCovers(neighbour, deltaSeconds, neighbourDuration, sourceDurations, "head")) return null;
+    Object.assign(clipPatch, {
+      duration: clipDuration,
+      ...subRange(ctx.clip, 0, clipDuration)
+    });
+    Object.assign(neighbourPatch, {
+      startTime: neighbourStart,
+      duration: neighbourDuration,
+      ...subRange(neighbour, deltaSeconds, neighbourDuration)
+    });
+  }
+  ops.push({ op: "updateClip", clipId, trackKind: ctx.trackKind, patch: clipPatch });
+  ops.push({
+    op: "updateClip",
+    clipId: neighbour.id,
+    trackKind: ctx.trackKind,
+    patch: neighbourPatch
+  });
+  const plan = emptyPlan("Roll edit");
+  plan.ops = ops;
+  plan.resultingSelection = [{ kind: "clip", clipId }];
+  return plan;
+}
+function planSlide(composition, clipId, deltaSeconds, sourceDurations) {
+  const ctx = contextFor(composition, clipId);
+  if (!ctx) return null;
+  if (linkPartners(composition, clipId).length > 0) return null;
+  const before = ctx.ordered[ctx.index - 1];
+  const after = ctx.ordered[ctx.index + 1];
+  if (!before || !after) return null;
+  if (Math.abs(deltaSeconds) < 1e-6) return null;
+  const beforeDuration = before.duration + deltaSeconds;
+  const afterStart = after.startTime + deltaSeconds;
+  const afterDuration = after.duration - deltaSeconds;
+  if (beforeDuration < MIN_SECONDS || afterDuration < MIN_SECONDS) return null;
+  if (!windowCovers(before, 0, beforeDuration, sourceDurations, "tail")) return null;
+  if (!windowCovers(after, deltaSeconds, afterDuration, sourceDurations, "head")) return null;
+  const plan = emptyPlan("Slide clip");
+  plan.ops = [
+    {
+      op: "updateClip",
+      clipId: before.id,
+      trackKind: ctx.trackKind,
+      patch: { duration: beforeDuration, ...subRange(before, 0, beforeDuration) }
+    },
+    {
+      op: "updateClip",
+      clipId,
+      trackKind: ctx.trackKind,
+      // Content untouched — only where it sits.
+      patch: { startTime: ctx.clip.startTime + deltaSeconds }
+    },
+    {
+      op: "updateClip",
+      clipId: after.id,
+      trackKind: ctx.trackKind,
+      patch: {
+        startTime: afterStart,
+        duration: afterDuration,
+        ...subRange(after, deltaSeconds, afterDuration)
+      }
+    }
+  ];
+  plan.resultingSelection = [{ kind: "clip", clipId }];
+  return plan;
+}
+function windowCovers(clip, headDelta, newDuration, sourceDurations, grow) {
+  const trim = trimOf(clip);
+  if (!trim) return true;
+  const start = trim.start + headDelta * trim.rate;
+  const end = start + newDuration * trim.rate;
+  if (start < 0) return false;
+  const source = clip.source;
+  const total = source.kind === "media" ? sourceDurations[source.mediaId] : void 0;
+  if (grow === "tail" && total !== void 0 && end > total + 1e-6) return false;
+  return end > start;
+}
+function subRange(clip, headDelta, newDuration) {
+  const out = {};
+  const trim = trimOf(clip);
+  if (trim) {
+    const start = trim.start + headDelta * trim.rate;
+    out.source = {
+      ...clip.source,
+      trim: { start, end: start + newDuration * trim.rate }
+    };
+  }
+  if (clip.animate) {
+    const animate = {};
+    for (const [param, channel] of Object.entries(clip.animate)) {
+      if (!channel) continue;
+      const retimed = retimeChannel(channel, headDelta, newDuration);
+      if (retimed.length >= 2) animate[param] = retimed;
+    }
+    if (Object.keys(animate).length > 0) out.animate = animate;
+  }
+  return out;
+}
+
+// ../composition/src/timeline/intent.ts
+function projectTracks(composition) {
+  return composition.tracks.map((t) => ({
+    id: t.id,
+    kind: t.kind,
+    contents: t.contents.filter((c) => "source" in c && !!c.id).map((c) => ({ id: c.id, startTime: c.startTime, duration: c.duration }))
+  }));
+}
+function indexClips(composition) {
+  const clipsById = /* @__PURE__ */ new Map();
+  const trackIdByClipId = /* @__PURE__ */ new Map();
+  for (const track of composition.tracks) {
+    for (const item of track.contents) {
+      if (!("source" in item)) continue;
+      const clip = item;
+      clipsById.set(clip.id, clip);
+      trackIdByClipId.set(clip.id, track.id);
+    }
+  }
+  return { clipsById, trackIdByClipId };
+}
+var sourceKindOf = (clip) => clip.source.kind;
+function applyOpsToOccupancy(track, ops) {
+  for (const op of ops) {
+    switch (op.op) {
+      case "removeClip":
+        track.contents = track.contents.filter((c) => c.id !== op.clipId);
+        break;
+      case "updateClip": {
+        const row = track.contents.find((c) => c.id === op.clipId);
+        if (!row) break;
+        if (op.patch.startTime != null) row.startTime = op.patch.startTime;
+        if (op.patch.duration != null) row.duration = op.patch.duration;
+        break;
+      }
+      case "insertClip":
+        track.contents.push({
+          id: op.clip.id,
+          startTime: op.clip.startTime,
+          duration: op.clip.duration
+        });
+        break;
+      default:
+        break;
+    }
+  }
+}
+function expandMovesToLinkGroups(composition, moves, clipsById) {
+  const named = new Set(moves.map((m) => m.clipId));
+  const out = [...moves];
+  for (const move of moves) {
+    const clip = clipsById.get(move.clipId);
+    if (!clip?.linkGroupId) continue;
+    const delta = move.startTime - clip.startTime;
+    for (const partnerId of expandClipIdsToLinkGroups(composition, [move.clipId])) {
+      if (named.has(partnerId)) continue;
+      const partner = clipsById.get(partnerId);
+      if (!partner) continue;
+      named.add(partnerId);
+      out.push({
+        clipId: partnerId,
+        // The partner keeps its own lane — linking couples TIME, not track.
+        toTrackId: trackIdOf(composition, partnerId) ?? move.toTrackId,
+        startTime: Math.max(0, partner.startTime + delta),
+        duration: partner.duration
+      });
+    }
+  }
+  return out;
+}
+function trackIdOf(composition, clipId) {
+  for (const track of composition.tracks) {
+    for (const item of track.contents) {
+      if ("source" in item && item.id === clipId) return track.id;
+    }
+  }
+  return null;
+}
+function resolveMoveIntent(args) {
+  const { composition, intent, newClipId } = args;
+  const policy = intent.policy ?? "resolve";
+  const plan = emptyPlan(intent.label ?? (intent.moves.length > 1 ? "Move clips" : "Move clip"));
+  const { clipsById, trackIdByClipId } = indexClips(composition);
+  const tracks = projectTracks(composition);
+  const withPartners = expandMovesToLinkGroups(composition, intent.moves, clipsById);
+  const movingIds = withPartners.map((m) => m.clipId);
+  for (const track of tracks) {
+    track.contents = track.contents.filter((c) => !movingIds.includes(c.id));
+  }
+  const selection = [];
+  for (const move of withPartners) {
+    const clip = clipsById.get(move.clipId);
+    if (!clip) {
+      plan.refusals.push({ reason: "clip-not-found", entity: { kind: "clip", clipId: move.clipId } });
+      continue;
+    }
+    if (!(move.duration > 0)) {
+      plan.refusals.push({ reason: "zero-duration", entity: { kind: "clip", clipId: move.clipId } });
+      continue;
+    }
+    const startTime = Math.max(0, move.startTime);
+    const span = { startTime, duration: move.duration, excludeClipIds: movingIds };
+    const placement = resolvePlacement({
+      tracks,
+      sourceKind: sourceKindOf(clip),
+      spans: [span],
+      strategy: { type: "explicit", trackId: move.toTrackId },
+      allowOccupied: true
+    });
+    if (placement.kind === "refused") {
+      plan.refusals.push({
+        reason: placement.reason,
+        entity: { kind: "clip", clipId: move.clipId }
+      });
+      continue;
+    }
+    if (placement.kind === "newTrack") {
+      plan.refusals.push({
+        reason: "track-not-found",
+        entity: { kind: "clip", clipId: move.clipId }
+      });
+      continue;
+    }
+    const target = tracks[placement.trackIndex];
+    const trackKind = placement.trackKind;
+    const resolution = resolveOverlaps({
+      track: target,
+      trackKind,
+      span,
+      policy,
+      clipsById,
+      newClipId
+    });
+    if (resolution.refusals.length > 0) {
+      plan.refusals.push(...resolution.refusals);
+      continue;
+    }
+    plan.ops.push(...resolution.ops);
+    applyOpsToOccupancy(target, resolution.ops);
+    const fromTrackId = trackIdByClipId.get(move.clipId);
+    if (fromTrackId !== placement.trackId) {
+      plan.ops.push({
+        op: "moveToTrack",
+        clipId: move.clipId,
+        toTrackId: placement.trackId,
+        startTime
+      });
+      if (Math.abs(move.duration - clip.duration) > 1e-6) {
+        plan.ops.push({
+          op: "updateClip",
+          clipId: move.clipId,
+          trackKind,
+          patch: { duration: move.duration }
+        });
+      }
+    } else {
+      plan.ops.push({
+        op: "updateClip",
+        clipId: move.clipId,
+        trackKind,
+        patch: { startTime, duration: move.duration }
+      });
+    }
+    target.contents.push({ id: move.clipId, startTime, duration: move.duration });
+    selection.push({ kind: "clip", clipId: move.clipId });
+  }
+  plan.resultingSelection = selection;
+  return plan;
+}
+function planLeavesOverlaps(composition) {
+  const found = [];
+  for (const track of projectTracks(composition)) {
+    for (const row of track.contents) {
+      const others = collidingClips(track, {
+        startTime: row.startTime,
+        duration: row.duration,
+        excludeClipIds: [row.id]
+      });
+      for (const other of others) {
+        if (row.id < other.id) found.push({ trackId: track.id, clipIds: [row.id, other.id] });
+      }
+    }
+  }
+  return found;
+}
+
+export {
+  spansOverlap,
+  spansFit,
+  collidingClips,
+  classifyOverlap,
+  entityKey,
+  refusalText,
+  emptyPlan,
+  planIsNoop,
+  trackKindForSource,
+  resolvePlacement,
+  EASING_CONTROL_POINTS,
+  bezierEasing,
+  sortedChannel,
+  valueAt,
+  isAnimated,
+  retimeChannel,
+  MIN_RESIDUE_SECONDS,
+  trimForSubRange,
+  resolveOverlaps,
+  MAX_COMPOUND_DEPTH,
+  hasCompoundClips,
+  flattenCompoundClips,
+  planSlip,
+  planRoll,
+  planSlide,
+  resolveMoveIntent,
+  planLeavesOverlaps
+};