decktalk.toml

decktalk.toml sits in the project root, and every path in it is relative to that directory. It has two halves, and knowing which half a key is in tells you everything else about it. The document is the content this project is: what it is called, which section plays which page or clip, which voice reads it, what the sound is made of and how the cuts behave. Every value in it changes from presentation to presentation, and this page is its reference. Each number in it still has a range the loader holds it to, which the tables below give and which decktalk schema setting publishes under content with its default and the reason for each edge. The settings are what a project changes. Every settings key publishes its default, its safe range, its unit, its scope and what a value at the edge risks, all from one declaration in the code, so decktalk schema setting, the JSON Schema, decktalk config explain and Configuration are four renderings of one row. This page names the tables and sends you there rather than copying the numbers.

The first line

decktalk.toml

#:schema https://raw.githubusercontent.com/jacobcbeaudin/decktalk/main/schemas/v1/decktalk.json

That comment binds the file to the published JSON Schema. An editor that understands it completes every table and every key as you type, offers each key’s own sentence, and marks a value outside a key’s safe range before you save. decktalk init writes the line, and it costs nothing to keep.

Which value wins

A project key is set by its default, then by decktalk.toml, then by the environment variable it publishes, such as DECKTALK_VIDEO_PRESET, then by --set table.key=value for one run. A machine key takes the per-machine file in place of decktalk.toml, and a project file that sets one is refused. Which value wins is the rule in full, and Keys only a machine may set lists the machine keys. --set writes nothing. --set overrides a key for exactly the run it is given to, and the file on disk is untouched, which is what makes it the right way to try a value. It takes the same spelling an environment variable takes, so a value cannot get in through one route that the other would refuse. No flag on any command duplicates a settings key, so reduced motion is --set motion.reduce=true and never a flag of its own. decktalk config explain KEY prints the value that wins and the layer that set it, along with what the key changes, what may be written into it and which findings it moves. Its --json lists every layer that sets the key. decktalk config set KEY VALUE is how you write one into a file. It reads the value under the same range the loader enforces, edits the document in place rather than rewriting it, so the comments you wrote around the key survive, and loads the would-be file whole before a byte lands, so a file no run could use never reaches the disk. --scope project writes decktalk.toml and --scope machine writes the per-machine file. --dry-run reports the change and writes nothing. decktalk config unset KEY takes a key out again so the layer below it wins. A value outside a key’s safe range is refused at load, by the dotted key that wrote it, with the range it missed, the layer it came from and the sentence saying what goes wrong at the edge.

error[INPUT]: video.crf: must be between 0 and 32, got 99 in decktalk.toml.
  hint: Above about 32 the encoder's own ringing is larger than a small reveal, so a cue that played reads as no change and the check that would have caught it passes instead.
  docs: https://docs.decktalk.ai/reference/errors/INPUT

Load rules

Every project command loads this file first. The load fails when any of these is true, and the refusal names what it read and would not accept.

A top-level table is neither a document table nor a settings table.
The file has no [[section]] table.
A required key is missing, such as a [[section]] with no number.
A value has the wrong type. seconds = 120.5 under [score.music] fails, because that key is an integer and a mapping carries the type its author wrote.
A number is nan or inf, which TOML spells and no range can hold. The same refusal meets one in a DECKTALK_ variable or a --set, and it names the file, the variable or the flag that wrote it.
Two [[section]] tables share a number.
A section names more than one of page, clip and render_command, or none of them.
A render_command is not a list of words, or holds an empty word.
A number in a document table is outside its range, such as slate_seconds = -3 or [mix] music_db = 40. The refusal names the line that wrote it.
seamless is set on the first section, which has no previous section.
A [transition] dips pair or a [[mix.effect]] row names a section that does not exist.
A settings value is outside its safe range.
A page sits at the project root. The origin serves a page’s whole directory, and the root holds the script, the cue file and the build directory.
A path the project names resolves outside the project, which includes a symbolic link inside the project that points out of it. The refusal names the path and never the place it resolved to.
A settings key only a machine may set is written here, such as record.concurrency or tools.ffmpeg. The refusal names the key and the config set line that puts it in the machine’s file.

An unknown key inside a known table does not fail the load. DeckTalk warns, names the closest key it does read, ignores the key and carries on.

decktalk.toml: [elevenlabs]: ignoring unknown key 'stabilty' (did you mean 'stability'?).

A key spelled under a table it does not live in is warned about the same way, and the closest key is named with its own table, because no key is read under any name but its own.

