@cueframe/kernel 0.0.1

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

@@ -0,0 +1,121 @@
+/** 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.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A/V LINK GROUPS.
+ *
+ * `linkGroupId` on a clip says only "these belong together". Everything a link
+ * MEANS lives here, and it lives in the kernel because both lanes edit
+ * compositions: a link rule the desktop honours and the cloud director does not
+ * is a composition the two lanes disagree about.
+ *
+ * The rule is one sentence: an operation that names one member of a group names
+ * all of them. Expansion therefore happens BETWEEN selection and every verb —
+ * not inside each verb — because a verb that has to remember to expand is a
+ * verb that will eventually forget, and the failure is silent: picture moves,
+ * sound does not, and the user discovers it at playback.
+ */
+import type { Composition } from "../validators/composition.js";
+import type { TimelineEntity } from "./plan.js";
+/** Every clip id sharing a group with any of `clipIds`, including the inputs. */
+export declare function expandClipIdsToLinkGroups(composition: Pick<Composition, "tracks">, clipIds: Iterable<string>): string[];
+/**
+ * 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 declare function expandToLinkGroup(composition: Pick<Composition, "tracks">, entities: readonly TimelineEntity[]): TimelineEntity[];
+/** The other members of `clipId`'s group. Empty when it is unlinked. */
+export declare function linkPartners(composition: Pick<Composition, "tracks">, clipId: string): string[];
+/**
+ * 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 declare function makeLinkGroup(clipIds: readonly string[], newGroupId: () => string): {
+    linkGroupId: string;
+    clipIds: readonly string[];
+} | null;

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

@@ -0,0 +1,59 @@
+/** 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.d.ts

@@ -0,0 +1,72 @@
+/**
+ * WHAT A LANE IS ALREADY HOLDING.
+ *
+ * This is the half of placement that has nothing to do with pixels, gestures or
+ * React — "does this span collide with what is already on that track" — and it
+ * lives in the kernel for the same reason `clipPlacement.ts` does: both lanes
+ * write compositions, so a rule implemented in one lane is a rule the other
+ * lane does not have.
+ *
+ * The occupancy test itself was already correct in the desktop
+ * (`components/Timeline/fabric/placement.ts:spansFit`, half-open intervals so
+ * abutting clips are not a collision, tested). What was missing is that the
+ * clip-MOVE path never called it — `handlers/drag.ts` resolved a target track by
+ * raw Y hit-test and committed, so dragging a clip onto an occupied lane wrote
+ * an overlap that nothing downstream refused
+ * (brain: Issues/2026-08-23-clip-move-writes-overlaps-and-the-guard-never-runs).
+ */
+import type { Track } from "../validators/composition.js";
+export type TrackKind = Track["kind"];
+/** A clip's occupied span. Structurally typed so callers can pass any row shape. */
+export interface PlacementSpan {
+    startTime: number;
+    duration: number;
+    /** Clips that must not count as collisions — typically the ones being moved. */
+    excludeClipIds?: readonly string[];
+}
+/** The minimum a track has to expose to be reasoned about. */
+export interface PlacementTrack {
+    id: string;
+    kind: TrackKind;
+    contents: ReadonlyArray<{
+        id: string;
+        startTime: number;
+        duration: number;
+    }>;
+}
+/** Half-open overlap: `[aStart, aEnd)` against `[bStart, bEnd)`. */
+export declare function spansOverlap(aStart: number, aDuration: number, bStart: number, bDuration: number): boolean;
+/** A span fits when it overlaps nothing already on the track. */
+export declare function spansFit(track: PlacementTrack, spans: readonly PlacementSpan[]): boolean;
+/**
+ * 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 declare function collidingClips(track: PlacementTrack, span: PlacementSpan): Array<{
+    id: string;
+    startTime: number;
+    duration: number;
+}>;
+/**
+ * How an incoming span sits against one existing clip. Named because the
+ * resolution for each is different, and because "overlap" as a single word is
+ * what let a real defect hide: the drag path had no concept of degree.
+ */
+export type OverlapRelation = 
+/** The incoming span covers the existing clip entirely. */
+"covers"
+/** The incoming span starts inside and runs past the end. */
+ | "trims-tail"
+/** The incoming span starts before and ends inside. */
+ | "trims-head"
+/** The incoming span sits strictly inside the existing clip. */
+ | "engulfed-by";
+export declare function classifyOverlap(span: {
+    startTime: number;
+    duration: number;
+}, clip: {
+    startTime: number;
+    duration: number;
+}): OverlapRelation;

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

