@cueframe/kernel 0.1.0 → 0.1.2

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

@@ -1,30 +1,10 @@
-/**
- * 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;
@@ -34,35 +14,14 @@ export interface PlacementTrack {
         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 type OverlapRelation = "covers" | "trims-tail" | "trims-head" | "engulfed-by";
 export declare function classifyOverlap(span: {
     startTime: number;
     duration: number;

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

@@ -1,44 +1,17 @@
-/**
- * WHERE A SOURCE GOES.
- *
- * Hoisted from `apps/studio/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). */
-{
+export type PlacementStrategy = {
     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";
 };
@@ -47,9 +20,7 @@ export type PlacementResult = {
     trackId: string;
     trackIndex: number;
     trackKind: TrackKind;
-}
-/** `insertIndex` is the index the new track takes in the track array. */
- | {
+} | {
     kind: "newTrack";
     insertIndex: number;
     trackKind: TrackKind;
@@ -57,30 +28,12 @@ export type PlacementResult = {
     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/plan.d.ts

@@ -1,27 +1,5 @@
-/**
- * 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;
@@ -38,10 +16,8 @@ export type TimelineEntity = {
     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;
@@ -50,60 +26,36 @@ 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)` */
-{
+export type TimelinePlanOp = {
     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/resolve.d.ts

@@ -1,55 +1,19 @@
-/**
- * MAKING ROOM.
- *
- * When something lands on top of something else, an editor has to do one of
- * four things, and the difference between them is the whole difference between
- * "the app is a video editor" and "the app is a rectangle arranger":
- *
- *   covers      → the buried clip is gone; delete it
- *   trims-head  → the buried clip loses its head; advance it, advance its trim
- *   trims-tail  → the buried clip loses its tail; shorten it
- *   engulfed-by → the buried clip is cut in two; the incoming clip sits between
- *
- * The first version of the gate REFUSED an overlapping move instead. That kills
- * the defect but ships a worse experience than the defect did: a drag that does
- * nothing reads as broken software. Refusal survives only as the last branch —
- * when there is genuinely no legal resolution.
- *
- * TRIM IS THE PART THAT IS EASY TO GET WRONG. Shortening a media clip's timeline
- * span without moving its source window makes the picture jump: the frames that
- * play are no longer the frames the editor saw. Every edit here carries the
- * source window with it, playback-rate aware.
- */
 import type { TimelineClip } from "../validators/composition.js";
 import type { PlacementSpan, PlacementTrack, TrackKind } from "./occupancy.js";
 import type { RefusedPlacement, TimelinePlanOp } from "./plan.js";
-/** Timeline seconds below which a residue clip is not worth keeping. */
 export declare const MIN_RESIDUE_SECONDS = 0.04;
 export type OverlapPolicy = "resolve" | "refuse";
-/**
- * The source window for a sub-range of an existing clip.
- *
- * `newStartTime`/`newDuration` are TIMELINE values; the trim window is SOURCE
- * values, so the delta is scaled by playbackRate. A clip with no trim window
- * (overlays, cards, components) has nothing to carry and returns undefined.
- */
 export declare function trimForSubRange(clip: Pick<TimelineClip, "startTime" | "source">, newStartTime: number, newDuration: number): TimelineClip["source"] | undefined;
 export interface ResolveArgs {
     track: PlacementTrack;
     trackKind: TrackKind;
     span: PlacementSpan;
     policy: OverlapPolicy;
-    /** Full clip rows for the track, so trims can carry their source window. */
     clipsById: ReadonlyMap<string, TimelineClip>;
-    /** Mints ids for the tail half of a split. Injected so the kernel stays pure. */
     newClipId: () => string;
 }
 export interface ResolveResult {
     ops: TimelinePlanOp[];
     refusals: RefusedPlacement[];
 }
-/**
- * Ops that clear `span` on `track`. Emits nothing when the span already fits,
- * which is the common case — resolution is the exception, not the rule.
- */
 export declare function resolveOverlaps(args: ResolveArgs): ResolveResult;

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

@@ -1,54 +1,5 @@
-/**
- * SLIP, ROLL and SLIDE — the three trims that are not "drag an edge".
- *
- * The trim classifier knew move / left-trim / right-trim and nothing else, so
- * every correction that keeps something else fixed was impossible:
- *
- *   SLIP   the clip stays exactly where it is; the SOURCE WINDOW moves inside
- *          it. "Right beat, wrong framing" — the single most common correction
- *          in content-aware editing, and the one this timeline could not make.
- *
- *   ROLL   the CUT between two neighbours moves; both durations change and
- *          nothing after it shifts. Pacing, without re-timing the whole lane.
- *
- *   SLIDE  the clip MOVES and its neighbours absorb the difference; the clip's
- *          own content is untouched and total duration is unchanged.
- *
- * All three are computed here, as pure functions returning plan ops, for the
- * same reason placement is: the cloud director edits compositions too, and a
- * trim rule that lives in the desktop is a rule the cloud does not have.
- *
- * Each returns `null` when the gesture is not legal rather than clamping to
- * something almost-right — a slip past the end of the source is not "a smaller
- * slip", it is a slip that cannot happen, and silently doing something else is
- * how an editor stops trusting the tool.
- */
 import type { Composition } from "../validators/composition.js";
 import type { TimelinePlan } from "./plan.js";
-/**
- * SLIP — shift the source window by `deltaSeconds` of TIMELINE time, leaving
- * the clip's position and duration untouched.
- *
- * Refused when the clip has no source window (an overlay has nothing to slip)
- * or when the shift would run off either end of the source. `sourceDuration`
- * is required to police the far end — without it the far bound is unknowable
- * and a "successful" slip could point past the end of the media.
- */
 export declare function planSlip(composition: Pick<Composition, "tracks">, clipId: string, deltaSeconds: number, sourceDuration: number): TimelinePlan | null;
-/**
- * ROLL — move the cut between `clipId` and the neighbour on the given side.
- *
- * Both clips change duration; the outer edges and everything downstream stay
- * put. Refused when either side would fall below the minimum, or when either
- * side lacks the source to cover its new length.
- */
 export declare function planRoll(composition: Pick<Composition, "tracks">, clipId: string, side: "left" | "right", deltaSeconds: number, sourceDurations: Readonly<Record<string, number>>): TimelinePlan | null;
-/**
- * SLIDE — move the clip in time; its neighbours absorb the difference.
- *
- * The clip's own content and duration are untouched; the previous clip grows
- * or shrinks and the next one does the opposite, so nothing beyond the pair
- * moves. Refused without neighbours on both sides — a slide with nothing to
- * absorb into is just a move, and the caller should ask for that instead.
- */
 export declare function planSlide(composition: Pick<Composition, "tracks">, clipId: string, deltaSeconds: number, sourceDurations: Readonly<Record<string, number>>): TimelinePlan | null;

package/dist/_members/composition/validators/brandKit.d.ts

@@ -19,10 +19,6 @@ export declare const EasingValue: z.ZodUnion<[z.ZodEnum<["linear", "ease", "ease
     y2: number;
 }>]>;
 export type EasingValue = z.infer<typeof EasingValue>;
-/** A palette reference (audio-substrate P2 AudioPaletteEntry.ref): a pack
- *  soundId | music-pack bedId | org mediaId — an opaque string placement handle.
- *  The brand SOUND kit fields (audio.sonicLogo / uiSoundSet / bedStyle /
- *  ambiencePreference) reference sounds by this same handle. */
 export declare const AudioPaletteRef: z.ZodString;
 export declare const FontRef: z.ZodUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"system">;
@@ -839,23 +835,10 @@ export declare const BrandKit: z.ZodObject<{
         opacity?: number | undefined;
         placement?: "tl" | "tr" | "bl" | "br" | undefined;
     }>>;
-    /** Brand audio identity (audio design spec 2026-07-20): default SFX intensity
-     *  + music-bed defaults. Brief `audio` wins when present (caption-identity
-     *  precedence: brand default beats brief absence; brief beats brand).
-     *
-     *  Brand SOUND kit (audio-substrate Phase 5) — identity over TIME. All four
-     *  fields are OPTIONAL; a kit that sets none behaves byte-identically to a kit
-     *  with no audio block. Refs are palette references (P2 AudioPaletteEntry.ref:
-     *  a pack soundId | music-pack bedId | org mediaId — an opaque string handle). */
     audio: z.ZodOptional<z.ZodObject<{
         sfxIntensity: z.ZodOptional<z.ZodEnum<["off", "light", "standard", "dense"]>>;
         musicEnabled: z.ZodOptional<z.ZodBoolean>;
         musicMood: z.ZodOptional<z.ZodString>;
-        /** SONIC LOGO — a brand audio signature bound to the intro/outro bookend at
-         *  compose time (an sfx-role clip at the body edge adjacent to the render
-         *  bookend). `ref` = a palette reference; `placement` = which bookend(s);
-         *  `offsetMs` shifts within. Bound only when the corresponding bumper
-         *  (kit.intro / kit.outro) exists — else a non-blocking advisory. */
         sonicLogo: z.ZodOptional<z.ZodObject<{
             ref: z.ZodString;
             placement: z.ZodEnum<["intro", "outro", "both"]>;
@@ -869,10 +852,6 @@ export declare const BrandKit: z.ZodObject<{
             ref: string;
             offsetMs?: number | undefined;
         }>>;
-        /** UI SOUND SET — per-family palette overrides consumed by the sfxCompile
-         *  org-first draw as the HIGHEST-priority tier (brand > org palette > pack
-         *  default), mirroring how a brand FONT sits above org defaults. Keys are the
-         *  closed SfxFamily vocabulary; values are palette refs. */
         uiSoundSet: z.ZodOptional<z.ZodObject<{
             tick: z.ZodOptional<z.ZodString>;
             pop: z.ZodOptional<z.ZodString>;
@@ -898,11 +877,6 @@ export declare const BrandKit: z.ZodObject<{
             whoosh?: string | undefined;
             riser?: string | undefined;
         }>>;
-        /** BED STYLE — a preferred pack bed (`bedId`) or a style hint (`genre` /
-         *  `bpmRange`). SURFACED-ONLY today (compose does not auto-select a pack bed
-         *  — it uses a client-pinned bed or generates from mood); the field resolves
-         *  through the kit + surfaces via get_profile / brand-kit reads so driving
-         *  agents honor it when pinning / generating a bed. */
         bedStyle: z.ZodOptional<z.ZodObject<{
             bedId: z.ZodOptional<z.ZodString>;
             genre: z.ZodOptional<z.ZodString>;
@@ -931,9 +905,6 @@ export declare const BrandKit: z.ZodObject<{
                 max: number;
             } | undefined;
         }>>;
-        /** AMBIENCE PREFERENCE — a preferred ambience bed (`{ref}`) or explicit
-         *  `null` (opt-out). SURFACED-ONLY (compose has no ambience auto-placement);
-         *  resolves + surfaces for driving agents. */
         ambiencePreference: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             ref: z.ZodString;
         }, "strip", z.ZodTypeAny, {

package/dist/_members/composition/validators/composePlan.d.ts

@@ -1,17 +1,4 @@
-/**
- * ComposePlan — the locked contract between the compose PLANNER and the
- * ASSEMBLER (multi-agent director spec 2026-06-11). The plan mirrors the
- * composition model: framing → cropIntents, cuts → delete_ranges/excludedRanges,
- * captions → CompositionCaptions.style intent, assets → mediaId refs,
- * graphics → overlay/component refs. Specialists fulfill assets/graphics
- * requests; the assembler integrates and never re-plans.
- */
 import { z } from "zod";
-/** The planner's subject pick — WHO/WHAT the camera tracks on a `frame` beat.
- *  This is the PLANNER↔assembler contract shape (kept subject-centric so the
- *  Langfuse-managed planner prompt is unchanged); the assembler (compile.ts)
- *  maps it onto the canonical `Focus` of a `ReframeSegment`. Same variants as
- *  `Focus`: face / all-faces / frame-center / active-speaker / point. */
 export declare const PlanSubject: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     kind: z.ZodLiteral<"face">;
     faceId: z.ZodString;
@@ -53,16 +40,6 @@ export declare const PlanSubject: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     y: number;
 }>]>;
 export type PlanSubject = z.infer<typeof PlanSubject>;
-/** One framing decision — three first-class intents so none is expressible
- *  only by misusing another (the 2026-07-12 verify-rerun planner read 'trim'
- *  as "keep un-cropped" and trimmed the whole clip; the vocabulary had no
- *  legal move for subject-less footage):
- *   - 'frame' — SHOW this span, cropped/tracked per `subject` (required).
- *   - 'keep'  — SHOW this span AS-IS, no reframe (b-roll, landscapes, any
- *               footage with nothing to track). No subject.
- *   - 'trim'  — DELETE this span from the output entirely.
- *  Downstream: 'frame' compiles to a crop intent; 'keep' compiles to nothing
- *  (shown uncropped); 'trim' compiles to an excluded range. */
 export declare const PlanFramingSegment: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodObject<{
     startSec: z.ZodNumber;
     endSec: z.ZodNumber;
@@ -110,7 +87,6 @@ export declare const PlanFramingSegment: z.ZodEffects<z.ZodEffects<z.ZodEffects<
     shotScale: z.ZodOptional<z.ZodEnum<["close", "standard", "wide"]>>;
     zoomScale: z.ZodOptional<z.ZodNumber>;
     verticalBias: z.ZodOptional<z.ZodNumber>;
-    /** Optional in the plan; the assembler defaults it to 0 on set_crop_intents. */
     lateralBias: z.ZodOptional<z.ZodNumber>;
     intent: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -320,9 +296,6 @@ export declare const PlanAssetRequest: z.ZodObject<{
     kind: z.ZodEnum<["broll", "audio", "sfx", "music", "ambience", "gif", "image"]>;
     source: z.ZodEnum<["find", "generate"]>;
     intent: z.ZodString;
-    /** Phase 1: the planner resolves `find` requests against the pool at plan
-     *  time (it has search_library) and records the pick here. Unresolved find
-     *  requests are stripped by the validator (degrade, not error). */
     resolvedMediaId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -342,14 +315,6 @@ export declare const PlanAssetRequest: z.ZodObject<{
     resolvedMediaId?: string | undefined;
 }>;
 export type PlanAssetRequest = z.infer<typeof PlanAssetRequest>;
-/**
- * A first-class typed graphic the planner requests: a `role` (the editorial
- * graphic type) + structured `copy` — NOT a coarse kind + freeform text. The
- * designer phase reads these straight into a graphics-plan ContentBeat and
- * compiles deterministically (no inference, no bespoke-JSX escape hatch).
- * `role`/`copy` are the graphics-domain SSOT (graphics-plan/schemas); zPlane is
- * implied by the role (`hero` → behind-subject) so it is not re-declared here.
- */
 export declare const PlanGraphicRequest: z.ZodObject<{
     id: z.ZodString;
     atSec: z.ZodNumber;
@@ -494,7 +459,6 @@ export declare const ComposePlan: z.ZodObject<{
         shotScale: z.ZodOptional<z.ZodEnum<["close", "standard", "wide"]>>;
         zoomScale: z.ZodOptional<z.ZodNumber>;
         verticalBias: z.ZodOptional<z.ZodNumber>;
-        /** Optional in the plan; the assembler defaults it to 0 on set_crop_intents. */
         lateralBias: z.ZodOptional<z.ZodNumber>;
         intent: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -709,9 +673,6 @@ export declare const ComposePlan: z.ZodObject<{
         kind: z.ZodEnum<["broll", "audio", "sfx", "music", "ambience", "gif", "image"]>;
         source: z.ZodEnum<["find", "generate"]>;
         intent: z.ZodString;
-        /** Phase 1: the planner resolves `find` requests against the pool at plan
-         *  time (it has search_library) and records the pick here. Unresolved find
-         *  requests are stripped by the validator (degrade, not error). */
         resolvedMediaId: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id: string;