decktalk.toml: [voices.narrator]: ignoring unknown key 'tail_seconds' (did you mean 'narration.tail_seconds'?).

A page section key written on a clip section, or the reverse, gets a warning of its own that names the kind of section the key belongs to.

The smallest file that loads

decktalk.toml

[[section]]
number = 1
page = "deck/index.html"

decktalk init writes a three-section file with comments and every section a page section. decktalk init --example NAME writes a finished project instead.

The document

The tables below are the content this project is. Every one of them is read by Document, none of them has a settings key in it except where this page says a table is shared, and none of them publishes an environment variable or answers to --set.

`[project]`

Key	Type	Default	Meaning
`name`	string	the project directory’s name	What the film is called. The film is `build/final/<name>.mp4`, and the captions, the chapters, the transcript and the poster are named from it too.
`script`	path	`script.md`	The narration script.
`cues`	path	`cues.json`	The cue file.
`build`	path	`build`	Where everything generated goes.
`language`	string	`en`	The BCP 47 tag of the language the film is narrated in. It labels the mp4’s streams, which is what a player names the audio from, and it is the transcript page’s own language.

`[[section]]`

Write one [[section]] per section of the film. Sections are sorted by number, so the order in the file does not matter. A section is a page section, which records one scene of an HTML page, a render section, which is narrated like a page section and drawn by a program you name, or a clip section, which plays a video file you already have. A page key makes a page section, a render_command key a render section and a clip key a clip section, and naming more than one of them or none fails the load.

Every section

Key	Type	Default	Meaning
`number`	integer	required	The section number. A page or render section is narrated from the `## N.` heading with its number, and one with none plays silent.
`chapter`	string	the script heading, then `Section N`	The chapter title, which names this section in the chapter markers, in the transcript and on the slate a missing clip plays. Consecutive sections with the same title share one marker.
`seamless`	boolean	`false`	This section opens on the picture the section before it ended on. `verify` compares the two frames across the cut and raises `CUT_POP` when the join shows. It may not be set on the first section.

A page section

Key	Type	Default	Meaning
`page`	path	required	The HTML file to record, such as `deck/index.html`. It sits in a directory of its own, never at the project root.
`scene`	integer or string	the section’s `number`	Which `data-scene` of that page to play. It reaches the page as a string.
`hold_seconds`	number	`0`	How long the page plays on after the section’s narration. The hold is recorded like the rest of the section, so a motion that arrives after the last word lands in it. The narration waits for the hold, and the next section starts after it. Between 0 and 60.
`lead_seconds`	number	`[narration] lead_seconds`	Silence before the section’s first word. Between 0 and 5, as `[narration] lead_seconds` is.
`tail_seconds`	number	`[narration] tail_seconds`	Silence after the section’s last word. Between 0 and 10, as `[narration] tail_seconds` is.
`with_ambience`	boolean	`false`	Play the ambience bed under this section.
`params`	table	none	Query parameters the page is opened with, written as `[section.params]`. Every key must be one of `scene`, `freeze`, `cues`, `words`, `turns`, `caption`, `t0`, `speed`, `hud`, `after` and `before`, which is the whole vocabulary a DeckTalk page reads. Loading the project accepts any key, and a command that opens the page or works out whether its recording is current refuses any other key by name, as `INPUT`: `check` with pages, `storyboard`, `status`, `record` and `build`. `narrate`, `cue` and `check --no-pages` never read it. Every value reaches the page as a string.

lead_seconds and tail_seconds are placed when the takes are joined and are never sent to the voice, so changing either voices nothing. The section starts where its silence starts, so lead_seconds moves every word and every phrase cue of the section later while a $start cue stays at zero. A change reaches the clock when narrate joins the takes again: until then words, cue and record read the lead the take index holds, which is the lead the narration plays. script.md has the whole rule. record sets t0 itself so that the page starts its clock on the recorder’s signal, and it fills cues, words and turns from what cue and narrate resolved unless the section names them. A frozen frame, which storyboard and check draw, sets cues, t0, freeze, after and before itself, so those five are dropped from a section’s params rather than passed through.

decktalk.toml

[[section]]
number = 4
chapter = "The edit"
page = "deck/index.html"
lead_seconds = 1.5    # the page shows for 1.5 seconds before the first word
hold_seconds = 2      # the page plays on 2 seconds before section 5

