@cueframe/kernel 0.0.1 → 0.1.1

package/dist/_members/composition/timeline/compound.js

@@ -1,134 +0,0 @@
-import { InvariantError } from "../invariants/errors";
-import { retimeChannel } from "./keyframes";
-export const MAX_COMPOUND_DEPTH = 4;
-/** Does this composition contain any compound clip at all? Cheap gate. */
-export 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;
-}
-export 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(" → ") || "(root)"}) — flattening refused`,
-            details: { path, maxDepth: MAX_COMPOUND_DEPTH },
-        });
-    }
-    const outTracks = [];
-    for (const track of composition.tracks) {
-        const kept = [];
-        /** Tracks minted from compound children on this host track, in order. */
-        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(" → ")}) — 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 — 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);
-            // Minted tracks inherit the HOST track's disabled state — a compound clip
-            // on a muted track must vanish with it, not outlive it on lanes of its
-            // own (review finding 2026-08-24).
-            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 };
-}
-/** The child's tracks, windowed and shifted into the host's time. */
-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; // outside the window
-            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;
-}
-/** The clip's source with its own window advanced by the flatten cut. */
-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 undefined;
-    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 : undefined;
-}

package/dist/_members/composition/timeline/index.js

@@ -1,9 +0,0 @@
-export * from "./occupancy";
-export * from "./plan";
-export * from "./placement";
-export * from "./resolve";
-export * from "./keyframes";
-export * from "./compound";
-export * from "./trims";
-export * from "./link";
-export * from "./intent";

package/dist/_members/composition/timeline/intent.js

@@ -1,228 +0,0 @@
-import { collidingClips } from "./occupancy";
-import { resolvePlacement } from "./placement";
-import { resolveOverlaps } from "./resolve";
-import { emptyPlan } from "./plan";
-import { expandClipIdsToLinkGroups } from "./link";
-/** Occupancy rows only — the full clip rows come from `clipsById`. */
-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 = new Map();
-    const trackIdByClipId = 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 };
-}
-/** `source.kind` is what compatibility is judged on, not the track family. */
-const sourceKindOf = (clip) => clip.source.kind;
-/** Keep the mutable occupancy in step with the ops we just emitted. */
-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;
-        }
-    }
-}
-/**
- * Every requested move, plus one per unrequested link partner shifted by the
- * same delta. A partner already named explicitly is not duplicated.
- */
-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;
-}
-export 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);
-    // A move that names one member of a link group moves the whole group, by the
-    // same delta. Selection expansion already covers the UI path; this covers the
-    // agent's, which names clip ids directly and never went through a selection.
-    const withPartners = expandMovesToLinkGroups(composition, intent.moves, clipsById);
-    const movingIds = withPartners.map((m) => m.clipId);
-    // Every moving clip leaves its lane before anything is placed, so a clip
-    // never collides with where it used to be — including the whole group, which
-    // is why this is done up front rather than per move.
-    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 };
-        // `allowOccupied` — a user dragging a clip onto a busy lane means "put it
-        // there and deal with what is in the way", not "find me somewhere near it".
-        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") {
-            // `explicit` + `allowOccupied` never mints a lane; a newTrack result here
-            // would mean the resolver changed under us. Refuse rather than invent one.
-            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);
-            // A move that cannot clear its landing zone is not applied at all — a
-            // partial group move is worse than none, because half a gesture is a
-            // state the user did not ask for and cannot name in undo.
-            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,
-            });
-            // `moveClipToTrack` preserves duration, so a gesture that also resized
-            // needs the geometry patch after the move.
-            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;
-}
-/**
- * The gate's read-only half: does this composition still satisfy the one rule
- * the move path exists to protect? Kept next to the resolver so a resolution
- * bug fails here rather than reaching the document.
- */
-export 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;
-}

package/dist/_members/composition/timeline/keyframes.js

@@ -1,121 +0,0 @@
-/** Named easings, as cubic-bezier control points. EXPORTED so the curve
- *  editor draws exactly what the interpolator evaluates — a UI restating these
- *  numbers is a curve that lies about the motion. */
-export const 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;
-}
-/**
- * y at x for a cubic-bezier easing curve, x ∈ [0,1].
- *
- * Newton-Raphson with a bisection fallback — the standard approach, and the
- * fallback matters: Newton diverges on the near-vertical segments that the
- * overshoot presets (a "pop") deliberately have.
- */
-export function bezierEasing(t, [x1, y1, x2, y2]) {
-    if (t <= 0)
-        return 0;
-    if (t >= 1)
-        return 1;
-    if (x1 === y1 && x2 === y2)
-        return t; // linear
-    const curveX = (u) => {
-        const v = 1 - u;
-        return 3 * v * v * u * x1 + 3 * v * u * u * x2 + u * u * u;
-    };
-    const curveY = (u) => {
-        const v = 1 - u;
-        return 3 * v * v * u * y1 + 3 * v * u * u * y2 + u * u * u;
-    };
-    const slopeX = (u) => {
-        const v = 1 - u;
-        return 3 * v * v * x1 + 6 * v * u * (x2 - x1) + 3 * u * u * (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);
-}
-/** Channel sorted by time. Authoring order is not guaranteed to be time order. */
-export function sortedChannel(channel) {
-    return [...channel].sort((a, b) => a.time - b.time);
-}
-/**
- * The channel's value at `clipTime` (seconds from the clip's start).
- *
- * Holds flat outside the channel's range rather than extrapolating — a value
- * invented beyond the last keyframe is a value nobody authored, and for
- * opacity or scale it is the difference between a clean hold and a fade to
- * something absurd.
- */
-export 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;
-    // The easing belongs to the keyframe being APPROACHED — "how do I arrive
-    // here" — which is the convention every timeline UI draws.
-    const eased = bezierEasing((clipTime - a.time) / span, controlPoints(b.easing));
-    return a.value + (b.value - a.value) * eased;
-}
-/** True when this param is animated on this clip. */
-export function isAnimated(animate, param) {
-    const channel = animate?.[param];
-    return !!channel && channel.length >= 2;
-}
-/**
- * Re-time a channel for a clip whose window moved.
- *
- * The ONE case clip-relative time does not survive for free: trimming the head
- * shifts every keyframe's origin. Keyframes that fall outside the new window
- * are dropped rather than clamped — clamping would silently stack several onto
- * the same instant, which is exactly the `varying_keyframe_duplicate_time`
- * violation the invariants refuse.
- */
-export function retimeChannel(channel, headDelta, newDuration) {
-    return sortedChannel(channel)
-        .map((k) => ({ ...k, time: k.time - headDelta }))
-        .filter((k) => k.time >= 0 && k.time <= newDuration);
-}

package/dist/_members/composition/timeline/link.js

@@ -1,59 +0,0 @@
-/** Every clip id sharing a group with any of `clipIds`, including the inputs. */
-export function expandClipIdsToLinkGroups(composition, clipIds) {
-    const seedIds = new Set(clipIds);
-    if (seedIds.size === 0)
-        return [];
-    const groupsWanted = new Set();
-    const all = [];
-    for (const track of composition.tracks) {
-        for (const item of track.contents) {
-            if (!("source" in item))
-                continue;
-            const clip = item;
-            all.push(clip);
-            if (seedIds.has(clip.id) && clip.linkGroupId)
-                groupsWanted.add(clip.linkGroupId);
-        }
-    }
-    const out = new Set(seedIds);
-    if (groupsWanted.size > 0) {
-        for (const clip of all) {
-            if (clip.linkGroupId && groupsWanted.has(clip.linkGroupId))
-                out.add(clip.id);
-        }
-    }
-    return [...out];
-}
-/**
- * Selection with every link partner pulled in.
- *
- * Non-clip entities pass through untouched — a keyframe is not linked to
- * anything by this mechanism, and silently widening it would be worse than not
- * handling it.
- */
-export function expandToLinkGroup(composition, entities) {
-    const clipIds = entities.filter((e) => e.kind === "clip").map((e) => e.clipId);
-    if (clipIds.length === 0)
-        return [...entities];
-    const expanded = expandClipIdsToLinkGroups(composition, clipIds);
-    const known = new Set(clipIds);
-    const out = [...entities];
-    for (const id of expanded) {
-        if (!known.has(id))
-            out.push({ kind: "clip", clipId: id });
-    }
-    return out;
-}
-/** The other members of `clipId`'s group. Empty when it is unlinked. */
-export function linkPartners(composition, clipId) {
-    return expandClipIdsToLinkGroups(composition, [clipId]).filter((id) => id !== clipId);
-}
-/**
- * Ids for a new group. Returned rather than assigned so the caller decides how
- * the clips get updated — the kernel never mutates a composition.
- */
-export function makeLinkGroup(clipIds, newGroupId) {
-    if (clipIds.length < 2)
-        return null;
-    return { linkGroupId: newGroupId(), clipIds };
-}

package/dist/_members/composition/timeline/occupancy.js

@@ -1,36 +0,0 @@
-const excluded = (span, id) => !!span.excludeClipIds && span.excludeClipIds.includes(id);
-/** Half-open overlap: `[aStart, aEnd)` against `[bStart, bEnd)`. */
-export function spansOverlap(aStart, aDuration, bStart, bDuration) {
-    return aStart < bStart + bDuration && aStart + aDuration > bStart;
-}
-/** A span fits when it overlaps nothing already on the track. */
-export function spansFit(track, spans) {
-    return spans.every((span) => collidingClips(track, span).length === 0);
-}
-/**
- * Everything on `track` that this span would sit on top of, in start order.
- * Returned rather than counted because the resolution strategies need to know
- * WHICH clips collide and HOW — a clip fully covered by the incoming span is a
- * different edit from one it merely clips the tail of.
- */
-export 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);
-}
-export 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";
-}

package/dist/_members/composition/timeline/placement.js

@@ -1,74 +0,0 @@
-/**
- * WHERE A SOURCE GOES.
- *
- * Hoisted from `cueframe/src/components/Timeline/fabric/placement.ts` (2026-08-23)
- * for the reason the module's own header predicted and the repo rule requires:
- * the cloud director writes compositions too, so a placement rule that lives in
- * the desktop is a rule the cloud does not have. This is now the single home.
- *
- * The vocabulary — strategy → resolve → a result that is either an existing
- * track or an instruction to mint one at an index — is unchanged. What changed
- * is that the DRAG path can reach it: previously the only caller was the media
- * drop path, so two of the four strategies had never been constructed by
- * production code at all.
- */
-import { isSourceKindCompatible } from "../invariants/tracks";
-import { spansFit } from "./occupancy";
-/** The track kind a source belongs on, or null when nothing accepts it. */
-export function trackKindForSource(sourceKind) {
-    const kinds = ["video", "audio", "image", "overlay", "effect"];
-    return kinds.find((k) => isSourceKindCompatible(k, sourceKind)) ?? null;
-}
-export 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)) {
-                // A compatible lane that is already occupied gets a sibling directly
-                // below it rather than silently pushing the drop elsewhere.
-                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,
-            };
-    }
-}