@@ -0,0 +1,36 @@
+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.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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.js";
+import type { PlacementSpan, PlacementTrack, TrackKind } from "./occupancy.js";
+import type { PlacementRefusal } from "./plan.js";
+export type SourceKind = Parameters<typeof isSourceKindCompatible>[1];
+/** How to choose a track. */
+export type PlacementStrategy = 
+/** The caller already knows the track (drop directly onto a lane). */
+{
+    type: "explicit";
+    trackId: string;
+}
+/** First compatible track with room; otherwise a new one. */
+ | {
+    type: "firstAvailable";
+}
+/**
+ * Hovering a lane boundary. `hoverDirection` is which side of the hovered
+ * track the cursor sits on; a new track is inserted there when the hovered
+ * one cannot take the span.
+ */
+ | {
+    type: "preferIndex";
+    trackIndex: number;
+    hoverDirection: "above" | "below";
+}
+/** Always mint a lane — the explicit "give it its own track" gesture. */
+ | {
+    type: "alwaysNew";
+    position: "highest" | "default";
+};
+export type PlacementResult = {
+    kind: "existingTrack";
+    trackId: string;
+    trackIndex: number;
+    trackKind: TrackKind;
+}
+/** `insertIndex` is the index the new track takes in the track array. */
+ | {
+    kind: "newTrack";
+    insertIndex: number;
+    trackKind: TrackKind;
+} | {
+    kind: "refused";
+    reason: PlacementRefusal;
+};
+/** The track kind a source belongs on, or null when nothing accepts it. */
+export declare function trackKindForSource(sourceKind: SourceKind): TrackKind | null;
+export declare function resolvePlacement(args: {
+    tracks: readonly PlacementTrack[];
+    sourceKind: SourceKind;
+    /**
+     * The track FAMILY this clip belongs to, when the caller knows more than the
+     * source kind can say. `sourceKind: 'media'` is compatible with video, audio
+     * AND image tracks, so a pool drop routed by source kind alone lands every
+     * still and every song on a VIDEO track (`trackKindForSource` returns the
+     * first compatible kind). The renderer derives its element from `track.kind`,
+     * so that mis-route is wrong pixels, not a cosmetic. When set, this REPLACES
+     * the compatibility predicate: only tracks of exactly this kind take the
+     * clip, and a minted track is this kind.
+     */
+    trackKind?: TrackKind;
+    spans: readonly PlacementSpan[];
+    strategy: PlacementStrategy;
+    /**
+     * When true, a compatible-but-occupied lane is still chosen — the caller
+     * intends to resolve the collision rather than route around it. The drop path
+     * routes around (it mints a sibling lane); the drag path resolves, because a
+     * user dragging a clip onto a busy lane means "put it there", not "put it
+     * somewhere near there".
+     */
+    allowOccupied?: boolean;
+}): PlacementResult;

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