A page may load only what this file declares. Every page is opened at a local origin that answers for the directory each page sits in and for the files the document names, which are each clip, every [mix] file, every [[mix.effect]] file and every [score] out. Every other file in the project is refused, so the script, the cue file, build/ and .env stay out of a page’s reach. A declared file is reached by the spelling written here and by no other, so media/Theme.mp3 does not answer a request for media/theme.mp3 on any platform. A declared directory is a place, so every name under it is served however the page spells it.

A render section

A render section names the program that draws its picture in place of a page. It is narrated exactly as a page section is: its take sets its length, cue resolves its cues from its words, and the narration runs through it without a pause. It names no page and no scene, and it takes the page section keys hold_seconds, lead_seconds, tail_seconds and with_ambience with the same meaning. A scene or a params table written on it is ignored, and the load warns that the key applies only to a page section.

Key	Type	Default	Meaning
`render_command`	list of strings	required	The program and its arguments, run once in an empty scratch folder when `record` draws the section, with every word that names a project file handed over as its absolute path. Each `{name}` in a word is replaced before it runs.

Word	What it becomes
`{motion}`	The section’s motion document, `build/recordings/render/NN/motion.json`, which holds the frame rate, the size, the length, every spoken word and every cue’s second on the section clock.
`{out}`	The video the program writes, which is the section’s recording.
`{landings}`	`build/recordings/render/NN/landings.json`, where the program may write the lanes it drew for verify to mask and measure.
`{python}`	The Python DeckTalk is running on.
`{ffmpeg}`	The ffmpeg DeckTalk encodes with.

decktalk.toml

[[section]]
number = 3
chapter = "A picture from elsewhere"
render_command = ["{python}", "render/draw_bars", "{motion}", "{out}", "{landings}", "{ffmpeg}"]
hold_seconds = 1.0

The program runs only on a machine that allows a project’s programs through record.programs, which refuses them by default, and never under record.page_policy = "untrusted". It runs with your user’s rights and can read every file you can, .env included: the scrubbed environment it is given keeps a credential in the shell from it, and nothing keeps a file on disk from it. It runs in an empty scratch folder, and a word that names a project file by a relative path is handed over as that file’s absolute path. check raises PROGRAM_NAMED for every program a project names. Programs a project names says how to allow them. A section whose program writes no landings is drawn and played, and verify measures none of its cues. A render section shows the whole contract.

A clip section

Key	Type	Default	Meaning
`clip`	path	required	Your own video file. It keeps its own audio.
`slate_seconds`	number	`5`	How long the titled slate plays when the file is not there. Above 0, at most 60.
`optional`	boolean	`false`	A missing file is expected here for now, so `decktalk status` raises no `FILE_MISSING` for it and `Project.assemble(strict=True)` plays the slate rather than refusing. Delete the line once the clip is there.

A clip whose file is not there plays a titled slate for slate_seconds, and decktalk status raises FILE_MISSING unless the section sets optional. The speech inside a clip is captioned from the words file beside it, <clip>.words.json. The voice never reads a clip section, so it needs no heading in the script and it is never voiced. A clip between two page sections pauses the narration, which resumes with the next page section. DeckTalk scales and pads the clip to the frame size, matches its sound to the narration’s loudness, and the chapters include it. Play a clip shows the whole task. Every media file a project names, which is a clip, the music, the ambience and each effect, is read as one file by one of a closed set of formats: MP4, MOV and M4A, WebM and MKV, AVI, MP3, WAV, Ogg, FLAC, AAC, PNG, JPEG and WebP. A file in any other format is refused, and so is a playlist, an HLS or DASH manifest, an ffmpeg concat list or an image sequence, because each of those opens files or hosts the project never named.

`[voices.NAME]` and `[narration] voice`

Each voice a project reads in is one [voices.NAME] table, and [narration] voice names the default voice, which reads every section no [voice NAME] line in the script names. A voice name is a lower-case letter followed by lower-case letters and digits, such as narrator, guest or host2, so it spells one environment variable. Everything a provider is particular about is in that provider’s own table, [elevenlabs] for ElevenLabs and [dtsp] for the local voice, and a voice may set any of that table’s voice settings for itself alone.

decktalk.toml

[narration]
voice = "narrator"            # the default voice, which reads every section no [voice NAME] line names

[voices.narrator]
provider = "elevenlabs"
id = "21m00Tcm4TlvDq8ikWAM"
speed = 1.0

[voices.guest]
provider = "dtsp"
id = "af_heart"
speed = 1.1                   # this voice's own pace
model = "kokoro-82m"          # over [dtsp] model, for this voice alone

