<aside> 🛠

Turn a Shorts Edit Plan into a Renderable EDL — The Bridge from Planning to Rendering

Take a shorts edit plan (from an upstream planner that combined Video Analysis, Video Constraint Map, and any other planning signals) and convert it into a rendering-ready Edit Decision List — the enhanced metadata format that downstream Video Editing tools consume to make smart, coordinated decisions across the whole shorts chain. This is the tool that turns "here's what we should do" into "here's what to render.”

</aside>

What it does

Video EDL takes an edit plan as input and produces the segments + carried metadata that the shorts-rendering chain expects. In video-editing tradition, an EDL (Edit Decision List) is a formal description of an edit — cuts, timings, and per-segment decisions written in a machine-readable format. Video EDL is the studio's equivalent: it converts a planner's abstract decisions (which segments to keep, how to frame them, what shot type / emotion to associate with each, where the hook moment lives) into the concrete data shape that Video Trim, Video Reframe (9:16), Video Subtitle (Spoken), Video SFX, Hook Teaser, and the other rendering-stage tools directly consume.

Problem it solves

• Planning-to-rendering bridge – A shorts planner produces high-level edit decisions; Video EDL converts them into the exact JSON / metadata shape the render tools need
• Coordinates the whole chain – One EDL feeds multiple downstream tools (Video Trim reads segment ranges, Video Reframe reads shot_type, Video SFX reads emotion, Hook Teaser reads hook_sec) — all coherently derived from the same plan
• Machine-editing standard – EDL is the traditional bridge between edit intent and edit output in video post-production; Video EDL applies that idea to AI-driven shorts
• Enables intelligent-editing pipelines – Downstream tools that support "EDL mode" or "Auto" behaviors (Video Reframe punch-in Auto, Video SFX EDL mode, Hook Teaser hook-anchored teasers) work best when the metadata comes from an EDL rather than raw Video Analysis output
• Separates concerns – Planning tools decide what to do; Video EDL formalizes the plan; render tools handle how to do it — each stage is testable and swappable
• Reproducible – Same plan + same EDL settings = same segments JSON, so rendering is deterministic

Input/Output

<aside>

• Input: Edit plan (+ optional secondary reference)
  • Edit plan (top input, orange port): The plan produced by an upstream shorts planner (built on top of Video Analysis and, optionally, Video Constraint Map). Describes which segments to keep, per-clip framing / shot-type / emotion / hook-time decisions, and any other planner outputs.
  • Secondary input (optional, second orange port): Additional reference data the EDL may draw from (e.g., a constraint map, a config, or a per-clip override list) — depending on how your flow is wired. </aside>

<aside>

• Output: Rendering-ready EDL (two outputs)
  • Segments / metadata output (yellow-gold port): The per-clip metadata bundle carrying title, hook, hook_sec, emotion, shot_type, score, and any other per-clip fields the render chain will use. Consumed by tools that need the metadata directly (Video Caption, Video Narrate, Video Reframe Auto punch-in, Video SFX EDL mode).
  • Segments JSON output (orange port): The start_sec / end_sec segment list — the JSON shape Video Trim consumes to cut clips. </aside>

Configuration Options

Advanced Options

• Upper bound on how many cuts the plan may contain: Hard cap on the number of cuts (segments) in the finished EDL.
  • Default: 40
  • UI: Slider (in Advanced Options modal)
  • Behavior: Cuts past this limit are dropped from the output EDL, and the plan explicitly reports that the cap was hit (so downstream tools / logs can see the truncation happened, rather than silently losing content).
  • Reference points:
    • 10 – 20 – Tight cap for very short compilations or single-video outputs where you only want the top-N cuts
    • 40 (default) – Balanced ceiling that handles most podcast / interview / vlog highlight reels without hitting the limit
    • 60 – 100 – Loose cap for long-form sources or dense-cut / kinetic edits where the planner is expected to make many small cuts
    • 150+ – Very generous cap; use for full-length compilations or when the planner intentionally emits many micro-cuts
  • Tip: If the plan reports that the cap was hit, either raise the ceiling here or tune the upstream planner (Video EDL Planner) to be more selective — dropping cuts silently would lose plan intent, so this cap is deliberately loud about truncation.

How to Use

<aside>

1. Prepare the edit plan → Route your source through Video Analysis (and optionally Video Constraint Map + a shorts planner) to produce the edit plan that Video EDL consumes
2. Wire the plan into Video EDL → Connect the edit plan to the top (orange) input port. If your flow includes supplementary reference data, connect it to the second input port.
3. (Optional) Tune the Advanced Options → Open the Advanced panel if you need a specific EDL variant; defaults are usually correct for the standard shorts chain.
4. Wire the outputs →
   • Connect the segments JSON output (orange) to Video Trim
   • Connect the segments / metadata output (yellow-gold) forward through the pipeline so tools like Video Reframe, Video Subtitle, Video SFX, Video Caption, Video Narrate, and Hook Teaser can read per-clip fields
5. Run Flow → Video EDL emits the rendering-ready EDL; the shorts chain downstream cuts, reframes, subtitles, and finishes the video using the coordinated per-clip decisions </aside>