@@ -0,0 +1,74 @@
+/**
+ * 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,
+            };
+    }
+}

package/dist/_members/composition/timeline/plan.d.ts

@@ -0,0 +1,109 @@
+/**
+ * THE PLAN VALUE.
+ *
+ * Every timeline gesture — drag, trim, drop, razor, paste — and every agent op
+ * resolves to one of these BEFORE anything mutates. The point is not elegance;
+ * it is that there stops being a code path from a pointer event to a clip write
+ * that skips the resolver, because the applier only accepts a plan and only the
+ * resolver produces one.
+ *
+ * The ops are deliberately shaped to the store verbs that already exist
+ * (`moveClipToTrack`, `updateClip`/`updateAudioClip`/`updateOverlay`,
+ * `removeClip`, `addClipToTrack`, `addTrack`) rather than to an abstract edit
+ * language. A plan that cannot be applied with the verbs we have is a plan that
+ * needs an interpreter, and an interpreter is how a second implementation of
+ * the composition rules gets written by accident.
+ */
+import type { TimelineClip } from "../validators/composition.js";
+import type { TrackKind } from "./occupancy.js";
+/**
+ * Anything on the timeline that can be addressed. Clips are not the only
+ * selectable thing once keyframes and transitions exist, and giving sub-items
+ * the same addressing as clips is what makes one selection model serve all of
+ * them.
+ */
+export type TimelineEntity = {
+    kind: "clip";
+    clipId: string;
+} | {
+    kind: "keyframe";
+    clipId: string;
+    param: string;
+    index: number;
+} | {
+    kind: "transition";
+    clipId: string;
+} | {
+    kind: "marker";
+    markerId: string;
+};
+export declare const entityKey: (e: TimelineEntity) => string;
+/** Every way a placement can fail, named. */
+export type PlacementRefusal = "incompatible-track" | "track-not-found" | "no-compatible-track-kind" | "clip-not-found" | "occupied-and-unresolvable" | "zero-duration";
+export declare function refusalText(reason: PlacementRefusal): string;
+/** A refusal, and which entity it is about, so the UI can point at it. */
+export interface RefusedPlacement {
+    reason: PlacementRefusal;
+    entity?: TimelineEntity;
+}
+export interface ClipPatch {
+    startTime?: number;
+    duration?: number;
+    source?: TimelineClip["source"];
+    /**
+     * Re-timed keyframe channels. Keyframe time is CLIP-RELATIVE, which survives
+     * a move for free — but a resolution that eats a clip's HEAD moves its origin,
+     * so every channel on it has to shift by the same amount or the motion the
+     * author placed drifts away from the frames it was placed against.
+     */
+    animate?: TimelineClip["animate"];
+}
+export type TimelinePlanOp = 
+/** `moveClipToTrack(clipId, toTrackId, startTime)` */
+{
+    op: "moveToTrack";
+    clipId: string;
+    toTrackId: string;
+    startTime: number;
+}
+/** The kind-appropriate `update*Clip(clipId, patch)` */
+ | {
+    op: "updateClip";
+    clipId: string;
+    trackKind: TrackKind;
+    patch: ClipPatch;
+}
+/** `removeClip(clipId)` */
+ | {
+    op: "removeClip";
+    clipId: string;
+}
+/** `addClipToTrack(trackId, clip)` — the tail half of a split */
+ | {
+    op: "insertClip";
+    trackId: string;
+    clip: TimelineClip;
+}
+/** `addTrack(kind, name, id)` then `reorderTracks` to land at `insertIndex` */
+ | {
+    op: "createTrack";
+    trackId: string;
+    kind: TrackKind;
+    insertIndex: number;
+};
+/**
+ * The whole outcome of a gesture. `resultingSelection` is part of the plan and
+ * not an afterthought: it is what the group-move path had no way to express, so
+ * a multi-clip move used to leave selection wherever Fabric happened to put it,
+ * and undo restored a selection that no longer described the edit.
+ */
+export interface TimelinePlan {
+    ops: TimelinePlanOp[];
+    resultingSelection: TimelineEntity[];
+    refusals: RefusedPlacement[];
+    /** Human-readable transaction label — becomes the undo entry's name. */
+    label: string;
+}
+export declare const emptyPlan: (label: string) => TimelinePlan;
+/** A plan that changes nothing is not applied; the caller snaps the UI back. */
+export declare const planIsNoop: (plan: TimelinePlan) => boolean;

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

@@ -0,0 +1,31 @@
+export const 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}`;
+    }
+};
+const 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",
+};
+export function refusalText(reason) {
+    return REFUSAL_TEXT[reason];
+}
+export const emptyPlan = (label) => ({
+    ops: [],
+    resultingSelection: [],
+    refusals: [],
+    label,
+});
+/** A plan that changes nothing is not applied; the caller snaps the UI back. */
+export const planIsNoop = (plan) => plan.ops.length === 0;