[elevenlabs]                  # every ElevenLabs voice's defaults, and what the plan charges
dollars_per_1000_characters = 0.30
stability = 0.55
similarity_boost = 0.75

Key	Type	Default	Meaning
`provider`	string	`elevenlabs`	The speech provider that reads this voice. It is a name the machine’s own map answers. An unregistered name loads, and it fails when a run asks that voice for a take. A run that does not spend plays placeholders and never asks. DeckTalk ships `elevenlabs` and `dtsp`, and one film may mix them.
`id`	string	empty	The provider’s id of this voice. It is a published name rather than a credential, so it is committed with the project, and `DECKTALK_VOICES_<NAME>_ID`, such as `DECKTALK_VOICES_GUEST_ID`, overrides it for anyone who keeps it out of the file.
`speed`	number	`1.0`	How fast the voice speaks, as a multiple of its natural pace. Speed is set on each voice alone.

Any other key of a voice table is a voice setting of its provider’s table, such as model, stability or output_format, and its value wins over that table’s for this voice, whatever layer set either. A key of another provider’s table is refused when the project loads, and so is the rate a provider charges, which every voice of that provider is billed at, and a key only the machine may set, such as base_url. A project that writes no [voices.NAME] table is read by the default voice at every default. Once one table is written, every voice the project reads in needs its own, the default included, and [narration] voice must name one of them. A variable or a --set for a voice the project does not declare is refused, because a voice renamed in the file would otherwise leave its variable buying in the wrong voice. A voice’s name is never part of a take’s digest, so renaming a voice, with its [voice NAME] lines, voices nothing. Write a dialogue shows a section read by two voices. The ElevenLabs API key is the one secret, so it lives in .env as ELEVENLABS_API_KEY, or in the environment. The local voice needs none. [elevenlabs] holds model, stability, similarity_boost, style, speaker_boost, dollars_per_1000_characters, output_format and base_url. ElevenLabs bills per character, so its rate is stated per thousand characters. model is the model every ElevenLabs voice reads in unless its own table sets one. The score stage buys from the same API with the same key and base_url, and its own request settings and its rates per minute of audio are in [score]. Configuration has each one with its range. The voice id, the model, speed, the four voice fields and output_format are part of a take’s input digest, so changing one makes the next voiced build voice again every turn that voice reads. The price and the base URL are not. base_url is machine-scoped, so it is set in this machine’s file and a decktalk.toml that sets it is refused. [dtsp] holds model, and the machine-scoped base_url and handshake_seconds, for the local voice, which speaks the DeckTalk speech protocol to decktalk-voice, a separate local server that is not part of this repository and is not yet public. base_url is machine-scoped like ElevenLabs’s, so only this machine names where the script is sent, and handshake_seconds is how long the server has to say which aligner it serves. The local voice bills nothing, so buying its takes asks for no --spend, and a build still asks about a score it would buy. Its takes are named by dtsp, the voice id, the model and speed, so they never share a name with an ElevenLabs take of the same words. Configuration has all three keys.

`[score]`

[score] holds the prompts that decktalk score generates from. It is optional, and no packaged project writes one. Every sound it buys is written to the score directory, [score] dir, which is score/ by default and which you commit, unless the item names another path. A generated file that [mix] then names is what the film actually plays. Each item’s table is shared: its prompt and its file are the document, and beside them sit the settings that size its request, spelled the same way in every table. Configuration has every setting with its range, and [score] timeout_seconds is how long one request may take.

decktalk.toml

[score.ambience]
prompt = "a quiet room, distant traffic, no music"

[score.effects.chime]
prompt = "one soft glass chime"

[score.music]
prompt = "calm piano under a lesson, unhurried"
duration_seconds = 360

`[score.ambience]`

Key	Type	Default	Meaning
`prompt`	string	required	The prompt.
`out`	path	`[mix] ambience`, else `score/ambience.mp3`	Where to write it.
`duration_seconds`	number	`25`	A setting: how long a bed to ask for. The bed loops under every section that sets `with_ambience = true`.
`prompt_influence`	number	`0.3`	A setting: how closely the sound follows the prompt.
`model`	string	`eleven_text_to_sound_v2`	A setting: the sound model to ask.
`dollars_per_minute`	number	`0`	A setting: what your plan charges for a minute of this audio. A spend cap refuses a score while it is still `0`.

`[score.effects]` and `[score.effects.<name>]`

[score.effects] holds four settings for every effect: duration_seconds, which is 0.5, prompt_influence, which is 0.5, model, and dollars_per_minute, which is what your plan charges for a minute of effect audio. One [score.effects.<name>] table per effect names it, and <name> is the name the file is written under. It takes prompt, which is required, and out, which is score/<name>.mp3 by default, and it may set duration_seconds, prompt_influence or model for itself. A [[mix.effect]] row is what places the finished sound in the film.

`[score.music]`

Key	Type	Default	Meaning
`prompt`	string	required	The prompt.
`force_instrumental`	boolean	`true`	Ask for no vocals.
`out`	path	`[mix] music`, else `build/score/music.mp3`	Where to write the piece joined from its parts, which are bought into `score/music-part<n>.mp3`.
`duration_seconds`	integer	`360`	A setting: how long a piece to ask for. It is an integer, so `120.5` fails the load.
`model`	string	`music_v2`	A setting: the music model to ask.
`bitrate`	string	`192k`	A setting: the bitrate of the file joined from the parts.
`chunk_max_seconds`	integer	`300`	A setting: the longest one request asks for.
`crossfade_seconds`	integer	`2`	A setting: the crossfade between two parts.
`dollars_per_minute`	number	`0`	A setting: what your plan charges for a minute of this audio. A spend cap refuses a score while it is still `0`.

A piece longer than chunk_max_seconds is asked for in parts and joined with a crossfade, because the service will not write a long piece in one answer.

`[mix]`

[mix] is shared too. The keys below are the document, naming the sound files the film plays and the level each one plays at. The settings half is how each layer is ramped, and Configuration has its five keys. The loudness the final mix is mastered to is [audio]. Without [mix] the film carries the narration and the audio of any clip, and nothing else.

Key	Type	Default	Meaning
`music`	path	none	Music under the whole film. It loops, and it ducks under speech and under clips.
`music_db`	number	`-24`	The music level, between -60 and 0.
`music_duck_db`	number	`-6`	The extra level change under each spoken span and each clip, between -40 and 0.
`music_fade_in_seconds`	number	`2`	The fade in. Above 0, at most 30, because ffmpeg reads a fade of no length as a second long.
`music_fade_out_seconds`	number	`3`	The fade out. Above 0, at most 30.
`music_markers`	path	none	A markers file that swells and mutes the music at spoken phrases.
`ambience`	path	none	The ambience bed for every section that sets `with_ambience = true`.
`ambience_db`	number	`-20`	The ambience level, between -60 and 0.
`slate`	path	a rendered slate	A PNG to show for a missing clip, instead of the titled slate DeckTalk renders.

A missing music or ambience file does not fail the build. assemble warns and plays the film without it.

`[[mix.effect]]`

One table per sound effect, each of which plays at a cue.

Key	Type	Default	Meaning
`file`	path	required	The audio file to play.
`section`	integer	required	The section whose cue places it. The section must exist.
`cue`	string	required	The cue id of the cue in that section, such as `3.2:expand`.
`db`	number	`-16`	The level, between -60 and 0.
`offset_seconds`	number	`0`	Seconds added to the cue time, between -10 and 10. This offset belongs to the sound and not to the cue.
`caption`	string	none	The line a viewer reads when the sound plays, such as `ball bounces`. `assemble` gives it a line of its own in the captions.

A missing file or a cue that never resolved does not fail the build. assemble skips that effect and says so.

`markers.json`

[mix] music_markers names a JSON file that shapes the music under the film. No packaged project writes one, so the block below is the shape rather than a starter’s values.

media/markers.json

{
  "boost_db": 3,
  "boost_seconds": 2,
  "markers": [
    { "name": "turn", "section": 3, "phrase": "$start", "mute_seconds": 0.4 }
  ]
}

Key	Where	Type	Default	Meaning
`boost_db`	top level	number	`3`	How far each marker raises the music, in dB, between 0 and 12.
`boost_seconds`	top level	number	`2`	How long each swell lasts, between 0 and 30.
`markers`	top level	array	`[]`	The markers.
`name`	marker	string	none	The name a warning uses for it.
`section`	marker	integer	required	The section that holds the phrase.
`phrase`	marker	string	`$start`	A spoken phrase, `$start` or `$end`.
`offset_seconds`	marker	number	`0`	Seconds added to the matched second, between -10 and 10.
`occurrence`	marker	integer	`1`	Which match of the phrase to take, counting from 1.
`case_sensitive`	marker	boolean	`false`	Whether the match compares case.
`mute_seconds`	marker	number	`0`	Seconds of silence before the swell starts, between 0 and 30.

A marker resolves exactly as a cue does, against the words of its own section. A marker whose phrase is not spoken is reported by assemble and skipped.

`[transition]`

Key	Type	Default	Meaning
`dips`	array of two-integer arrays	every cut	Which boundaries dip to black, written as `[[from, to], ...]` of section numbers. Leave the key out to dip at every cut, and write `dips = []` for none.
`dip_seconds`	number	`0.15`	How long a dip lasts, rounded to whole frames so a fade never ends part way through one. Above 0, at most 1: ffmpeg reads a fade of no length as a second long, so write `dips = []` for straight cuts.
`page_fades_in`	boolean	`true`	Pages fade themselves in, so the cut into a page section adds no fade of its own.

Audio never dips. A dip shows on screen, so leave a pair out of dips for a cut that should not show, which is also what a seamless section needs.

The settings

A settings table may be written here with its project keys. Its machine keys go in the per-machine file instead, and [tools] holds nothing else, so it is never written here. These are the tables, and every key of each one is published with its default, its safe range, its unit, its scope and its hazard by decktalk schema setting and documented in full on Configuration.

Table	What it sets
`[narration]`	The pacing, the lead and the tail, the take folders and where a take’s sound ends.
`[voices.NAME]`	One table per voice: its provider, its id, its speed and any of its provider’s voice settings.
`[elevenlabs]`	ElevenLabs’s own keys: the fields its speech takes, its default model, what your plan charges and its API.
`[dtsp]`	The local voice’s own keys: its model and where its server listens.
`[record]`	How the recorder drives Chromium, steps each section frame by frame and judges a short recording.
`[video]`	The frame size, the frame rate and the video encoding of every recording and of the final mp4.
`[audio]`	The final audio: its bitrate, its sample rate, its channels, and the loudness, the true peak and the range it is mastered to.
`[mix]`	The ramps of the music duck, the ambience bed and each marker.
`[score]`	How each sound and the music are asked for: their models, their lengths and how the music is joined.
`[verify]`	Every limit the finished film is measured against.
`[motion]`	Reduced motion and the multiplier on every declared motion span.
`[output]`	The timestamped copy of the final mp4, the captioned copy, and whether the captions of a dialogue name its voices.
`[events]`	How many runs of event files are kept, and how large one may grow.

decktalk config list prints every key with the layer that set it. The captions of a section spoken in more than one voice carry the words alone by default. Turn on caption_voices to name the voice of every one of those captions, as a WebVTT voice span in the .vtt and as the name before the line in the .srt:

[output]
caption_voices = true

00:00:03.494 --> 00:00:05.120
<v engineer>Says who? Every demo says that.</v>

The .srt writes the same caption as engineer: Says who? Every demo says that., and those turns are wrapped short enough that the name and the line still fit on one caption line. captioned = true also writes <name>-captioned.mp4, the film with its captions drawn into the picture by your page, for a place that cannot load a caption file. The film itself is the same frames either way. Accessible video says how a page styles the captions and places them by voice.

Write the script: script.md
Land a reveal on a phrase: cues.json
Change a setting: Configuration
See how the sound fits together: Sound

Get started

Use cases

Concepts

Guides

Reference

Agents

Design decisions

Help

The first line

Which value wins

Load rules

The smallest file that loads

The document

`[project]`

`[[section]]`

Every section

A page section

A render section

A clip section

`[voices.NAME]` and `[narration] voice`

`[score]`

`[score.ambience]`

`[score.effects]` and `[score.effects.<name>]`

`[score.music]`

`[mix]`

`[[mix.effect]]`

`markers.json`

`[transition]`

The settings

​The first line

​Which value wins

​Load rules

​The smallest file that loads

​The document

​[project]

​[[section]]

​Every section

​A page section

​A render section

​A clip section

​[voices.NAME] and [narration] voice

​[score]

​[score.ambience]

​[score.effects] and [score.effects.<name>]

​[score.music]

​[mix]

​[[mix.effect]]

​markers.json

​[transition]

​The settings

​Related

The first line

Which value wins

Load rules

The smallest file that loads

The document

`[project]`

`[[section]]`

Every section

A page section

A render section

A clip section

`[voices.NAME]` and `[narration] voice`

`[score]`

`[score.ambience]`

`[score.effects]` and `[score.effects.<name>]`

`[score.music]`

`[mix]`

`[[mix.effect]]`

`markers.json`

`[transition]`

The settings

Related