Testing

12. Testing

Program settings have focused tests in program_setting_test.dart, program_path_test.dart and program_box_test.dart. They prove machine-only storage, defaults refused, executable discovery on a fixture PATH, explicit acceptance and typed paths, and the stored path’s executable warning at 1200 and 700 pixels in light and dark themes.

The same manifest and consent tests prove the process capability’s boolean declaration and one consent line per program. plugin_log_test.dart proves that each process door refuses a missing capability before dispatch, logging its full arguments.

process_door_test.dart runs a local Dart line-protocol fixture. It proves unchanged arguments containing spaces and & on Linux, stable default and explicit working directories (the fresh start answers its private process/<setting> directory and logs it), queued whole stdout and separately logged stderr, exit mid-receive, ownership refusal and release, cancellable waits, group cleanup including a child, and host survival across fresh JavaScript calls with disable, setting-change and exit cleanup. Its named Windows test, “Windows cmd path and argument with spaces”, proves a shim path and argument containing spaces on Windows; it is skipped on other systems. engine_test.dart proves all five frozen ctx.process doors across the real bridge. The process fixture also proves preservation of a concurrent setting edit while a program ignores TERM, and cancellation after a root exits while its child holds inherited pipes. lifecycle_test.dart proves process cleanup for failed Off, On and Allow writes, and host_runtime_test.dart proves it for a hung call. It also proves that a picture’s wait remains pending across chat traffic, ends with a fresh start after process stop, returns immediately for absent, exited or unowned processes, and cancels without changing chat ownership. A foreign-owner stop refuses busy while the owner still exchanges lines; own, unnamed, unowned and independent-lane stops retain their behavior, with the wait decisions and outcomes logged.

tool_relay_test.dart proves authenticated loopback initialize/list/call, repeated numeric ids on distinct responses and operations, string FilmOpen ids, non-POST refusal, complete request/result logging without the injected bearer, and pending-call completion, queue dropping and bearer invalidation on Stop, close, staleness, turn end and process exit. A real process fixture keeps the assistant relay live after a frame yields; a changed assistant turn refuses a new call. A cancelled policy’s tools start stops its spawned process before refusing, with the original failure and stop reason logged; explicit stops end their relay with their own reasons. A send without header substitution preserves its original line, including whitespace and number forms. The existing assistant tool loop remains the executor.

The xAI plug-in’s native xai-grok.test.mjs exercises fresh and loaded ACP sessions, the working directory and placeholder, whole system context, replay suppression, a string-id relay call across a fresh JavaScript continuation, whole successful and refused tool results, terminal plan usage, cancellation and unknown usage, model/protocol refusals, input bounds, busy ownership, sign-in status and the program/key status merge. These scripted tests prove the mapping; the signed-in live session proves model behavior.

The same process fixture proves parallel ownership at start, independent queues and release, same-lane already, operation-scoped stop, all-lane lifecycle cleanup and host frame cleanup of status and render before any send. program_setting_test.dart checks that the program-only parallel names a machine number setting of the manifest in either order, is absent by default, refuses a non-string (the program dropped) and reports a name that is no machine number setting as badEntry with the program kept and no lanes. program_copies_test.dart proves the number as read: the default, the person’s, a fraction’s integer part, a negative in the file as 0 and min: 0 refusing one typed, none without parallel; the render capacity from it per job, 0 as one; the number’s edit stopping that program’s lanes with settingChanged while another number stops none, and 0 making the setting one process again; and a program without a number serial — a turn kept across rounds in one process, a competing chat busy, a render waiting its turn, Stop ending the process — with the number on every slot and process log line. The engine regression returns the supplied clock, job id and frame operation through the native bootstrap. A shared-setting fixture keeps chat ownership between two completions and stops in the second: at 0 copies the picture waits outside both runner slots, then starts a fresh process and succeeds. Stopping the waiting picture returns cancelled while the chat can finish. At three copies the picture overlaps the chat, logs decision: none, and enters no process wait.

The program-turn cases in assistant_action_test.dart run the same native fixture through a test text provider. They cover Stop while receiving, Stop between a tool answer’s settlement and dispatch, failed and stale calls, a third repeated tool refusal, finalization, absent or throwing interrupts and their ordinary wall. Overlapping turn and finish requests refused busy leave the admitted policy’s relay live; the admitted invocation then completes normally and ends that relay once with turnEnded, while each refused invocation logs notAdmitted and ends nothing. They prove one fresh handover ledger, usage settled once, owner release, a surviving program after successful interruption and explicit fresh starts after failed cleanup. dev_run_test.dart proves both developer completion modes omit the wall despite their dev.complete recording label. contract_test.dart proves root operations are present and nested completions carry their calling frame id. It also proves done and failed frame owners are stopped, and a cancelled nested completion in another provider stops the caller-frame owner, discards queued output and lets the next operation start afresh. A one-shot fault in the existing process-stop wait proves that cleanup errors in both turn paths are logged and leave the backend free. A filtered ten-minute clock advances eleven minutes while a native program receive waits: completion remains pending with no wall timer, then Stop completes its handover. run_offer_test.dart checks that three nested completions each log a null wall with reason: complete and elapsed milliseconds. The fixture opens an existing key-backed Usage chain through the HTTP stand-in; native-route funding and admission remain the route’s integration work.

The universal core and the milestone suite

The universal core is the handful of end-to-end cases every change is proved against, whatever it touched: a project created, opened, edited through the autosave, saved, forked and picked; resolution (pickAt); the writer’s refusals of a stale file and of another author’s; a render through a stand-in backend; the command registry’s dispatch; the whole app pumped once (pumpApp); the plans 010 and 020; and the acceptance walk at 1200 × 800. It lives in one list, scripts/test_core.txt, each entry with a comment naming its case. A list has one entry per line, # comments and blank lines ignored: a test file’s path from the root, a whole package (packages/filmopen_format), a plan (plan:010) or a walk’s size (walk:1200x800).

A milestone suite is the core plus a chosen list of what the change could affect; the full suite runs at the major intersections only, such as a release candidate. The same selection drives every runner:

scripts/test_all.sh --core, --tests FILE (repeatable) and --full — the default with no argument — and scripts/test_all.ps1 -Core, -Tests FILE,… and -Full. A selection runs each chosen package in its folder with the named files, or whole, and the root’s files under the root’s flutter test; a bad entry ends the run before anything runs, exit 2, naming the list, the line’s number and a code (bad-entry, no-such-test, no-test-folder) — never the line’s text, which could hold anything a caller pasted. Plans and walks in a list are ignored there. scripts/test_all.ps1 also runs the repository’s own Python tests in every mode, after the selection is checked and before the packages — python -m unittest discover -s scripts/tests -p test_*.py -v, named with its folder and the python found, ending test_all: done scripts/tests with its elapsed time and exit code — and a failure there fails the run whatever the later suites do; no python on PATH is refused (test_all: refused scripts/tests reason: no python on PATH, exit 1). On Windows the tests that run a Linux-only script (scripts/gate.sh, scripts/agent-run.sh, scripts/agent-vps.sh) skip, naming it, and the rest need bash and cmake on PATH (MSYS2’s usr\bin and ucrt64\bin, after the Windows Python).
scripts/gate.sh runs dart run scripts/gen_field_maps.dart --check among its checks, whatever the selection (scripts/tests/test_gen_field_maps.py: every type written with its record and its change view, LF, its lines on stderr from start to the elapsed time; --check passing on a fresh file and leaving its bytes, failing on a stale one naming the difference and on a missing one, writing nothing; an unknown argument and --out without a file each refused with 64, a check of a file that is no UTF-8 and a write that cannot be made each failing with 1, every one logged from its start to done: with its code and milliseconds; writing over a file that is no UTF-8 replacing it and saying it changed; test_gate_script.py: a failing check failing the gate with its code). It requires one of --full, --core, --tests FILE or --no-suite, passes it to test_all.sh, adds the lists’ walk: entries to its --walk sizes, and names it in its summary (selection: core + list.txt, selection: none (checks only)). It never runs a plan.
python3 test_plans/run_mcp.py --core and --tests FILE run the lists’ plan: entries, and --plan takes a comma-separated list; a selection keeps the runner’s own order and its project handoffs. A list’s plan:130 is test_plans/run_report.py‘s and is not run there. A wait for idle not met is said — idle wait not met: with the last tap or step, the answer and its seconds — and counted, never a failure: the common app’s summary and each separate plan print their count, and the exit status stays the checks’ failures. A tap that opens a menu waits for no idle, which the driver does not meet while a menu is open, and says so; the plan then taps its item (scripts/tests/test_run_mcp_dispatch.py).

python3 scripts/select_tests.py <git range> proposes the chosen list from the files a range changed: every changed package with a test/ folder whole; every workspace package that depends on a changed one, directly or through others, whole, naming the changed package it reaches — the graph read from the pubspecs’ dependencies, and their dev_dependencies too, since a test breaks when its fixtures’ package changes; every root test file when the application depends on a changed package, else the root test files whose row in the table below names a changed root file (every root test file when no row does); and plan:NNN for a changed plan. A dependent without a test/ folder is a comment line, as a changed one is. The root’s own pubspec.yaml and pubspec.lock are not followed. It is a starting point to edit, not a rule, and says so on its first line. A range git refuses, or one shaped like an option, is refused (bad-range), as is a testing specification it cannot read when the table’s rows are needed — a changed root file and no changed package the application depends on (no-spec).

The close smoke plan test_plans/040_media.md covers media through the UI and MCP control, at 1280 × 720 and at 700 × 800: every kind uploaded into the place a person chose — a clip refused by a picture place and taken by a character’s Motion clips, always shown — each checked on the file’s media container, the batch item’s n and group and the folder, every media: identifier on the page naming its place, and the tile’s provenance strip read through find; a picture place’s refusal of a clip read as the sentence it says; a favourite, a move, an archive and its undoing, and a delete whose take’s file and thumbnail, seen before, go, each read back from the file. The runner works in English, the one language shown, since it chooses a menu’s items by their labels. Its places check retains identifiers read before scrolling and reaches Motion clips, the card’s last place, before checking the five places’ Upload and no Add a place…; a location’s three places, no voice and no Add a place…. Its §10 case leaves and returns to a page during an import held by a loopback server, checks the place’s own job tile, its Stop and its disabled Upload, then completion, and verifies one take, one batch and one entry with intervening typing retained.

The close smoke plan test_plans/050_keys-dictation-usage.md covers the speech keys on the two speech providers’ pages — fo-openai and fo-xai, planted in a development folder, which every speech step needs — and a development-folder plug-in’s own key on its page, inline dictation and Usage with fake credentials and scripted speech. It observes the default service before a missing-key failure replaces its tooltip, then chooses OpenAI and Grok explicitly and checks their models, setting events and separate totals. The actual message’s Open <provider> action is discovered and pressed immediately, and lands on the provider’s page. Summary is a prose box: while listening it shows the words provisionally, with no caption, and its file keeps the committed baseline; the second press commits the text once, and page departure cancels and restores the exact baseline. Each attempt requires its own new terminal event and expected file outcome, rather than a delay or an earlier attempt’s event. Usage is zero only when its explicit empty sentence is present and its row controls are absent; accepted sessions require the populated controls and new Done rows with their file, minutes and cost. Light and dark captures show the provisional words and blue microphone, while selected service text withheld from agent values is checked on the pictures. The timestamped hold and keyboard rules remain widget-test and desktop-walk checks; the scripted agent does not prove hardware or live-service behavior.

The mutable document-copy regression also runs against the web runtime: from packages/filmopen_format, run dart test --platform chrome test/json_document_test.dart. It exercises clearing/refilling a decoded draft and the typed iteration used by the form after attachment.

The acceptance walk (scripts/agent_walk.py) waits for each event an act logs — an import’s media.imported, Compare’s durable compare.copied, a save, a fork, a player’s release — from a log mark taken before the act, over the app’s whole 500-event ring, so neither an earlier event nor a burst after it (save, refresh and sync events can follow before the tap answers) decides the step; every wait the walk polls prints its start (an event wait its mark and the events it reads, a timed wait its bound), its outcome and the time it took, and a refused log read is named in its failure line. A walk line masks only a VM service URL’s auth code. It reaches a fork’s exact child within page.tree before checking the row and its file. Plan 020_character-location.md scrolls the page body up to Compare’s heading before whole-copy, then retains its file assertion that copying does not remove the left version’s other values.

The template is the plug-ins repository’s: a suite that reads it (filmopen_plugins, filmopen_plugin_host, the root) needs the staged bundle, plugins/stock.json, which scripts/test_all.* and the gate stage first.

A replay has a 20-minute cooperative deadline that closes only its owned server input and permits the ordinary cleanup; expiry fails with status 124. The numbered runner bounds its replay child to 22 minutes, retaining partial stdout, stderr and status on timeout. Before cleanup, failed input is copied in full; a retention-copy failure is itself a failed check and keeps the original task home available rather than deleting the only input.

File	Covers
`packages/filmopen_exchange/test/exchange_id_test.dart`	Every type’s group, key and stem forms, the manifest and batches, UUID and dotted tags, a 32-character username’s allocated epoch and outfit ids parsing as key and stem, and the refused spellings, a 33-character author and an owner of 33 among them.
`packages/filmopen_exchange/test/import_reader_test.dart`	File places, full-stem identity and source hints, dollar decoding, optional envelope, whole-document refusals, skipped structure/catalogue, unknown collections, malformed elements/ids/epochs/directives, duplicate normalized patches and all sample export file objects.
`packages/filmopen_exchange/test/plan_test.dart`	Current picks and explicit project selection; own updates, foreign and library forks in both guard modes; project-only development override; all creation reasons, epochs and missing sources; dry permissions and snake-case validation details; base-only vanished identities; total states; bounded answers; canonical consent comparison and carried-stage snapshots; source-hint precedence, scope hash replay, moved picks and conflicts including removals, null and literal root keys; a conflict on a path the baseline’s projection excludes suppressed and said skipped, and a selected absent value added meanwhile still conflicting. New children entries require folder/scene types, stored entries stay unchanged, and non-list children is invalid content. Project declarations validate the whole list, deduplicate trimmed labels, allocate like the store and merge content in one change; epochs-only base conflicts, viewer/read-only refusals, foreign forks and same-import creative epoch resolution are pinned. The sole explicitly unused era relabels, explicit scene/version/location/cast/prop use blocks it, an implicit starter scene permits it, an omitted year clears, and same-year labels stay distinct; planner/writer equality uses an explicitly occupied era. Naming the sole era anywhere in the list claims it, preserving its token and appending the unknown label with reason claimed in either order. Birth-date changes fill numeric age and review paths with full diagnostics; summary-only edits and unchanged date echoes preserve age; malformed dates remain with their reason. Project-last aliases rewrite only typed positions, refuse bad aliases globally and detect rewritten duplicate ids; a same-import era year fills age 22. Character seeds replace group refusal while locations retain it; planned first-era sources and explicit age overrides/removals are pinned. A proposal’s change breaking its record refused with its problems and logged `import.plan.record`, a valid sibling change applied; an export echoed back with a legacy key applied.
`packages/filmopen_format/test/epoch_seed_test.dart`	Default pick, sole retained era, ambiguous/empty/no-pick refusals; exact look and picture clearing, retained voice binding and inspirations/unknown data, preview removal or retention, independent copies, numeric age fill and phrase age retention with shared decision details.
`packages/filmopen_exchange/test/apply_test.dart`	Serial independent apply, skipped changes, content-only updates, retained stages, pick-only recovery, partial and unexpected failures, ordered immutable outcomes; the planner supplies dependency order.
`packages/filmopen_exchange/test/import_writer_test.dart`	Guarded updates, forks and creation headers; stale refusal without blocking another file; captured importing viewers; store failure codes without text, each caught failure of an update, a fork, a creation and a retained pick logged `import.write.failed` with its stage, type, words and stem; library forks in both modes; partial creation and project/scene artifact recovery; completed outcome carry without another store write; comparison input purity and contributor normalization, a plug-in’s setting kept. Declaration and content use one project save; per-entry success/refusal logs carry values and code/stage, foreign forks recompute the epoch floor, and pick-only recovery emits no declaration event. A sole unused era’s relabel is saved or refused honestly with the old values and its content-stage outcome logged. Project-last aliases apply through the guarded writer; missing cast versions precede scenes, honor override/newly declared eras, distinguish planned sources, support both newcomer routes, preserve explicit root removals and actual provenance, refuse ambiguity/no-pick without losing the scene, and skip unchanged scenes.
`packages/filmopen_exchange/test/patch_document_test.dart`	Pure leaf merge and explicit removal, null and empty values, all identified lists and their addressability, stable insertion, block allocation at the original floor and replacement/removal, canonical equality, identity, protected keys, shapes, directive order and whole-patch refusals. Project and folder children replace whole, retain pinned references, echo silently and support explicit replacement/removal. $declare belongs to the planner on projects and remains ignored on other types. A key its record does not name refused `record` with each path and value, a stored null included; an unchanged old key, a block’s partial merge, a whole replacement echoing an old block passing; a changed item held whole; an object the patch makes held whole (a prompt without `positive`, a rate without `den`), a replacing list to its bounds (a CDL pair); a `null` on a defined key stored in a new or replaced block, never an unknown key’s, an item of a list (a CDL slope, new or standing) or a member of a rate, made or merged; the result independent of the input.
`packages/filmopen_exchange/test/filing_test.dart`	New scenes filed under an existing folder; failed/refused creations leave the parent independent; new season and scene filed under the project; entity.saved children and import.write.failed diagnostics; focus base detects changed children and a parent not exported whole.
`packages/filmopen_exchange/test/reference_examples_test.dart`	The sixteen import reference examples against the sample’s full source documents, with retained fields, exact paths, allocator counters and atomic refusals.
`packages/filmopen_exchange/test/apply_round_trip_test.dart`	Both viewers and all seven sample scopes through export, leaf patch, dry plan, guarded apply and export; exact picked content, cross-viewer ownership, moved picks, local library forks in both guard modes, and unchanged null/empty/id-less/manifest echo without writes.
`packages/filmopen_exchange/test/import_round_trip_test.dart`	Both viewers’ seven frozen export scopes read and patched onto their exact full source documents by stem, yielding no changed path, removal or patch note; group names accepted without ignored-key notes, with prescribed manifest, batch and structure information retained.
`packages/filmopen_exchange/test/picked_script_test.dart`	Picks descended despite differing pins, duplicate and cycle termination, flagged rows and unfiled folders and scenes.
`packages/filmopen_exchange/test/export_entity_document_test.dart`	`exportEntityDocument` exports the supplied draft, not the file, with its exchange identity, the whole projection and recursive escaping
`packages/filmopen_exchange/test/selectors_test.dart`	Every structural and content selector; shared and unfiled folder descendants, cycles and silent scans; cast and block speakers, outfit precedence and fallback, epoch overrides, props, library style, FDX outfits/resources, shots, cues and unresolved paths; a scene walk groups the cues once, and none for a scene with a cues list, its output unchanged.
`packages/filmopen_exchange/test/scope_test.dart`	Registry descriptors, arguments checked before selection, group/concrete projection union, exact nine-scope recipes, `focus`’s overview/whole unions and argument refusals, `scene_dialogue` with a scene under another folder and a character who does not speak in it, ancestor boundaries and speaker-field union.
`packages/filmopen_exchange/test/assembler_test.dart`	Envelope and wire order, UTF-8 bytes, content and source hashes, selected project/frame, group epochs, flat spec objects, manifest/catalogue/batches, picked sources and script, shared-folder scene closure, cast-only empty blocks, library origin, staleness, notes, escaping and context problems collected once including late file failures.
`packages/filmopen_exchange/test/focus_export_test.dart`	Stored project children and epochs, named folder descendants and scene closure whole, outside synopses, full script order, export identity and union sources, empty focus as overview plus children with whole characters and locations, a scene’s focus carrying used and unused ones whole at every era, changed-children source-hash replay and bytes no larger than all.
`packages/filmopen_exchange/test/lean_export_test.dart`	The lean export on a tiny film: every `$id` and the selected content, no `sources`, `sha256`, `$stem`, `export_id` or `exported_at`, no unselected notes, negative prompts or media; the script walked only where scenes are selected (the full export walks it always); a working version written in place of the version in use, once, and refused on a full export; the full export’s bookkeeping unchanged by the flag; an entity document exported lean without its `$stem`.
`packages/filmopen_exchange/test/export_goldens_test.dart`	Fourteen fixed-time bundled-sample wire and canonical-content goldens for two viewers and seven scopes; stable ids across times; project/group/source structure and exact dialogue example.
`packages/filmopen_exchange/test/doc_example_test.dart`	The specification’s complete export example matches the public API’s wire output, including content id, source hash, timestamp and frame.
`packages/filmopen_exchange/test/projection_test.dart`	Labels never selecting whole-file rules, whole and everything with their omissions, where notes travel, unions, identified-list and speaker composition, media by reference; model-facing media retaining unreviewed entries and their picks/preview, without archived or deleted entries, references to those dropped entries, or `kept_at`, empty containers kept, everything keeping all; the input never altered and key order kept; the narrow media projection walking each block’s `media` as the entity’s: archived and deleted entries dropped, unreviewed entries retained, `kept_at` stripped, a container emptied by the drop removed, an empty one kept, `preview` and `picks` naming a dropped block entry dropped
`packages/filmopen_render_ui/test/render_dialog_test.dart`	Provider headers and concrete model/platform rows at 1200 and 700 pixels; unavailable route reasons and catalogue-only missing-adapter rows, preserving context exclusions and route retention; at a block’s clip its usable frames and voice line chosen and sent by name, including unreviewed frames, with chosen flags logged, Pro’s ten seconds leaving a line out after a route’s change, a person’s line the way replaces no longer theirs, the rows fitting at 700 px in dark, a row only where the row maps and the block gives, the sound line’s four codes, a continued take given its recorded inputs, and a failed choice holding Render; a clip’s prompt naming a character’s and a location’s sheets sent as `reference_images` in the reference way’s placeholders, in first-appearance order, three where the way takes two refused, never cut, the text way refusing them `no-placeholders`, no voice line on a way that takes no sound, and `render.inputs.given` counting the pictures with `tokens: offered` or `none`; the clip card’s writer handed the clip’s tokens only on a way that takes pictures; the card at a clip holding the block’s own words
`packages/filmopen_render_ui/test/render_dialog_test.dart` (a lent route)	a lent offer one more route at 1200 and 700 pixels, light and dark, named Shared on the website or Your other computer followed by what tells two apart, priced at what it will send, and sent with its offer and price
`packages/filmopen_render_ui/test/render_dialog_test.dart`	Outfit sheets capture the exact-epoch character pick and its hash as the dialog opens and the outfit’s hash at Render, retain usable kept and unreviewed references in order, check reference bounds inline, refuse changed sources or bindings and initially foreign targets, each refusal logged with its reason (`render.outfit.sources`), and preserve ordinary outfit rendering.
`packages/filmopen_render_ui/test/render_dialog_test.dart` (an outfit’s sheet’s card)	the Prompt card on the outfit’s `prompts.sheet`, logged `render.prompt.bound {target: outfit-sheet}`, read-only with no page open, no line of joined words under it; typing or Generate in the card then Render sending the outfit’s words alone and its new snapshot, never refused; the character changed after opening still refused, `reason: changed`; a parent portrait and the outfit’s `@reference-1` both sent, the token written `@Image2`, the character’s words and their token not sent; a picture the character holds and the outfit names sent once; a picture both hold sent once in the composite, as logged; a token in the character’s words alone offering both modes; a token added in the card turning the offers to edits, removed back to both modes; five composite pictures on a four-picture model held, the character’s three and one named not, the character’s four and one named refused whole, never cut, `render.outfit.inputs {character, outfit, sent, words: own, references, entries, skipped}` saying which; a prompt-only model `from: none`; the outfit’s negative alone, the treatment once; the bound’s refusal logged `render.outfit.bound {outcome: refused, reason: referencesBelow
`packages/filmopen_render_ui/test/render_preparation_test.dart` (an outfit’s sheet)	`renderOutfitPromptInputs`: the character’s pictures first, then those the outfit’s words name, each once, the outfit’s token written by its place in that list (a portrait and `@reference-1` → image 2), a token naming nothing missing, the whole list past the bound and a row with no form refused, none named giving no pictures and no refusal, logged `render.prompt.tokens {kind: outfit-sheet, character, outfit, words: own}`; `renderKindAt` at an outfit’s sheets `i2i` with inputs and both modes without; `promptCardTargetAt` `outfit-sheet` there, on `prompts.sheet`
`packages/filmopen_render_ui/test/render_dialog_test.dart`	Same-name GPT input modes have distinct menu and selected labels at 700 and 1200 pixels, preserve model and route identity, and send references only for the reference-taking model; a sole model retains its name across routes.
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the stage, the span, the references)	the stage selector opens at the version’s own `render_stage` (Prototype where it says none or one of another shape), logged `render.prepare.stage`, and Render freezes it into the request, the film’s document untouched; a render continued from a take asks at the entity’s stage, not the take’s; a forced take’s selector held with why; a block place covering blocks shows Through block {n} at the last block’s position, none for the owning block alone, an extent, a gone block or an entity’s place, and no second chooser; unreviewed and kept renders both feed the outfit composite’s references (§9.3)
`packages/filmopen_render_ui/test/render_dialog_test.dart` (a ready server of the person’s)	the model picker’s default on a route that is not ready gives way to a ready server the person started, logged `render.route` with the route’s label, destination and `reason: ownServer`; a ready server its provider listed and this app never started leaves the default (`picked`); Recommend names a server’s own label, not its engine’s platform, logged `render.recommend` with the line’s text before any tap (`reason: shown`), and again once when Final changes its words, not per rebuild; the line drawn while the plug-ins are read logged as shown; a server chosen that goes logs the place it fell back to with `why: serverGone`, and the picker’s place on this computer gone the next with `why: ready`
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the last options)	a model, a route by its destination, a way and a value reopen over the picker’s row after Render; Add to batch keeps them too, as its log says, and cancel nothing, logged `render.remembered` and `.write`; at a block’s clip and an outfit’s sheet with no picture named, which ask no picker; a model not offered falls to the picker’s row, a way or value not taken to the route’s, logged `render.settled.changed` at whichever answer drops it and whoever chose it, on a stage’s row (`picked`), a readiness return, another place or model (`routeReset`) and the person’s own change (`chosen`), the quote the settled choice’s; another media’s or stage’s entry disturbs nothing; a forced render and a voice neither read nor keep them, a take continued does not read them, saying why
`packages/filmopen_render_ui/test/render_preparation_test.dart`	The shared preparation (§6.15): the request it builds equals the one the dialog sends from the same place, asked-at aside; a prompt given replaces the entity’s words with the treatment after them; the model picker’s default the offer, with its route’s quote; at Draft the picker’s model, route, way and settings, the dialog’s and the preparation’s request alike, a setting the options do not offer dropped, never sent, and logged `render.picker.params`, with `render.picker` and `render.route`; no picker, a row naming none or a failed call `no-default` with that reason and nothing opened; the picker’s plug-in not offered here: nothing prepared, `render.route` `noRoute`; a character’s reference pictures offered only `t2i` entries, the offer stage logging the kind; a character’s, location’s or prop’s reference pictures and sheets and a block’s first and last frames `i2i` with inputs and `t2i` without, a character’s motion clips `i2v`, an outfit’s places and others no kind; the prompt’s pictures (§9.8): a token picking an edit, the words in the row’s form, the pictures sent in first-appearance order, `render.kind`, `render.prompt.tokens` and `render.prompt.placeholders` carrying each token, the picture it names, the form and the words written; a block’s frame naming a character’s sheet sent that sheet; a first frame naming a character’s, an outfit’s, a location’s and a prop’s sheet sent the four in first-appearance order, each token in the model’s placeholders, and refused `references-count` by a model taking three; the Prompt card at a block’s clip on its own `prompts.clip`, never the scene’s words; `tokens-missing`, `references-count` and `no-placeholders` refused before any request; the writer’s target `character-reference` at a character’s reference pictures, `character-sheet` at its sheets, none elsewhere; a character with no words of its own given the writer’s, the treatment still after them, `render.prepare.prompt` saying `writer` with the words; the character’s own words or the words given the person’s, the writer never asked; a writer that fails `writer-failed` with no request, its code logged here and its message in the host’s `render.prompt.done`; no writer, `notAvailable`, `no-prompt` or blank words with nothing else to say `no-prompt` as before, each `none` with its code; at any other place the writer never asked, other places no kind; nothing ready is not ready with no request; a route that cannot say what it offers fails, logged by stage, type and the error’s message; the dialog’s own trail carries no `ref`, ends `done` on Render and `closed` on Cancel; the route kind lent, server, paid, local in that order; the picked variant bounds resolution and duration before the request, with one render.variant log of the model, stack, replaced names and elapsed time; the treatment’s style (§8.7) stored, never added: the prompt and the leaves sent without its words, its reference carried in the treatment, the plug-in never read, no style logged, the dialog’s request alike; the dialog’s Prompt card at a picture’s place of a character, a location, an outfit and a prop and at a block’s frames (`promptCardTargetAt`, `renderPromptPathAt`), an outfit’s composed sheets and every other place keeping the box; at voice samples keeping no voice, a design: no picker asked, the kind `voice` offered, its request the voice’s prompt with the audition text as `text` (none where empty) and no `voice`, refused `audition-length` outside the model’s bounds and `no-voice-description` without a prompt, logged `render.voice.mode` `design`
`packages/filmopen_render_ui/test/render_preparation_test.dart` (the last options)	the preparation opens on the remembered row and its values rather than the picker’s, and with no picker row; a value no longer taken settles, logged; a clip with a first frame after a `t2v` choice is `notOffered`, the picker’s row, and after an `i2v` choice the remembered row
`packages/filmopen_render_ui/test/render_preparation_test.dart` (Settings → Models)	§6.15, §9.4: a Settings default stands before the last options and the picker, logged `source: settings`; Final takes the picker’s settings for its model, at Prototype where Final names another; Draft is Final at the lowest listed resolution (the catalogue’s Z-Image `512x512`, Nano Banana’s `512`/`1K`, a one-resolution Kling variant equal to Final), the tokens ordered `WxH`, `NNNp`/`NNNP`, `1K/2K/4K` and a bare side, another form placing nothing; a default whose model or route is not offered gives way to the last options, else to the picker’s own answer, logged `refused`; with none the picker answers, logged `settings: none`; `prepareRender`’s `stage` and `remembered: false`; last options kept flat reopen by plug-in and platform, and a choice saved now reopens on its own key
`packages/filmopen_render_ui/test/render_preparation_test.dart` (the role)	§9.4: `renderClipRole` from a clip’s inputs; an outfit’s reference pictures `t2i`/`i2i`; a frame pair’s and a frame and line’s clip ask the picker the clip’s own kind with no default or a cleared one, and open on a chosen one; a new clip’s `t2v` default, in the preparation and in the dialog; a voice design on its `ttv` default, else its first ready model, the picker never asked for one
`packages/filmopen_state/test/render_defaults_test.dart`	`render.defaults` (§9.4): a stored default read and logged, an entry of the wrong shape left out; a choice and a clearing kept with `settings.keep.start` and `settings.kept`; nothing stored, or an unreadable value, is none, said why
`test/settings_models_test.dart`	Settings → Models (§9.4) at 700 and 1200 px, light and dark: Text followed by Speech service; a card for each kind with a model here and none for the others, logged `settings.models.shown`; a model chosen kept with its route at the stage shown, another route chosen below, The picker’s default clearing it; Final its own default; one resolution says Draft has none lower; two places of one route are one choice; a model chosen again keeps its route; a route is named by its platform, never a place; a default kept for a model not offered here, or for a route not offered of a model that is, reads as the picker’s default, kept, and is logged `unavailable`; a choice the store refuses holds and is said under its card; on Final, Draft’s sentence where Final and Draft settle to one value on the chosen route — no picker row, the route’s default the lowest; a route offering no lower value than the picker’s — and not where the picker’s settings ask a higher one the route takes; a refusal said at its own stage only
`test/settings_models_test.dart`, `packages/filmopen_state/test/route_words_test.dart`, `render_dialog_test.dart` (a route’s words)	a route read by its plug-in and origin (`renderRouteLine`): Your key, FilmOpen credit, this computer, Codex on this computer, a place’s own name in the render dialog; in Settings a route a server comes first on reads as its local candidate, this computer, its funding and words logged in `settings.models.read`; a shared offer beside a saved key is its own route, Shared on …, never Your key, its candidate funded `lent` (`lent_render_test.dart`).
`test/agent_host_test.dart` (Models)	at 1200 and 532 px, `set_tab models` opens Settings → Models and the state reads `models`; the stage’s segments are no tab
`packages/filmopen_keys/test/usage_tab_test.dart` (tokens)	a plan’s and a local use’s tokens among the line’s details, N in · N cached · N out (§6.7)
`packages/filmopen_keys/test/provider_keys_tab_test.dart` (help and credit)	a key’s help draws its addresses as links, a sentence’s period outside them, a tap opening one, logged `keys.help.link`; an address that is no URI opens nothing, said and logged `refused: notUri`; the credit sentence follows the owner’s route where it names the card’s key
`packages/filmopen_machine/test/machine_reader_test.dart`	one shared read, including in flight, a missing command’s words logged; probe timeout; nonzero exit logged with its code, output and errors; the facts read logged; an unexpected failure logged by stage, type and message and answered unknown; Windows running `nvidia-smi` alone — the exact arguments, its cards and the command logged, a nonzero exit, a timeout, a missing command an empty incomplete list; phones and macOS never probe; web stub
`packages/filmopen_machine/test/parse_linux_test.dart`	captured facts and socket/core pairs; missing GPU command, absent core ids and garbled sources unparsed; NVIDIA MiB conversion and several cards
`packages/filmopen_render_ui/test/machine_command_test.dart`	local memory verdicts, failed requirements first, short reasons floored to one decimal with raw checks retained, unknown and unverified checks and the shared pool; one command line per local model, work logs, and an honest unexpected failure logged with its stage, type and message
`packages/filmopen_render_ui/test/auto_references_test.dart` (activity and Stop)	one activity line per entity — its prompt while written or waited for, its render with its job, gone at the job’s end; Stop removes a writer waiting its turn and signals the running one through its call’s control, forgets the follow-up, writes and renders nothing; a late answer is not written and starts no render, and a later write renders; Stop during the render’s preparation submits nothing; a submitted render is stopped through its job and reads Stopping until it ends cancelled; an unconfirmed stop and a refused one stay with their reason; a write heard while a stopped render settles is new work, its line clean and reached by the next Stop; Stop while the prompt’s patch waits behind another patch of the entity writes no words; and in `packages/filmopen_state/test/auto_references_test.dart`, each change of the engine’s lines logged as it is set, two changes before any frame logged as two events
`packages/filmopen_render_ui/test/auto_references_test.dart`	Auto-generate reference images (§6.15), on a fixture with a stand-in backend and insertion: the box off, a person’s write, a type with no reference and a write of only media or prompts rendering nothing; a character’s change rendering at the reference place under the chat’s attribution, and a location, a prop and an outfit each asked of their own writer and rendered; an identical fork nothing and a changed fork a render; an empty or a writer’s prompt written with the writer’s pair through the attributed door, a person’s words standing; five writes during one job giving exactly one more render on the last data; another film’s write with the same stem its own and no writer asked for it; a quote above the line, another place of the same route, another way of running it and another key alone left unmade, logged with each side’s route and said under the box, a read of the line with no backend saying so, a paid writer not on it left unmade with no words asked for, the line read again on that writer’s refusal and on a route no longer ready, which is said in a sentence; the line naming both routes and the writer in the dialog’s words; no route; a Final-stage character and a remembered route still rendering at Prototype on the line’s route; the box unticked while the writer writes submitting nothing, and the box unticked or the film closed while the line is read asking no writer; a read of the line logging its start and what it waits for before the wait ends; a failed render said under the box and the entity free again; an unexpected failure logged whole, said in a sentence and not by its text, the entity free again; during a press, ten entities written while the first prompt is written each waiting its turn and rendering once, and a prompt waiting its turn never started once the box is unticked; a real `builtin/create-entity` with its content asking one prompt, from the content, and rendering once, with the line ready and while it is read, and one whose first prompt got no words not asking the writer again on the same data; a prompt written while another create holds publication sent on the words and the negative just written, not refused `no-prompt`; an insertion attached while the projection shows the render’s acknowledgement pending said rendered, and one whose acknowledgement failed said not rendered with its code; Use the LLM changed with the box ticked reading the line again with the writer that will run; a program route on the line asked for its options with its program and rendered on it, and a line changed while ticked leaving the reference outside it unmade, said, and the next one rendered on the line as it now reads; a job dismissed while it waits, through a real job engine, ending the wait as cancelled, the line gone and the entity free, another job leaving the list not ending it; the work’s key, two references’ work held apart and every engine event naming its place; a Pick: a character’s rendering its sheet on the `i2i` route with that entry’s token and no chat’s attribution; a copied-in kept entry, an assistant’s write and a re-rendered reference rendering none; a location’s and a prop’s their sheets; a character’s rendering the outfits it wears that are picked and saying the one not picked; an outfit’s rendering with its wearer picked and not without; pictures A and B picked then C1 using B, C2 during it one more on (C2, B), the same pair ending it `unchanged-since-pick`; pick A, pick B, archive B, pick the character using A, and no usable picked entry `notPaired`; a person’s sheet words naming another reference, none, or the picked one and another a conflict, nothing submitted, and naming the picked one rendering; a writer’s words naming no picture on an outfit’s sheet, another picture than the one offered, or the picked one and another refused `writerConflict`, not written and nothing submitted, and a person’s words landing while the writer writes held to the same rule; no `i2i` route agreed `noRoute`, a route with no amount said as unknown before the render; the box off nothing; Stop during a sheet’s prompt; a reference’s work and its sheet’s held apart, Stop reaching both, one’s end not the other’s
`packages/filmopen_plugin_host/test/build_prompt_wait_test.dart`	a writer’s turn (§6.11, §6.15): two `buildPrompt` calls on one plug-in that runs one call at a time, the second asked to wait held then admitted and both written, not asked to wait refused `busy`, and a waiting call whose admission check says no once it has its turn released before it starts, refused `disabled`
`packages/filmopen_render_ui/test/render_commands_test.dart`	The built-in tools registered and exposed with their literal schema shapes unchanged and caller rules retained, a description’s length not bounded; `builtin/render-quote` and `builtin/render-image` (§6.15) through a real insertion runtime: the quote inserting nothing; the job id answered at once with the observation naming the entity; a billed and an unknown price running with their quote; a repeated key one job, a changed prompt `operation-mismatch`; the authority changed during the preparation refused with no job; the settings read again at the call refused `not-ready` with `settingsLoading` before the admission and no job, the same operation key running once they are read; `insert-refused` and a route not ready `no-route`, each with its fixed reason; an empty prompt with no treatment’s words `no-prompt` before admission; a character with no words of its own quoted and rendered on the writer’s words, and a writer that fails `writer-failed` on both commands with no job; no picker, or a row naming none, `no-default` with the picker’s reason, and its plug-in not offered `no-route`, on both commands with no job; a scene `no-image-place`, an unknown target `not-found`, a closed film `no-project`; after a change, a versionless id and the original full stem both rendering on the person’s draft (`working: round`, `author: person`) and the quote naming the same version; without a draft the person’s own version in use; another author’s version in use `not-yours` on both commands with no preparation, no admission and no job; a take written into the person’s draft as the person, the job’s binding theirs; the lines naming the target, the prompt, the operation key and the app run’s session; `render-quote`‘s every argument asked on the start, the refusal and the end lines, a refusal with no project and one with no route included; `render-image` on a closed film, with the session `builtin/session` answered, logging that session among its arguments on the start, the refusal and the end lines; a style chosen read by neither command and none of its words sent; a location with no words of its own not written for, the commands’ writer a character’s alone; `builtin/add-media` through the same runtime: bytes into the person’s own version’s references (one reviewed entry, its `preview`, the chat’s record holding it, job-status naming the destination and the entry), a URL through `debugMediaHttpClient` into a block’s first and last frames, a voice sample, a block’s clip and an outfit’s references and sheet; `wrong-kind`, `no-such-place` (a place the type has not, a block on a character), `bad-source` (neither, both, no base64), `not-found`, `not-yours` with no job, `no-project` and `not-ready` before the admission; a missing block and a URL answering 403 accepted, then `needsAttention` with `wrongShape` or `badUrl` and the place’s sentence; a repeated key one job; render-image’s insertion attributed to the chat that called; the relay proof — a URL into Adrian’s references at 2030, bytes into his outfit’s sheet, a sound refused there — read back from the written file and written under `FILMOPEN_LIVE_OUT`
`packages/filmopen_render_ui/test/render_commands_test.dart` (the prompt’s pictures)	a prompt naming a picture that is not there `tokens-missing` on both commands, logged `render.command.refused`, with no job (§9.8)
`packages/filmopen_render_ui/test/render_target_view_test.dart`	a render asked while an update’s fork of another author’s version is landed and its publication held resolves the person’s draft, never `not-yours` (§6.15, §7.5)
`packages/filmopen_render_ui/test/render_status_test.dart`	`builtin/job-status` (§6.15): phases with progress, `needsAttention` and a failure’s code, `render.status` logging the code it answers with; `not-found`, a live job render-image did not start too, each logged with the job asked; a done job’s take, its link minted once for two concurrent relay readers with the picture inline, minted again after its expiry, the link alone where the result would pass 1 MiB; voice and text without a link, a take’s size from the store’s length and its bytes never read; the gate gone before the upload uploading nothing; a refused upload `media-refused` and not kept; a minted link’s picture answered by `mintedMedia` with its life left until it expires, any other URI none, the link logged whole; a link minted under one authority listed by `mintedLinks` and read under it, neither under another account, both again on return; a cached reader under another authority, or reading other bytes, not relabelling it nor changing its picture, nor an upload completing after the authority changed; an expired link left out of the list; an added file answering its destination and its entry for the relay, live and after its place dismissed it, never uploaded and never read whole; an added file whose take the store no longer holds `failed`, logged `render.status.failed`
`test/command_render_test.dart`	At 1200 and 700 px a command’s render says {who} started a render of {name}; through `pumpApp`, `builtin/render-image` on a character whose page is open, its take drawn first in the place and the done job dismissed there, then `builtin/job-status` still answering `done` with the take from the view it kept; `render.job.terminal` logging the job’s code and its take’s reference; the same render by the app’s own chat, the write that landed the take attributed to that chat and the chat’s saved record, in the ledger and in its file, naming the entity and `builtin/render-image`; `builtin/add-media` beside a name typed and not yet saved, both landing, the file drawn and dismissed, and job-status for the relay naming where it landed with no upload
`packages/filmopen_plugin_host/test/assistant_fixtures_test.dart`	the five primary VisualStyle leaves as Observed text
`packages/filmopen_store/test/declare_epoch_test.dart` (relabel)	`relabelEpoch` keeping the token, the floor and the entry’s other fields, setting or clearing the year
`packages/filmopen_store/test/declare_epoch_test.dart`	Declaration on the exact project version in use: guarded own save, foreign fork and pick, unused own version kept, workspace ownership, preserved entry fields and order, post-append floor, missing selection/viewer, blank label, read-only and changed or unverifiable base refusals.
`packages/filmopen_store/test/declare_epoch_pick_test.dart`	A declaration whose project fork exists but whose pick write races an arriving commentary exposes a typed partial failure carrying its token and stem; the existing commentary and official selection survive, with no rollback or retry, while public fork retains its usable-stem best-effort behavior.
`packages/filmopen_store/test/declare_epoch_allocation_test.dart`	Distinct same-owner bases may declare one id concurrently into their own guarded files; the refreshed inventory advances past both, and sequential declarations after refresh never reuse the previous id.
`packages/filmopen_store/test/create_at_epoch_test.dart`	Characters and locations copy the exact resolved source epoch into a declared missing target as independent v1 documents with provenance; canonical groups, hidden authors, library sources, stale picks, null/changed/deleted sources, target collisions and best-effort pick failures retain their guards; a character’s age filled from the default epoch’s year of birth even when the copy comes from another epoch, the copied age kept with its reason — no year of birth, no target year, a year after the target, no default version, an `appearance` copied as a sentence — and the decision logged before the write, kept when the write fails. The numeric birth-date fill gives age 22 at 2010 from a 2030 file born in 1988, reads the legacy default birth source, preserves the copied appearance shape even when the default source has another shape, and logs filled/kept with the shared refusal vocabulary and before/after values. The cleared seed skips default-pick age fallback, keeps active voice samples, logs its full source/document/age map, and labels drafts without picking them.
`packages/filmopen_store/test/fork_epoch_floor_test.dart`	A cross-owner project fork carries no floor of the source’s owner, plain or with supplied content, counting the forker’s own floor across their versions and workspaces and their ids in the folder and the copy; a same-owner fork keeps the owner’s high water across their versions and past their ids in the folder, against a lower, omitted or non-finite supplied floor, and keeps a higher valid one; late source changes and target collisions refuse without writing; a non-project document’s field is untouched.
`packages/filmopen_store/test/allocated_round_trip_test.dart`	A 32-character username creates a project, saves it, declares a second epoch (34 characters), creates a character and an outfit at it, and encodes and parses references to the outfit and the epoch, with no refusal and no naming warning for those segments.
`packages/filmopen_store/test/template_allocated_epoch_test.dart`	A new project, by an owner, a workspace or the unnamed user `default`, declares the creator’s `<owner>-1` as its one epoch with the caller’s label and year, and `next_epoch` 2, read back through the loader.
`packages/filmopen_store/test/allocation_inventory_loader_test.dart`	What the loader feeds the allocation inventory from both origins: the project’s declarations, floor and takes, library groups and pointers (a missing version’s pointer included) count; library takes and library commentaries are not indexed and do not count.
`packages/filmopen_store/test/identity_writer_directory_test.dart`	On a real folder, a new project’s `<owner>-1` supports a guarded declaration, an exact copy into the new epoch and a named outfit; a late changed project file, a late changed source and a late target refuse without writing or retrying.
`packages/filmopen_store/test/identity_writer_codes_test.dart`	A declaration, saved or forked, is logged as `epoch.declared` with the id, the stem written, the label and the year, a refused one not at all; the identity writers’ refusals print their class and identifiers.
`packages/filmopen_store/test/create_outfit_test.dart`	Dedicated allocated dotted outfit creation retains generic guards, accepts project/library parents at any epoch, preserves parent files, uses owner namespaces across observed references, refuses concurrent or late file collisions without retry, logs identifiers only and keeps best-effort pick behavior; a `draftLabel` making the outfit a draft, labelled and not picked, under the same allocated id; an outfit file the loader set aside, as invalid JSON or for a duplicate key, advancing the allocation past its id — at another epoch and author, and at the very path the creation would write, its bytes untouched; `outfit.createRefused` with the group and the epoch as they are
`packages/filmopen_state/test/boundary_test.dart`	FilmOpen dependencies are exactly format, store, fdx, media, insertion, jobs, sync, platform, l10n and exchange after explicitly filtering external dependencies; no library import or export, including a conditional alternative, reaches a widget or render package or bypasses a dependency barrel; spacing and comments cannot hide a later declaration or an import, including after a nested block comment.
`packages/filmopen_state/test/import_proposals_test.dart`	The proposals’ seam empty and silent until used; held as a frozen snapshot; discard and replace in place, a discarded one never revived; dropped at read for another film, another viewer or no project; an operation’s kept exports reachable only by it and released with it, a successful `nothing` included, and with its last proposal discarded or dropped; `import.dropped` once per proposal dropped at `current`, at `of` and by `release`, with its reason and the proposal, the film before the viewer, none for an export alone or a discard; Later’s `defer` flagging the proposal shown and moving it last, logged at its start with the flag and position it had and at its decision with the state it decided from and its time, the flag kept by a review and gone with another document under the id, and one replaced or let go since it was shown left as it is, logged with why.
`packages/filmopen_state/test/import_apply_test.dart`	Apply through the controller on an in-memory film: the folder read once, before the plan, and nothing after the write; an update decided on the view, a save landed and its publication held being the text reviewed; an update through the open draft written once and reseeded, the page left as it was; a change to the draft after the review refused `changed_since_review` with the draft untouched; an outside edit redrawing the review, nothing written; a stale file leaving the other change written, and Apply again then writing it at once against what was left to do; an update written and then edited by the person written again, never taken as done; a file another change’s re-read found edited refused before its open draft takes the content; typing during the import’s own write not taken as a refusal; a proposal replaced under its id shown again and never written, and one added during the writes kept; two proposals never applied at once; an update of the project file from the overview leaving the overview; a fork verified picked and opened; two overlapping Apply calls making one fork; an update of the pick a page shows leaving the page as it was; a handle changed during Apply refusing the later stages `viewer_changed`; a retained project fork recovered against the writer’s rewrite; the library forked, never written; a creation’s three stages; made but not picked, then recovered from the retained fork, refused `artifact_changed` when it changed, never forked twice; a recovery refused `artifact_changed` when a save of the retained fork lands while its pick waits in the queue, its publication held; a redraw’s log naming the scene, the value reviewed and the value now, and its time, with no `Instance of`; the film left, the handle changed or the film replaced while drafts settle dropping the proposal; a draft’s own refusal kept as the answer. Project declarations and content apply in one write without changed_since_review; a hand declaration after review redraws the next token without writing.
`packages/filmopen_state/test/import_apply_test.dart` (cast versions)	controller-seeded cast versions (§7.3): a 2030-only character created at 2010 before its scene; a newcomer at two eras seeded from the first planned version; ambiguous source refused with a note while its scene still applies
`packages/filmopen_state/test/import_apply_test.dart` (a block’s time)	a block’s import applies after its write, the time the writer stamps on the block set aside (Project Specification §10.3)
`packages/filmopen_state/test/lifecycle_hook_test.dart`	a `LifecycleHook` hears the state and answers the exit while it lives; called after its dispose it hears nothing, answers exit and logs `app.lifecycle.lateCall` once (§7)
`packages/filmopen_state/test/workflow_state_test.dart`	the workflow’s done checks (§7): an episode beneath the project done at project scope and not beneath a sibling folder, a folder counted at every depth, `min` honoured as declared and 1 when absent; a deleted folder’s scenes counting for the folders above it, a cycle, a second listing and a deleted scene not, each skip logged with its row, parent and reason; an episode taken off the Contents list not counted for the project while it still answers for its own arcs; an empty folder not done, listed or not; characters, locations and documents counted project-wide by kind and tag as each viewer resolves them, a library character counted as it resolves, a deleted one and an unresolved one skipped; a scene answering for itself; a field done with text, not absent, empty, spaces or an empty list; no `done`, an unknown check or type no check; the counts made once per snapshot and again after a new one; a folder version not drawn walked once on first ask; a throw in the walk logged with its stage and row and thrown on; the two preferences (§7) — the chosen plug-in kept under `plugins.prefer.script-writer` and none removing it, the ceiling kept as a number and none removing it, zero, a negative, NaN and infinity refused with the reason, both read back by a new container on the same store, a stored value of another type read as none and logged whole, a write that throws keeping the value for the session and logging `written: false` with the cause, and no store logged `no-store`
`packages/filmopen_ui/test/identifier_scope_test.dart`	`scopedId`: an identifier unchanged outside an `IdentifierScope`, and under the nearest namespace inside nested ones
`packages/filmopen_ui/test/boundary_test.dart`	FilmOpen dependencies are exactly format and l10n; every library import or export respects those barrels and cannot reach state or store; declaration spacing, external dependencies, comment-prefixed imports and conditional import alternatives are checked explicitly.
`packages/filmopen_text_ui/test/`	Prose source/shown offset mapping, captured edits, reference spelling, IME, field undo records guarded by surviving chip spelling, 8,000-character bounded history and re-emission eviction, typed and chosen reference collision regressions, chooser word boundaries and nonempty menus, chooser ordering and layout, unique semantics, canonical clipboard actions and field constraints; nested/escaped bracket pairing and deletion, exact surviving chip mapping, grapheme and multiline wrapping, ordinary atomic Undo/Redo, composing/base-style preservation and literal/paste exemptions; raw literal categories, identity offsets, captured edits, clipboard bytes, loaded limits and consumer source gates; exact dependency/development boundaries, conditional imports and exports, FilmOpen barrels and the web-safe Dart whitelist.
`packages/filmopen_text_ui/test/prose_dictation_reporting_test.dart`	Provisional source never reports an edit; an identical final reports once, cancellation reports nothing, and a source switch seeds without a user-change callback.
`packages/filmopen_dictation/test/controller_dictation_target_test.dart`	Plain captured insertion keeps provisional text outside the controller, retains the original range through selection movement, refuses external text changes, commits once through existing formatters and room shortening, and cancels without changing committed text.
`packages/filmopen_state/test/semantics_walk_test.dart`, `packages/filmopen_recorder/test/tape_test.dart`	Live dictation retains the last safe sampled value, preserving pending prior typing and an identical final after focus moves; live fields and captions are refused as tape values until the attempt ends. Caption and live-field hits keep their tap and scroll mechanics, labels and tooltips, unresolved within markers included. Identity-owned canonical registrations supply committed source before the first live sample without changing native display semantics.
`packages/filmopen_state/test/integration_seams_test.dart`	Inert account, funding and native conversation defaults; no audio or plugin-channel requests; allowlisted account serialization and explicit unknown balance; installation after first read, subsequent publication, departed-source notifications and disposed subscriptions; funding observation without admission; exact capture-attempt microphone ownership, wrong or stale releases and refusal of occupied replacement or disposal; ordered media-entry registrations and occurrence-specific removers.; the inert resolver’s `portalHeaders` and `receipt` answering none, `portalRefused` and `end` doing nothing
`packages/filmopen_render/test/server_catalogue_test.dart`	A 33-row unchecked catalogue asks with no arguments; selection asks one GPU class; exact matching, held metadata and price, unknown/zero capacity, raw quota present/absent/exhausted/malformed and transport failures refuse safely before deployment.
`packages/filmopen_state/test/deadline_test.dart`	Admission consumes the whole discovery budget; child and nested limits cannot restart or extend it; remaining time clamps to zero; cancellation is idempotent and flows only downwards.
`packages/filmopen_state/test/command_registry_test.dart`	The command registry (§7.3): `toolOf` an MCP tool with `_meta` kept and the separator a parameter, an effectful one idempotent; each registration refusal, the validator’s included; `unregister` by source or name, a source never registered logged by its name, nothing removed; a call answering the handler with `_meta`, each stage logged in order; an unknown command refused, logged by its source and name; arguments past the old 256 KiB running, with no bound on their size; arguments over depth, a malformed `operation`, and the validator’s problems `bad-args`; a relay call to an unexposed command `not-exposed`; a passed deadline before the handler; a throw `failed`, logged by type, stage and message; a result past the old 1 MiB answered whole, `command.call.handler.done` logging it by value with `ms`; an observation logged with its outcome and label; a handler’s error logged as it answered it. An argument its handler checks (`checkedByHandler`) announced and read at registration whole, left to the handler at a call, the rest still checked, `handlerChecks` logged. A validator that names the allowed keys has them in the `bad-args` refusal and on `command.call.schema`; another has none.
`packages/filmopen_state/test/command_ledger_test.dart`	The operation ledger (§7.3), through a command counting its effects: a replay answering the stored result with one effect; two concurrent calls one effect and one answer; `operation-mismatch` on other arguments, a changed authority and another command, which does not run; the authority changing during preparation `authority-changed` with the key free again; `stale-session`, `session-required` on the first call, `operation-required`; no bound on the entries, a new key past the old 256 fresh ones running; each new operation dropping the answered entries over an hour old, an admitted one never; expiry and the guard during preparation refused with no effect, a waiter receiving the same refusal; the deadline passing after `admit()` keeping the answer; a throw after `admit()` kept as `failed`; a second `admit()` refused after a first passed keeping the answer; a refusal without `admit()` freeing the key, a success without it kept; a success past the old 1 MiB kept whole, its effect once; `check()` answering `authority-changed` and `stopped` and admitting nothing
`packages/filmopen_format/test/block_merge_test.dart`	a scene’s blocks changed by id (§5.13a, §7.3): a key replaced, kept or cleared by `null`, the input never changed; `deleted: true` removing a block with its number kept, `next_block` written where none was; `insert` at `top`, `bottom` and after an id, several at one anchor in the order sent, the anchor removed earlier in the change refused, an insert after a block removed meanwhile landing after the anchor; an empty change adding no `blocks`; refused, the scene as it was: neither or both keys, a `deleted` other than `true`, an insert carrying `deleted`, an id or anchor that is no string, an unknown id, an id two blocks carry, `blocks` that are not a script; `output_duration_sec` updated, inserted and cleared, a value not above zero or not a number `badArgs`
`packages/filmopen_state/test/working_version_test.dart`	Lean entity export without `$stem`; one- and two-epoch group exports in declared order at each working version, deleted and undecided markers, decision logs carrying the id asked and the document answered whole, and group writes still refused without changes; the assistant’s working version (§7.3): the person’s unpicked `ai:` version the draft; no draft the version in use; the newest own version alone, never an older one or another author’s; the director’s star and the person’s pick ending it; a draft fork the viewer’s next version, labelled, not picked, a save in place keeping it and its label; an ordinary fork picked, without a label, never a draft; the label’s four words, its cut at 32 and its default; `as:` refusing any handle but the viewer, logged with both handles, and a missing viewer; `export {scope: entity}` reading the draft, then the person’s version, logging `working` and `base`, a save its stem as it is, refusing a missing id and an unknown entity
`packages/filmopen_state/test/entity_update_test.dart`	`builtin/update-entity` (§7.3): the first change forking the person’s version into their draft — the next number, labelled from `summary`, not picked, the base pinned, `entity.forked {picked: false, label}` with the label written — the next in place keeping the label, `null` clearing, a pick ending the draft, the next fork labelled `ai: draft` and the picked version never overwritten; a change that changes nothing not written, its merged entity logged; an object merging key by key — one nested key changed, its 24 siblings kept, the merged entity on the `merge` stage line beside the content as handed —, a nested `null` removing at any depth, a list, a string and a number replacing whole, nulls alone into no object making nothing (`unchanged`); the stages and counts logged, the saved stem as it is; a scene’s blocks updated, removed and inserted and counted, an unknown id and an item with neither key refused with nothing written; the project file pinned first where the person has no explicit pick, kept where they have one, never on an official base, which still decides, never pinned by a refused or unchanged call, the pin refused when the authority changes while it waits; `not-found`, `reserved` with its keys, a `deleted` other than `true` `bad-args` and a project file’s `reserved`, a library entity’s `epoch`, `invalid`, `no-project`, `no-viewer`, `read-only`, `stale`, `drafts-unsettled`; admission refused after the queue wait and before an in-place write; a duplicate answered from the ledger; a form’s unsaved text in the base forked; a collaborator with nothing of their own: the sole owner’s version pinned, the fork, a second change in place, the export reading the draft; the person’s own latest pinned, official and picked versions never; a write the disk refuses `failed {stage: write}` with `osError` 5 and 28 told apart and the message logged; a fork whose base cannot be read `failed {stage: read}` with `fork.readSource` logged by type and message and its re-read in the trail; a pick the person made while the pin waited kept, the update refused `stale` (`pin-changed`); the write and its re-read two stages, the re-read’s outcome logged; two calls at once, the second refused `stale` in the queue with what it found logged, and the next landing in place; a project file the reader asks about `no-version`; the destructive hint; a workspace viewer’s draft its own; `"deleted": true` deleting into the bin — the draft struck in the tree, the entity scope answering it deleted, the scope and the film index’s assembly leaving it out once picked, `deleted: 1` logged — and `"deleted": null` restoring it; `create-entity` refusing `deleted`; `command.update.start` logging the id and the content as handed; a birth-date change filling age at 2030, summary-only keeping stale age, null (including legacy age) and a malformed text keeping age with their trail decisions, a number refused by the record; a scene’s reference the change sets resolved, an `$id` refused `location:unknown` with the tags, an unchanged one not rechecked, a new block’s speaker resolved though the old cast holds the same value, and refused at a cast epoch with no version where the write makes no cast version; both writes’ descriptions saying a reference takes the tag, not the `$id`, and naming a block’s keys with a spoken line and an action, not `type`, `kind` or `text`; a block patch’s key its record lacks refused per key with its path, its value and the keys a block takes, logged, nothing written, a key already in the file kept; a spoken line, an action and a deletion in the format’s keys written. The content held to the entity’s own type’s record before any write: a block’s `type` and `text`, a top-level `foo` refused naming the keys with each value, `metadata` written, a valid change with deletions written, a value of another shape refused with the shape expected; the tool announcing each type’s top-level keys and the guide; content its record refuses refused before the drafts settle; a key holding a dot answered with its value.; `create-entity`’s description names `update-entity`’s guide instead of repeating it; both write tools announce `content` as an object pointing at `update-entity`’s description, each schema under 1 KB; a character’s `appearance_notes` refused with its allowed keys, the value and the same advice, in the answer and the log
`packages/filmopen_state/test/entity_update_test.dart` (`declare-epoch`)	`builtin/declare-epoch` (§7.3): an unused default relabelled with its token kept and its year set or cleared, in English or another language; one with a character at it untouched and a new token declared; two periods in order, the first relabelling and the second appending, a new entity at the first; a renamed default a new token; a label already declared its token with nothing written; a Stop while the drafts settle `stopped` with nothing declared; `bad-args` with its reason, a fork whose pick failed saying what it wrote; the tool’s description saying a period comes before what uses it, not that it comes first; `epochs` in `update-entity` refused with the pointer, a person’s own save of them untouched; the command’s and the writer’s lines; `declare-epoch` with `periods`: five in one call give five tokens in order, the first relabelling the default, each logged with its index; good, bad, good declares the good and names the bad in its place; a period written whose pick failed keeps its `failed` with `epoch` and `stem`, and the next is answered `unrun` with its reason, unwritten; a Stop ends the list there, refused.
`packages/filmopen_state/test/entity_update_test.dart` (`declare-epoch`, `with an AI draft of the project`)	A period declared in a turn reaches the turn’s draft (§7.3), in the order that saves the person’s words first: the notes update makes the draft, a first period relabels and a second appends, both on the version in use and on the draft, the token set and never duplicated, the new one last, the floor carried, the draft’s own text kept, the draft one item in the chat and each draft write the chat’s, and picking the draft keeps the timeline; `periods` answers `draft` in each period; no draft, the answer and the file as before with the reason logged; a label already declared writes nothing to the draft; a draft that is itself the version in use written once; another author’s version in use forked and picked, the older draft no longer the draft and nothing written to it; a draft write that fails, refused as stale or stopped before it leaves the call `ok` and the period standing, answering `draft: {error, stage}`, the log with its type, message and OS error.
`packages/filmopen_state/test/entity_update_test.dart` (cast versions)	scene companions (§7.3): an epoch update, both forked and in place, making cleared, labelled, unpicked character drafts recorded in the actual assistant chat review and command facts; synopsis-only content making none and logging unchanged
`packages/filmopen_store/test/entity_deleted_test.dart`	the recycle bin’s reader (§5.4): `isEntityDeleted` true only for `true`; a deleted version in use for one viewer and not another; the person’s pick deleted while the script pins an older live version, live in the script; an official scene’s character live through its official file while the viewer’s pick is deleted; a deleted sole version still resolving; `isGroupDeleted` at every epoch and only then; a script row deleted where its drawn version is, and drawn; copy-left never moving `deleted` either way
`packages/filmopen_exchange/test/deleted_export_test.dart`	the recycle bin at the exchange’s output (§6.18): every registered scope’s selection unchanged but for the deleted ids, which no body, `sources`, `script` or `unfiled` holds and each is reported `deleted`; a deleted folder’s live scene in its place in the script; a deleted location’s scenes still selected; a scene’s deleted reference `deleted_reference`, never unresolved; the pattern assembly the film index uses; another viewer’s live version exported
`packages/filmopen_state/test/deleted_export_command_test.dart`	`builtin/export` and the recycle bin (§7.3): a scope leaving a deleted character out, reported, `command.export.start` and the outcome’s `skippedDeleted`, `ms` and the answer whole as `document`; the entity scope answering a deleted draft `{deleted, stem}`, never the live pick, logged with the id asked and that answer, a live one as before
`packages/filmopen_forms/test/deleted_pickers_test.dart`	the reference pickers and the recycle bin (§9.3): a scene’s character and location lists, Located within and the mention source offering no entity deleted at every epoch for the viewer, one live at another epoch or for another viewer offered; an entity whose every version is discarded offered to no one
`packages/filmopen_state/test/entity_restore_test.dart`	Restore (§9.3): the person’s own file saved without the key, nothing forked; older `<owner>.ai` versions — a draft, one the person picked, a created v1 — and, in development mode, another author’s file, each another author’s and forked as the person’s and picked, no other author’s file written; a fork whose pick could not be written answered `forked-not-picked`, kept, not forked again; a fork the writer refuses logged `fork/failed` once, then its re-read; refusals `not-deleted` and `no-viewer` writing nothing; the start, the stages and the outcome logged with the stem as it is
`test/recycle_bin_test.dart`	the recycle bin on screen (§8.2, §9.3) at 1200 px light and dark and 375 px light and dark: the struck rows with deleted; the row opening the deleted version with its notice; Restore of the person’s own scene in place; the struck character row opening its deleted version, restored as the person’s fork, shown, the assistant’s file unwritten; a fork whose pick could not be written still said after the page re-resolves to it, with no second fork; nothing overflowing
`packages/filmopen_state/test/entity_create_test.dart`	`builtin/create-entity` (§7.3): a character as the person’s v1 at the first epoch with its content, labelled from `summary`, not picked, the draft, its stages logged, the created stem as it is; nested content merged into the seed as update’s is, a nested `null` no key, the entity as written on the `content` stage line; an outfit through its character’s door — the allocated tag `<character>.<owner>-<n>` answered as `tag`, its content, the draft not picked, `character` and `tag` logged — and one without a wearer (`character:required`), with an unknown one (`character:unknown`) or with a `tag` or a `kind`, and a `character` on another type, refused `bad-args` with nothing written; a declared epoch, an undeclared one refused; a scene numbered, made as the person’s draft with its blocks, listed in the parent’s draft where it has one (`into: draft`) so that picking that draft keeps it, else in the version in use (`into: in-use`), and listed in the project file written as the person, the door’s log naming the stems; a parent locked to another author refused with nothing written; a project, a workspace and an unknown type refused; a folder at the top with its `kind` stored as given, numbered `f1`, empty, listed in the project file; a folder inside a folder with content and no kind, its `tag`, `epoch` and `children` refused; a folder into the parent’s draft; a taken, invalid or missing tag; invalid content, a reserved key and an unknown block id refused before any write; a failed second write answered `created-without-content`, the version kept; a named folder as the parent, a scene or a missing parent refused, arguments not for the type refused and logged with their problems; another author’s parent refused in development mode too; a failed listing answered `listed: false` with its stage; a `$` key reserved; a scene’s creation queued, then stopped or its authority changed, writing nothing; the call stopped or the authority changed before the listing, the scene kept and the refusal said with its stem, `folder.childAddFailed` with its type; a second scene waiting whole in the children queue behind another’s held listing, its file not made meanwhile, then stopped or its authority changed, writing nothing; two scenes, and two folders, asked through the relay while the first’s file has landed and its listing is held, taking two short names, both made and listed; and again with the first’s parent written and its publication’s listing held, the first’s unpublished child kept in the second’s list; `command.create.start` logging the arguments as handed, the content included; two scenes or folders at once, the first’s publication held after its parent landed: both made and listed, nothing dropped, and no document the app wrote read back; birth date 1988 at era 2030 filling numeric age 42 with before/after trail metadata; a scene’s references resolved as the format does — an `$id` refused naming the tags and nothing written, a full stem and a typed resource accepted, an explicit epoch with no version refused and an implicit one falling back, a speaker at its cast entry’s epoch, a cast character whose version cannot be seeded refused with the seed’s reason, a location made earlier in the answer; a scene’s block in `kind` and `text` refused per key naming `action`, logged, nothing made, and insertions with a deletion written. The content held to the requested type’s record: a block’s unknown keys and a character’s `foo` refused with their values and the keys allowed, nothing made; under `metadata` made. A scene block’s prompt name on a character is refused with the names a character takes and the `advice` saying where it belongs, logged whole.; Write the Synopsis’s story as its prompt spells it: an episode folder with `notes`, its scene under the stem the folder’s answer gave with `content.epoch`, a tag-valued location and cast, `notes` and inserted dialogue blocks verbatim, an `epoch` argument on a scene refused `notForType`, and a second run’s `update-entity` by id keeping the notes, adding a block and making nothing again; the seed and its content published in one pass, every receipt heard with the entity whole; a character’s `appearance_notes` refused with its allowed keys, the value given and the advice that the languages a character speaks, habits and other notes go in `notes` or `voice.description`, `voice.lang` holding one code, in the answer and the log, a scene’s without it
`packages/filmopen_state/test/placeholder_scene_test.dart`	`builtin/create-entity` and a new project’s placeholder (§7.3), on a project `writeNewProject` made: the first scene made discards the untouched placeholder and the script lists only it, a second finds none; a renamed, a forked and another author’s placeholder kept; content that fails, or a listing that fails, discards nothing; a discard that cannot be written answered `failed` with the scene made standing; an edit that lands while the discard waits in its queue keeps it
`packages/filmopen_state/test/change_notice_test.dart`	The chat’s notice of a refused change (§6.11a): set by a write refused with its record’s problems, its paths without `content.`; corrected only by a later successful write to the same target covering each refused path exactly — the same block by id or anchor, an unknown key under `metadata` there; `metadata` alone, another block, an empty object, a lookup, another entity, a partial cover, an answer that is no JSON, a read of the same target, a call with no content or a refusal left as it was; a non-object `content` corrected only by a later write’s object.
`packages/filmopen_state/test/entity_create_test.dart` (cast versions)	scene companions (§7.3): creation with an epoch and cast making cleared, labelled, unpicked character drafts recorded in the actual assistant chat review and command facts
`packages/filmopen_state/test/write_receipts_test.dart`	the write doors’ receipts (§7.4): a chat’s `declare-epoch` attributed, its period an item of its own (`WriteKind.epoch` with the token and the entry), saved in place the period alone, forked the fork too; a fork, a created scene’s three writes (the create, the listing with its `before`, the content), a listing through the parent’s open form one receipt, a pick from and to, nothing for a change that changes nothing, every door of the inventory publishing (declareEpoch in place and as a fork with the writer’s stem, createAtEpoch, pickFromCheck, keepPick, abandonPick, setOfficial’s follow naming the new official, setDiscarded, createOutfit), a later save through a kept write context its own receipt, and a retry through it in the patch’s own settle after its write the person’s; the attribution — a chat’s create and update attributed with the command, the run, the operation, the assistant and the summary, a relay call none, the person’s flush in the command’s settle none
`packages/filmopen_state/test/render_jobs_test.dart`	every render job under way (§6.15), on a stand-in service: only a producer’s job queued, working or waiting kept — an upload, a done, failed, cancelled or needs-attention one not; the name the job’s own, else the open film’s entity, else the stem, another film’s job keeping its stem; the place from a slot’s group, a block’s group and `takes`; `stopping`, `stoppable` only with stop and not stopping, `dismissable`, `unconfirmed`; `assistant.activity.changed {source: renderJobs}` started, changed and ended, never twice for one state; `stopRenderJob` sending stop to that id, its accepted, refused and thrown answers logged, never rethrown; `dismissRenderJob` sending dismiss, never stop, its request and outcome logged; a producer’s job needing attention kept only for an unconfirmed stop
`test/insertion_attention_test.dart` (the dock’s reader), `test/activity_dismiss_test.dart`	the dock’s reader over the installed composition — the real insertion engine, `ManagedRenderProducer`, `BackendRenderManager`, `AttentionInsertionService` —: a render whose stop could not be confirmed is kept, unconfirmed, dismissable and not stoppable, and an accepted Dismiss removes it as the service publishes; the dock at 1200×800 over a service that answers and publishes: the unconfirmed line in Auto-generate’s words with Dismiss and no Stop, an accepted Dismiss logged and the line kept, nothing said, until the service drops the job, then gone
`packages/filmopen_state/test/auto_references_test.dart`	the box’s preference (§6.15): off by default, a tick kept under its key and logged, a kept tick read back, the engine’s sentences kept across a tick; the broadcast of landed writes (§7.4): an assistant’s patch told once with its attribution, before and after, a person’s autosave through the save door told unattributed, a create and a fork told with the new version already in the published index, an insertion’s patch under a given attribution told with it, a pick not told, a pass of `publishingOnce` telling at its end; `askLine` reaching the engine, and nothing without one
`packages/filmopen_state/test/entity_move_test.dart`	`builtin/move-entity` (§7.3): a scene from the project file into a folder, the destination forked first and the origin second, both the person’s drafts labelled from `summary`, the versions in use untouched and pinned, the log’s write order and the stems as they are; from one folder to another, then back in place into the drafts (`into: draft`); a folder into itself or beneath itself `invalid` (`folderIntoItself`), a scene as the parent and a project file as the entry `bad-args` with the reason in the log’s last line, an unknown entry or parent `not-found`, all unwritten; a move to where it is `unchanged` and unwritten; after a named sibling across parents and within one list (one write, no origin), a sibling the destination lacks `position:notInParent`; a folder to the top of the project; a second write that fails answered `failed` with `parent: origin` and the destination’s stem, the entry listed twice; an unfiled entry moved with one write (`from: none`); the cycle read in the drafts — a folder moved out of another may then take it though the version in use still lists it, and the cycle two moves would make is refused unwritten; a pinned reference moved as written; two concurrent moves that would make a cycle run one at a time, one moved and the other refused `folderIntoItself`, no cycle on disk, each wait logged as `queued`; a refused move naming the ids and the position it was handed on its start and its refusal, and a move after a sibling the sibling
`packages/filmopen_state/test/core_commands_test.dart`	Scope argument expectations naming what `arg` was and what to send — absent, a string, a number, an array with a non-string, an object with its keys, `focus` given a list —, all typed tag descriptors and no-arg scopes; `scene_dialogue` ids and tags accepted with other scopes still full; `builtin/navigate` on two versions of one entity by full stem, each exactly, on the project page; a versionless id the version in use; a group id the entity whole; `resolveCommandEntity` exact, in use or `not-found`, a group id included; a full stem the film lacks and an unknown id `not-found`, never another version; a closed film `no-project`; the navigation’s line naming the id asked and the version and name found, and a refused id the id; `builtin/export` answering the document as structured content and text, its enum listing `scene_dialogue`, an unknown scope and a scalar argument `bad-args` naming `scope` or `arg`, an unknown tag a document with its `unresolved` problem, a closed film `no-project`; every export line carrying the scope, the argument and the id as asked and the answer whole as `document`, a refusal the argument it refused, an entity exported through the relay its stem and document; `builtin/session` answering the registry’s session and the instructions, its result logged by value on `command.call.handler.done`
`packages/filmopen_state/test/command_log_sentinel_test.dart`	A sentence in an operation key, a session, a navigate id, an export argument, a malformed argument, an unknown command’s source and name, and a refused registration’s source and name, carried by the registry’s start, lookup, operation and refusal lines, and by export’s and navigate’s lines as asked (§7.3)
`packages/filmopen_state/test/counting_source_test.dart`	`CountingSource` (`filmopen_test_support`): every read, write, delete and listing counted, a file read twice counted twice, `reset`; every other member passed through by name; a load by the store one listing and one read per file along `filmopen_store`; an open by the controller attributed `filmopen_state (ProjectController._open … ProjectController._readIndex) > filmopen_store (ProjectLoader.load … _Index._readDocument)`, each package named by the frame it was entered through and the one that called onward, and `report()` naming the counts and the chains
`packages/filmopen_state/test/write_cost_census_test.dart`	the write-cost census (§7.5): on `ProjectController` over a `CountingSource`, films of 100 scenes and of 500 entities — open, a folder and a scene made, one scene moved into a folder and fifty single moves, fifty marked scenes moved in one gesture (2 writes, 1 publication) and marked scenes from three lists (4 writes, 1 publication), each asserting the entries landed in their order and left their origins, one taken out, an autosave and a copy-left through `saveEntity`, a visit, a pick, official, the manifest, a fork, a pick abandoned, a file uploaded to Takes and one attached to a form through the application’s insertion service, a save and a patch that change nothing, a stale refusal, a batch of 20 submitted at the door the render queue’s pass calls (`PendingSets.update`: the record’s write, each item’s marker and outcome, the end — 42 writes and 42 publications, no read), close and reopen — each act’s reads, writes, deletes, listings, whole-film loads, publications, source calls by path of packages and time printed, and held to its ceiling: a write 0 reads, one listing, no load and one publication (a two-write door too: official, a fork, an add; an upload too, its bytes, thumbnail and batch, and on a form the entry’s patch); a save or a patch that changes nothing nothing at all; a stale refusal its one file read; an open and a reopen each listed document read exactly once, one publication; a move between two lists 0 reads, two writes, one listing, no load and one publication, its one gesture `moveChild`, and fifty single moves fifty of each; three moves asked at once, none awaited, each whole, one after another, two writes each, three listings and three publications; a take-out one write and one publication; after every act the index naming exactly the folder’s documents, each with the folder’s text, and the index before it left as it was — its entities, pointers, commentaries, sets, batches and manifest; the assistant’s Add scene, empty and with content, counted apart (2 + 2 ledger writes, one listing and one publication; 3 + 3, one and one, the command being one pass of `publishingOnce`), then the chat closed: one write, one listing, one publication; with `FILMOPEN_TRACE_FDX` naming an FDX file the same acts on that screenplay imported through `importScript` into `FILMOPEN_TRACE_OUT` (else a temporary folder), the import’s time, files and bytes printed, each act on that film on disk but an open preceded, and every act followed, by a second’s pause that outlasts the folder watch’s quiet, its own reads held to the ceilings above and the watch’s settle reads (§6.1b) counted apart and printed beside them, each settle reading only the `.json` paths the act wrote, as many as the `_settled` reads; else skipped with the reason
`test/command_navigate_test.dart`	At 1200 and 700 px, `builtin/navigate` through the registry moves the app to the character on the project page, and Remote control opened Mara shows
`test/assistant_page_test.dart`	the page after an assistant’s change (§9.3), through `pumpApp` and a real `builtin/update-entity`: at 375, 700 and 1200 px the page staying, the change said with Open (`assistant.page.decision {decision: messaged, reason: no automatic move, page}`), a page chosen by its stem alone too, and Open opening the version written with the box under the check — the owner’s sentence, its border the theme’s error colour, no guard line — inside the view, at 1200 px left of the docked assistant, Use this version not over it, `assistant.page` logged `opened` and `shown`; Go back opening the person’s version and writing nothing, the next change showing the box again; a scroll and a tap outside leaving it, a move to another page dismissing it; a refused change showing nothing; a press of the check picking the version and dismissing the box; a change made while Takes is open, and the next one in place, landing on View/Edit; a screen reader’s tap on the check picking and dismissing the box as `check`, the box back at the next write; the draft opened again showing the box again, Compare opening the prior version on Compare beside it and writing nothing, and no box once the draft is picked; a draft the assistant created: the box says pick or compare, never go back, with no Go back link
`test/assistant_describe_test.dart`	Describe character through the whole app at 1200 px (§6.11a, §9.3): the real host with the stock plug-ins, OpenRouter’s key stored, and an in-process stand-in for OpenRouter’s stream: the Summary typed and not yet saved is what the model reads (`assistant.open` `from: draft`, before any write), the first streamed words on screen while the answer has not ended, the model’s `update-entity` writing the change as a new version and the page moving to the chat’s record, which shows the changed field, and a first call that streams a tool call and no words logged `partials: 0`, `shown: false` beside the HTTP door’s `plugins.http.stream.open`; the key in no log line.
`test/assistant_field_chat_test.dart`	a field chat through the whole app at 1200 px (§6.11a, §9.3): a scripted assistant whose turns call the real `update-entity`; its calls attributed to the chat as the host’s are; Polish synopsis opening with no Finish, its first write moving the page to the chat’s record (`session.moved`, once) and the chat going on, a follow-up written in place, the person’s version untouched; Conversation disabled on the record’s page and, back on the project’s page, without the synopsis tapped again, another field held, asking for the page as it is then on the chat’s own field bound on the version shown, admitted by Start; the bound field given back with the chat; a character made from the project page said with Open, the page moving to the chat’s record and the chat staying, Open going to the version written.
`test/assistant_page_captures_test.dart`	not a check: where `FILMOPEN_CAPTURES` names a folder, pictures of the page after a real `update-entity` at 375, 700 and 1200 px, light and dark, in Roboto — the state the agent build cannot reach, since no op of its calls the app’s commands
`test/command_wiring_test.dart`	The root’s wiring: the three core commands, the assistant’s four write commands, the four render commands and the machine’s command registered, the session a UUID v4 never logged, `JsonShape` refusing an unknown keyword at registration and a wrong argument `bad-args`, each stage logged; the authority changing with the viewer; a validator throwing at the second registration logged `command.wiring.failed` with its stage, its error and its stack, not rethrown, the first command kept; `export` through the real validator: `arg`‘s schema a description alone, the scene list sent as text read and logged `command.export.argDecoded`, a string that is no list still `bad-args`. The write tools’ `content`, an object pointing at `update-entity`’s guide, through the real validator: registered, the relay’s tool carrying it; invalid content reaching the exact type’s check from the text, voice and relay callers alike; content that is no object `content:type`; a valid one written. An argument a write tool does not take is answered with the keys it does, without `session` and `operation`, and logged. One `declare-epoch` period with no label answers `label:missing`, as the schema that required it did; the auto-references engine handed the insertion under the attention projection, logged `command.wiring {stage: autoReferences, insertion, projected: true}`
`packages/filmopen_render/test/source_composition_test.dart`	Exact picked-version identity and filename epoch; caller-supplied named hash facts; primary and dependency snapshots, both hashes and structured references remain frozen.
`packages/filmopen_render/test/outfit_composition_test.dart`	The composer resolves exact-epoch parent picks without index mutation or fallback, freezes character/outfit prompts and ordered references, and refuses an invalid parent.
`packages/filmopen_render/test/render_request_test.dart` (program routes)	A program setting survives the route and request JSON codecs, participates in route equality and hashing, remains distinct from the same model’s key route, and is omitted when absent; a non-string program is refused.
`packages/filmopen_render/test/render_request_test.dart`, `packages/filmopen_render/test/render_manager_test.dart`	Optional primary and dependency provenance is frozen and survives submission and restore; malformed fields refuse, and ordinary request JSON remains unchanged.
`packages/filmopen_ui/test/editable_text_target_test.dart`	Captured directional UTF-16 selection; provisional revisions replace one span; commit and cancellation seal before reentrant or throwing callbacks; late text is refused after deletion, target switch or read-only; target identity distinguishes equal counters; normal field validation may refuse an edit.
`packages/filmopen_ui/test/messages_test.dart`	Both transient-message helpers preserve the plain action and optionally identify exactly one semantics node; labels and width remain Material’s, every displayed action runs once, a second tap during exit does nothing, and dismissal carries the action reason. By the clock: an action asked for 4 s can still be tapped at 9 s and is gone after 10 s and its exit, plain and identified; one asked for 20 s keeps 20; a message without an action keeps its 4 s.
`packages/filmopen_ui/test/scene_grid_test.dart`	the scene grid of 500 cards of differing heights (§9.3): only the cards on screen built, a later section heading its own cards, the last card opening its own scene once scrolled to; a resize to 700 px while scrolled, light and dark, keeping its place, without an overflow, a later card still opening its scene
`packages/filmopen_ui/test/screenplay_view_test.dart`	the reading page of 500 scenes of 20 blocks (§9.3): only what is on screen built, a later section named and the last block there once scrolled to; a resize to 700 px while scrolled, light and dark, without an overflow, the page still scrolling
`packages/filmopen_ui/test/script_timeline_test.dart`	the reading timeline’s widths (§9.3): 201 scenes of a page and one of an eighth giving the eighth 3 px and the strip wider than its room, at 700 px scrolling sideways with each lane’s cell as wide as the strip’s block; lengths that fit filling the room in proportion; an unknown length at the median, marked and said in the tooltip and the label; no length known, equal widths under the same minimum and the label saying so; no scene, the empty rule and the empty state
`packages/filmopen_ui/test/entity_icons_test.dart`	a comp and an assistant session drawn with icons of their own beside the render batch’s
`packages/filmopen_comps/test/review_regressions_test.dart`	stalled source-length cancellation, monotonic token and exchange deadlines, abandoned response cleanup, concurrent native no-overwrite, sanitized retryable disposal, measured image MIME and malformed WAV refusal
`packages/filmopen_comps/test/models_test.dart`	bounded comp/media JSON, picked and default names, listed/unlisted, truthful missing metadata, immutable snapshots, browser-safe numeric values, prototype-key refusal, a credential-named key copied, an exception’s code, status and detail, and no caller author
`packages/filmopen_comps/test/bundle_test.dart`	the inventory (`comp.json` first, the begin body, the digest recomputed), a given revision and slug prepared again, destination refusals, every preparation stage on a recording event sink, original preservation, all media kinds, deduplication, limits, malformed input and cancellation
`packages/filmopen_comps/test/publisher_test.dart`	authenticated `/v1` publishing through stand-ins: the published receipt and its URL, a resume of a published revision, same-revision retries, fresh bearer recovery, expiry, generic refusals, cancellation and response validation
`packages/filmopen_comps/test/publishing_protocol_test.dart`	the contract’s exchanges: the host refused unless a bare name, every fixture refusal’s code with its status and detail, an unknown revision’s `not-found`, a server error’s detail, a 32 KiB detail bound, the status of a published revision after staging expiry with no bundle, a cancel answered `already-published`, and every request an event before its bearer with no bearer in any event
`packages/filmopen_state/test/comp_poster_test.dart`	the comp poster’s default: every call answered not available, each refusal logged by its call; an outcome published only with the published state
`test/comps_composition_test.dart`	the app’s comp poster: each draft field from a take and its render and import records, the ids by each item’s own `n`, a full take filename keeping its render record, a clip’s missing facts from the engine’s probe and left unknown when it refuses, a take without one, private as unlisted, an unknown cost absent; a URL, a bytes-only medium, an unresolved reference and a missing store refused `no-file`, an unexpected failure `failed`; prepare with no request, prepare refused `signed-out` with nobody signed in, a published post with its progress and no bearer in the log, a reloaded posting published as its own revision, another account refused before any request, an account switched as a token is asked for sending nothing (the token’s own subject read), a token with no readable subject unsent, each operation’s start logged before it waits, `no-primary-name` definite with its status, a local cancel, a check of a published revision, an abandon after publication answered with its published receipt, never abandoned, a server error’s answer logged whole; a post’s bundle released at its end whatever its outcome, sending the same posting again preparing it again
`test/queue_composition_test.dart`	the app’s queue runner (§6.15) over `RenderQueue` and a stand-in insertion that counts its calls, and three renders a provider refuses through the real producer and insertion, which end the batch with the provider’s words on each item while other attention states stay unrecorded, and whose Details, in Activity and on the media tile, opens the record holding the job, with none for a job no record holds: one pass, live while it runs, its start and end told; Finish and Mark refused `no-record`, `not-submitting`, `no-item`, `not-unresolved` and written where they may; a job’s phase, its take only once done, its actions; an action accepted or refused with its code, its lines carrying its reason and outcome, a refusal or a throw a warning, a throw with its error’s type and text; the startup listener keeping emitted terminal views through same-event dismissal, once per job, with its subscription and heard values logged and the runner retaining their phase and take without live actions; restored terminal snapshots and the real film/viewer listeners settling only when the owning film and viewer return, with no resubmission; a closed film retaining terminal views without requesting settlement, then recording them on reopen; four jobs completing and dismissing with no page, then four recorded outcomes, Rendered rows, the complete header and a tree row outside Pending; a real partial pass and removal completing a still-pending record, listed by the same rule
`packages/filmopen_comps/test/files_test.dart`	new workspaces, a refusal’s where and why, path/link confinement, exclusive artifacts, source preservation and owned cleanup
`packages/filmopen_comps/test/media_test.dart`	bounded images and JPEG previews, a refusal’s reason and values, measured WAV facts, a clip and a sound published without a preview through a real portable assembly, malformed media and cancellation, including browser cancellation after synchronous decode
`packages/filmopen_comps/test/comps_fixture_test.dart`	the comps contract `/v1`’s shared examples, pinned by their SHA-256 (the same bytes as the website’s); the bundle digest’s formula recomputed from them; the app’s draft read from them; the begin body’s members and the uploaded manifest’s keys; every receipt read by the publisher
`test/render_queue_integration_test.dart`	The real application add tile and dialogs feed canonical receipt-based fixture providers into the managed render and insertion services: held local A, waiting B/C, Stop B without submission, independent fal D, C after A, original-character attachments; two model tags sharing one GPU; simultaneous same-character completions preserving two takes, batches and open draft data, in English at 700 pixels in light and dark.
`test/insertion_attention_test.dart`	two same-character insertions associate by their own render ids despite reversed journal order, preserve other view fields and route only offered actions to the exact manager job; id-only restored attention is visible before Retry even when insertion binding is refused; acknowledgement Retry performs one effective cleanup and advances only the insertion marker; absent, unsafe, other-producer and missing-render associations stay generic; restart and Retry collect the accepted receipt without another submission; an entry the manager cannot read draws no row and is never sent or collected; subscribers established before a held restore receive already-attention views without an unrelated event, with zero submissions or collections before action; visiting a destination preserves the insertion snapshot order; refused Dismiss-only consumers retain exact Stop after pending or staged recovery, including restart, refuse stale Dismiss, preserve unrelated jobs and return local dismissal only after cleanup; a job’s own view carries the same attention projection as its place’s, and settling is the insertion’s; an insertion held `stopUnconfirmed` has its Retry and Dismiss sent to the manager, then to the insertion, one `insertion.attention.route` line per tap; its Dismiss with the render `outputReady` and no attention view stops the render, letting its staged outputs go, then removes the insertion; a Dismiss that leaves the manager settling keeps the insertion and answers `settling`; over the insertion’s own runtime and the render producer, Stop, Retry, an unconfirmed collection and a second Retry place the clip once — the second Retry the manager’s alone, one entry, one acknowledgement, one submission — and a Dismiss kept while settling, then Retry, ends the insertion cancelled offering Dismiss, which removes it, nothing placed and nothing sent again; under a pending acknowledgement, the insertion itself ending attached, `renderRecordUnsettled` or refused while the projection still shows it pending
`packages/filmopen_timeline/test/rules_test.dart`	the three rules (§19.12): the first usable favourite, passing over deleted or archived favourites and accepting an unreviewed favourite, else the first usable kept or unreviewed entry, else none; a block’s output duration set, else its clip’s, its speech’s, the writer’s, 3 s, each reason, a value not above zero saying nothing; a block’s picture its clip, its first frame, its first and last frames, black, a last frame alone black
`packages/filmopen_timeline/test/otio_test.dart`	the scene’s OTIO export (§19.14; Project Specification §15.5): the six blocks’ file equal to the golden `test/goldens/six_blocks.otio`; every `OTIO_SCHEMA` one of `Timeline.1`, `Stack.1`, `Track.1`, `Clip.1`, `Gap.1`, `ExternalReference.1`, `RationalTime.1`, `TimeRange.1`, `Marker.2`; the tracks Picture, Clip sound, Speech, Music, Music 2, Effects and a marker per block; a short clip at its real length then a gap, `held_last_frame` reported, no source range past the available range; a clip one frame short of its block (24 source frames in 25) its real frames, then a gap on the picture and silence on its own sound, `available_range` 24, `held_last_frame`, each placement logged `otio.write.item`; a URL reported and logged whole, its user, password and query included (§6.2); a Windows path naming its file; stills from 0 with no available range, `still` reported, black a gap; rational times exact at 24 and 24000/1001 and the OTIO cut on the engine’s frame; the manifest’s frames; `otio.write.start` and `.ok` with their counts, and `.failed` with its stage where the JSON cannot be encoded
`packages/filmopen_timeline/test/scene_timeline_test.dart`	a scene’s build (§19.13) on the brief’s six blocks with fake references, its `EngineTimeline` equal to a golden one to the microsecond and valid: three clips with their own sound, a deleted take skipped and a favourite chosen, first and last frames split at the middle, a black block, a short clip held under a set output duration; each block’s beats and subtitles laid once by the build, by its index, the subtitles’ layout the one they are burnt from; five voice lines; two music lanes where two beds overlap; an effect for given seconds cut at its own length and one over two blocks; each block’s decisions logged, the build’s start and end; a boundary at half a frame (1.0625 s at 24 fps, 1.5 frames at 24000/1001) on the later frame in the build and under the engine’s `frameAt`; a voice line cut at its block’s end and a sound never longer than itself; music until a named block, effects for given seconds, an unknown block the owning one; a missing file black or silent with `missing_source`; a project without `format` at the defaults, each said; a probe filling a clip’s length, logged `timeline.probe.used`; the speech deciding a block without a clip, a first frame alone filling its block, the default reason; a missing bed taking no lane, items of no frames left out; the store resolver on a folder on disk — a file its path, an absent file and a URL none, each `timeline.resolve` logged with its outcome; a resolver that throws logged `timeline.build.failed` with its stage, block, group and reference; a probe that fails failing the build with the engine’s code, stage and reason and the file; `format.subtitles` read as given, and Noto Sans at 48 px with a `default_format` for each of `subtitles.font` and `subtitles.size` where it is absent or unusable; a block’s subtitles at the blocks’ own frames — a 1.0625 s block’s ending at frame 26, two 1.1 s blocks’ second over 26 to 53, `[5 s, auto]` over 3 s the first cut and the second never burnt —, one past the block or without text not burnt, an endpoint on half a frame inside a block at the later frame, one keeping no frame not burnt, three 0.1 s in 0.3 s each `laid`, each logged in `timeline.block` with what it asked, its seconds, its frames and its reason, the format’s font and size on the engine’s timeline; a clip spanning blocks: its block not decided by it, the covered blocks’ own clips first, then it resumed at its offset, stills and black under it not shown, its sound on a lane of its own to its span’s or its measured end, a short source resumed past its end and held, the resumed piece starting a frame of the slower of the source’s rate and the project’s before the source’s end (a 24 fps source in a 30 fps project at 1.433 s, 1.400 s where its rate is unknown: 100 ms), the clamp’s inputs logged, `audio: false` silent, `blocks` naming no later block not spanning, each logged; every clip’s sound logged `timeline.sound` — the spanning one `placement: span` on its lane, a covered block’s own `placement: picture` with its extent, each with its reference and file — and counted in `timeline.build.ok`’s `clip_sounds` and `clip_lanes`
`packages/filmopen_timeline_ui/test/timeline_dock_test.dart`	the timeline dock (§9.1, §19.15) on a three-block fixture at 375, 532, 700 and 1200 px, light and dark: narrow by default, one row, the scene’s time, nothing overflowing; dragged up it grows, never past half the page, keeps its height and logs one `timeline.dock.resize` at the drag’s end; a tap opens it to half the page and a second narrows it; open at each width, the picture the dock’s height at 16:9, capped at half the dock’s width, and `timeline.dock.resize` carrying `picture_px`; a stored height taller than half a smaller page laid out at half and kept; turning back after dragging past half the page moves it at once; a height that does not change neither logged as a resize nor written; opening and leaving logged; a press in the dock its press only (`dockPressed` until its up or cancel), taking the charge and asking the block under the playhead at once; a box’s tap — by a pointer or through its semantics, which takes the charge itself — asking its block by the dock and seeking its start, a one-frame block’s edge doing the same; play across a boundary asking the next block once, nothing after the charge is taken back; a scrub across three blocks asking each once; the block open in the script the current box, primary, its label saying so, centred, and a block wider than half the span keeping the playhead it holds in view
`packages/filmopen_timeline/test/lay_timed_test.dart`	the one timing rule of beats and subtitles, `layTimed` (§19.13, §19.15): each from where the one before ends, the rest shared; the owner’s 40 s of beats over 15 s — the first cut, the second past the end; a share of zero laid at the end; subtitles laid by the same rule
`packages/filmopen_timeline_ui/test/tracks_test.dart`	the tracks slid up at 375, 532, 700 and 1200 px, light and dark: a picture box per block, Black, the beats with their glyphs, the `+1`, nothing overflowing; a box as long as its block; the `+N`’s and a block’s tooltips; a missing clip striped and named, no beats track without beats; `timeline.tracks.built` once per revision with each block’s beats as laid, the fit, the shortest block and why the fit is what it is; a 67 s scene fitted to its room, its ruler ending on 1:07; the 8 s scene ending on its own label, clear of the time before it, at the four widths; a 0.1 s block among 60 s painted 3 px, the scene scrolling; a one-second scene that does not zoom, a drag on its ruler logged as changing nothing; a 160 px drag doubling the scale with the time under the pointer kept, back halving it, never under fit, and seeking nothing; the ruler’s semantic ×2 and ÷2, a double tap back to fit; a widened room clamping the zoom, logged `layout`; the edge at its block’s end at every zoom; a spanning clip named in a covered block’s box, after the block’s own shorter clip, both in its semantics label
`packages/filmopen_timeline_ui/test/subtitles_lane_test.dart`	the subtitles lane (§19.15) at 375, 532, 700 and 1200 px, light and dark: under the beats’, a box per subtitle with its glyph and first words, one cut at its block’s end, one past it a `+1`, the beats as they were, nothing overflowing; a subtitle’s tooltip and the `+N`’s; no subtitle, no lane; `timeline.tracks.built`’s `subtitles` with each text, its laid interval and `past_block_end`; `timeline.tracks.subtitles` with drawn, hidden and `too_narrow` — a one-frame box at its 3 px floor holding its first mark —, counted in the block’s tooltip
`packages/filmopen_timeline_ui/test/edit_test.dart`	the one edit (§19.15) on an open-draft stand-in: a right edge dragged sets `output_duration_sec` in whole frames through the draft and logs `old→new`; never under one frame; a double tap clears the key; the draft’s own block found by its id after an unsaved reorder; with no form open refused `no_draft`, said in the dock; no edges on a version the viewer may not change; a semantic increase a frame longer; the last edge whole; a drag back to its start asks the draft for nothing; the refusal gone once a form opens; a block whose id is not `bl_<n>` named by its place and its `block_id` in the gesture’s two lines, the tap’s and the tracks’ lines
`packages/filmopen_timeline_ui/test/player_test.dart`	the player (§19.15) on a spying fake engine: made and prepared as the dock opens, logged; play runs the playhead, pause stops it, the engine disposed as the dock goes; a re-read that changes nothing the scene is made of keeps it playing, the scene’s own synopsis typed into included, nothing paused or replaced (`timeline.reused`); fifty played frames moving the playhead and the time while the lanes’ boxes stay the same widgets, `timeline.tracks.built` once; a clip arriving in the media folder while playing pauses and replaces with the playhead kept and no second engine; another rail page pauses and keeps it, coming back resumes nothing; the scrubber scrubs while dragged and ends with an exact seek, a tap on the ruler seeks; a refused call kept and logged, never thrown; a prepare that fails said in the dock, the next revision — a block’s text changed — prepared again, never replaced; the web’s limit, and play disabled with its reason; a scrub during a play stopping it, logged as not the end (`at_end: false`); a scrub during the first prepare asking nothing and saying nothing, its end seeking once prepared; a tap on the ruler seeking once no double tap can follow; zoomed, the playhead past the span jumping the view to put it a quarter in, not before; paused, a seek out of view jumping; the person’s own scroll not fought, playing or paused, until their next seek; scrolled away within the first block, a tap on its box or its edge — the time unchanged — bringing the playhead back into view; every scroll the person makes logged from where it began to where it left the view; a play on another engine (the pop-up’s) pausing the dock’s through the logging base, its button following by the clock, `engine.play.yielded` and `timeline.player.stopped {why: engine}` logged a scene’s media in the cloud downloaded before the first play, the ring saying how far, and the timeline built from them played with no re-read of the project; the ring fitting the narrow row at 375 and 700 px; a medium that could not be downloaded named, and nothing played. A failure that stops playback (`playback` failed) said in the dock with its words, code and cause, the button back to Play, `timeline.player.failed` logged, an encoder’s failed event not shown; a refused prepare said with its cause beside its code; at 375 px on Android the play limit null, play enabled and `timeline.dock.play_limit` logged once, iOS still blocked.
`packages/filmopen_timeline_ui/test/silent_audio_test.dart`	the dock’s silent-playback notice (§19.15): at 700 px in light and dark it survives prepare, play and pause, with a volume-off icon apart from a failure’s and transport enabled; a player failure said before it, the notice back after the next call succeeds; only the engine’s `audio`, `info`, `no_audio_device` sets it, logged once with the engine’s data and the decision
`packages/filmopen_timeline_ui/test/export_test.dart`	the exports (§19.15): on the fake Export MP4… disabled with its reason, Export OTIO… writing the file, its manifest and its report into a temporary folder and logged; an OTIO export listing its report’s codes; no place chosen, nothing exported; on an engine that exports, the default settings, the progress and Cancel, logged; a failed MP4 saying its code and the engine’s cause beneath it, a cause of 1,023 and 2,047 characters scrolling inside the dialog at 375 and 700 px with Close in reach; neither offered on the web and mobile; what plays paused before an export; the setting Software only asking the export for `software`, and the dock’s start event saying `asked` and `asked_from: setting` an export waiting for the scene’s media in the cloud and exporting the timeline built from them;
`packages/filmopen_timeline_ui/test/review_fixes_test.dart`	the review’s findings (§19.15): a scene with no blocks shows what would fill it, play and each export item disabled saying so, opening without throwing and nothing prepared; a play in flight as the page is hidden paused as it settles; an OTIO export refused where a manifest it would write, or the file at an added extension, is already there, nothing written; Cancelled only once the cancel completed, a failed cancel said, an export finished first Saved.; a failing save dialog said in the dock and logged, its cause whole; a cancel’s and an engine’s cause logged whole; each OTIO file logged, the height’s old → new, a resize’s start and time; the beats logged mark by mark, a cancelled edge drag logged; a block too short for its beats drawing none outside it — its box painted 3 px, holding its first mark and not its `+N` —, the count in its tooltip
`packages/filmopen_timeline_ui/test/review2_fixes_test.dart`	the second review’s findings (§19.15): a scene become empty while play is pending paused as it settles; a cancel that fails said at once while the export goes on, then Saved.; a build failure’s `reason`, `cause` and `reference` logged whole; the beats as drawn at the scale shown logged (drawn, hidden, why — a one-frame box at its 3 px floor holding its first mark); an edge operation’s start and end — cancelled, cleared — with its time a pause asked for while the media download — after a second press too — leaves the scene paused; a failed download no longer said once the next press asks again;
`packages/filmopen_timeline_ui/test/lanes_test.dart`	the sound lanes as `SceneTimeline` gives them, at 375 and 1200 px: speech, two music lanes, effects, each named by its file; no lane invented; beats with no time left drawn inside their block’s end; fifty frames of the playhead reading no block, the laid tracks given back
`packages/filmopen_timeline_ui/test/monitor_view_test.dart`	the pop-out (§9.1, §19.15) on a stand-in runner, a second view in the test binding: the dock names `timeline.popout`; its tap asks `open` with the window’s title, logged with the scene; the second view shows the open dock’s picture, transport and `monitor.fullscreen`, and, the player gone, what would fill it; the runner’s focus word given before the view is built focuses its keys once built; space plays and F fills the screen in the window’s view, the main window’s keys never reaching it nor its keys the main window’s; Escape leaves full screen, then closes, the close logged with its scene, `how` and time; the main view’s keys back once the runner hands it the keyboard; an exit request closing the window before the app’s own exit listener; a runner that refuses disabling the button with a sentence; a play the engine fails said in the window in the dock’s words; an open the runner fails said in a message and logged `monitor.call.failed` and `opened: false`
`test/timeline_dock_test.dart`	the dock in the whole app (§9.1) at 375, 532, 700 and 1200 px of window, light and dark: beneath a scene’s tabs, narrow, the scene’s time, inside the window, and slid up a picture box per block; no dock on another type’s page; the reader’s tab kept from scene to scene, from a scene to another type’s page and back; a block’s edge dragged in the whole app written through the scene’s own form in whole frames, the timeline re-derived from the file; one engine per opened scene version — A → B → A, another version, Settings and back through the real rail (paused, the same engine, nothing resumed)
`test/script_timeline_focus_test.dart`	the dock and the script editor in the whole app (§19.15, §9.3), on a fake engine whose clock is the frame’s time: entering the dock opens the block under the playhead; a click on a block in the script takes the charge back, its box highlighted, the playhead unmoved; Play reopens the block under the playhead, and as it plays each block opens in turn, the one before condensed, none taking the keyboard’s focus; a press on another part of the page condenses the block and no card reopens; a dock opened on another scene while the timeline was in charge asks nothing, and back at the scene nothing is highlighted until a press in its dock
`packages/filmopen_state/test/scene_timeline_provider_test.dart`	the timeline providers (§19.13): a factory making a new fake engine each time, wrapped in its log; the probe’s engine its own, made once and disposed with the container; a scene’s timeline from the open project on a `MemoryProjectSource`, its media held as bytes and so `missing_source`; a re-read that changes nothing the timeline is made of answering the same timeline (`timeline.reused`), the scene’s name and synopsis changed answering it too, a block’s text changed built again at the next revision (`timeline.built`, `reason: [blocks]`); the input check logged as it goes — its start and each medium looked at while a read is pending, including its unreviewed/favourite flags and skipped references, and a failed read naming the block, group, reference and file it was at (`timeline.inputs.failed`); a clip arriving in the media folder built again with its path, and another source with the same files built again; the engine’s probe once per file across builds, filling each clip’s length and logged `timeline.probe.used`; no project, no timeline, logged `timeline.provider.none`; a probe that fails thrown and not kept, a refusal answering null; a clip’s sound through `mediaAudioProbeProvider`: the probe’s audio stream, the fake’s refusal and a failure their code and message
`packages/filmopen_state/test/script_focus_test.dart`	the script focus (§7): `opened` and `closed`, a close of another block or with nothing open changing nothing (`not_current`), the same opening `unchanged`, another opener replacing, `by` carried; each `ask` a new request with a raised serial, logged; `follow` and `dockPress` logged once per change; `live` until the scope is disposed
`packages/filmopen_engine/test/time_test.dart`	`frameAt` and `frameStart` at 24/1, 24000/1001, 25/1 and 30000/1001: the boundary between 41 ms and 42 ms, the 1001st frame, and `frameAt(frameStart(n)) == n` over an hour of frames
`packages/filmopen_engine/test/timeline_test.dart`	the timeline’s JSON round trip with snake_case keys; `bad_key` naming the key’s path; `validate()`’s codes: overlap, a hole, a picture short of the duration, an empty timeline, black without a source, two music lanes accepted, no picture track, a second picture track, a bad rate
`packages/filmopen_engine/test/subtitles_test.dart`	the timeline’s subtitles (§19.2): their JSON and style round trip, a timeline without them read with none in Noto Sans at 48 px, a wrong key `bad_key` naming it, the fake engine playing them and ignoring them; `assOf` on a golden (the output size, one style, the times, `\N`), its style following the timeline (a comma in the font’s name a space), an hour written in hours; frame zero written `0:00:00.00` at the four rates and read back, as libass and FFmpeg’s reader add the signed parts, as 0 ms, frame 0 showing and frame 1 not, no minus anywhere; at 24, 25, 30 and 24000/1001 fps, under FFmpeg’s own conversion of a frame’s time to whole milliseconds for the export’s `concat` and for MLT’s `avfilter`, exactly each one-frame subtitle’s frame showing it under `Start <= now < End`, near zero and past nine minutes; the person’s text — `C:\new`, a literal `\N`, `\h`, braces, CRLF and CR, a backslash before a line break, emoji, a trailing backslash — shown as typed by libass’s parsing rule
`packages/filmopen_engine/test/fake_engine_test.dart`	the fake engine’s records: prepare’s first frame, a seek on its frame, a displaced seek answered with the later frame and naming itself, a superseded scrub’s event, no record of an older revision after a replace, a waiting seek clamped to a shorter replacement, a replacement ending inside a frame keeping its last whole frame, play on time with its clock, export `unavailable`, `not_prepared`. `failPlayback` stopping the play and saying the `playback` failed event with its code and cause.
`packages/filmopen_engine/test/logging_engine_test.dart`	every member’s start and end (ok, refused, failed) with the engine, timeline and revision; prepare, replace and export logging their timeline’s content once; a non-engine error leaving as `unexpected`; the first frame naming the timeline being prepared; a refused prepare restoring the state; the export’s end, cancel and refusal; a stall over 100 ms; native events; an engine whose clock cannot be read (no native library) logging prepare’s and play’s start, then failed `no_native` with its time; one sound at a time: a play on a second engine pausing the first before it plays, `engine.play.yielded` naming both, the first’s clock saying it stopped, no yield on the same engine or after the other paused, a pause that fails failing the new play with `yield-failed`, said once as `engine.play.failed` (no `engine.play.yielded`), its cause naming the engine that did not pause and why, the new engine not started and the other still remembered, a disposed engine never asked; one `engine.play.summary` when a play ends, with its frames, drops and time, and no line per frame between the play and the pause; a play reaching the end saying its summary then (`ended`), a refused replace ending no play, an ended play not ended twice; a seek that stops the play ending its summary once, a clock reading from before it starting no play; an engine saying it plays on after a seek (an `audio` event, `playing: true`) counting the play after it from that word to its own summary, `ended` or `pause` — after one seek, a seek near the end whose play ends before any clock reading says it plays, a seek displaced by another, a seek asked after an answered one (as the dock queues them, each play counted) and a refused replace between —, and a play asked while a seek waits being the one counted, a stray state change after its end starting none; the clock’s line carrying `playing` beside its position. A playback failure logged `engine.native.playback` at error, ending the play in its summary, `why: failed`; every scrub in the log — a drag under 100 ms ending in `endScrub` lists every request, its target and frame, and each answer or supersession, requests within 100 ms share a line and `dispose` flushes the rest; a scrub that throws logs its target and its time.
`packages/filmopen_engine/test/file_timeline_test.dart`	`fileTimeline`, the pop-up’s one-file timeline: a clip as one video item with its own sound at the probe’s rate and size, a sound as black and a speech lane at 0 dB with the one audio item, a probe without video or audio rate giving 24/1, 1280 × 720 and 48 000 Hz; `validate()` empty for each
`packages/filmopen_engine_bench/test/measures_test.dart`	the bench’s arithmetic on recorded records: a clean play on time; frames from the tenth on 50 ms behind their deadline late; a trace shifted by 20 ms on time, its first frame 20 ms later; a missing frame late; frames missing at the start of a play late; seek latency; a drag answered only at its end failing the longest interval without a new frame; nearest-rank stats; A/V; a frame code read from pixels, and a code region of one colour read as no code
`packages/filmopen_engine_bench/test/stages_test.dart`	the bench’s stages on a scripted engine: a stress file that should play and does not is a fail, its picture not measured without a capture, one that plays presents its frames in order; a stale frame shown while replacing counts against the cycles; a cancel whose export never reached half way is not measured
`packages/filmopen_engine_bench/test/bench_test.dart`	the bench’s lock and `scripts/with_bench_lock.py` excluding each other both ways on Linux; the expected code of a timeline frame against the fixture script’s; the ten-minute play’s repeated timeline; a subtitles file laying its subtitles, font and size over the fixture’s timeline and nothing else, another key refused; the long play’s timeline repeating the scene’s subtitles at each repeat, in its style
`packages/filmopen_engine_bench/test/engines_test.dart`	the bench’s engines: `fake`, `mlt` and `mpv`
`packages/filmopen_engine_mlt/test/encoder_choice_test.dart`	the export’s encoder chosen on stub candidates: the first GPU encoder that opens its test frame, nothing after it tried; one that does not open, or that the build lacks, passed over to the next and then to the software one, each candidate’s cause logged; `FILMOPEN_ENCODER=software` trying no GPU encoder and saying so, another value ignored and said; no encoder opening chosen as none, nothing left to name, `no_encoder` with each candidate’s cause; the policy `software` trying no GPU encoder, its reason naming the setting, a software encoder that does not open `no_encoder` with the cause saying the software encoder was asked, no hardware tried; `FILMOPEN_ENCODER=software` winning over `auto` and said; one choice per policy, made once however often the policy switches; an export’s encoder from its policy’s choice, a named one checked against the automatic choice
`packages/filmopen_engine_mlt/test/mlt_compiler_test.dart`	the compiler from a timeline to MLT’s XML, golden-tested on the fixture and three tiny timelines: an item’s exclusive end as MLT’s inclusive `out` at the 41 ms and 62.5 ms boundaries; a clip shorter than its item played to its last frame and held, a still held; two music lanes and effects at their gains summed onto the picture with `sum=1`; a mono source boosted on a stereo timeline only; a second picture track `unsupported`; a path escaped; subtitles as one `avfilter.subtitles` on the tractor after the mix, naming the ASS file and the fonts folder (XML-escaped only, a path with an apostrophe, a comma and brackets as it is), and none without them
`packages/filmopen_engine_mlt/test/subtitle_sweep_test.dart`	the sweep of ASS folders an app left: `tasklist`’s answer and the parsed pids logged, each kept folder with its pid and reason, the ended one deleted; a `tasklist` that does not start, one that fails, an answer without this process and a base that cannot be listed each ending in `.sweep.failed` at its stage with nothing deleted and nothing escaping the zone; the same without `tasklist` (`/proc`)
`packages/filmopen_engine_mlt/test/mlt_engine_test.dart`	the MLT engine over its native build and the fixture’s media (skipped, saying why, where either is absent): subtitles on exactly their frames at 24, 25, 30 and 24000/1001 — frame zero, two adjacent distinct ones, a one-frame one and two late ones at frame 2000, each frame checked by its text’s width against the text exported alone, and the same check shifted a frame either way failing —; on Windows the fonts under a drive-letter folder named with an apostrophe, a comma and a space reaching libass, which says it took Noto Serif; libass’s provider by platform (Fontconfig, DirectWrite on Windows) for a family the folder lacks; prepare’s first frame, a seek on its frame and a displaced one answered; scrubs superseded; play on the audio clock and pause; play and pause following the engine when a seek or a second play crosses them; the audio clock read at the stamp (on alternate slow hand-overs, the clock minus the stamp unchanged); each play’s summary of its schedule and its signed A/V, and its 5-second windows of the signed A/V, under a 20 ms hand-over too; a replace keeping the playhead, no record of the old revision after it is asked; the stress set’s refusals; the probe; the encoder chosen once per engine by a test frame, each candidate and the choice logged (`h264_mf`’s test frame in NV12); a probe thread that cannot start (a create failure injected, `fo_mlt_test_fail_thread_create`) said with its error number and text in the result and the candidate event; on Windows `h264_mf`’s test frame opening when asked from a thread in COM’s single-threaded apartment (`fo_mlt_test_encoder_in_sta`, as the app’s UI thread); on Windows `h264_mf` named exports the fixture in software, its report saying `pix_fmt nv12` and `hw_encoding 0`, every frame verified; the encoder’s own log lines kept whole when two of its threads log at once; an export with the chosen encoder and its cancel (the suite passes with `FILMOPEN_ENCODER=software` too); an export passing the fixture’s `verify` in full, every frame’s code included; an encoder the build lacks `no_encoder`; a scrub during a play answering the asked frame and the next play running on from it; an export that cannot open its file failing with a cause naming the encoder and MLT’s error; a cancel in flight as the engine is disposed completing cancelled with no file, and an export whose start ends after the dispose began answered `unavailable` with no file written on; a dispose leaving no MLT profile, producer or consumer of ours alive, after an export too (the shim’s own counts, read by the test); a missing library `no_native` with prepare’s start and end; subtitles: the prepare writing `assOf` to an `.ass` and logging its write, the fonts and `subtitle.font`, the folder 700, the compile’s filter, and libass’s `fontselect` naming Noto Serif’s face; a family the folder lacks said at warning and libass’s line that it found none; no subtitles, no file and no filter; a replace writing a file of its own and the dispose deleting the folder; on Linux, in the user’s runtime folder, the folder of an ended process deleted and the sweep logged with its counts, a running process’s (pid 1) and an impossible number’s kept; a missing fonts folder `no_fonts` with the write’s failure; an export burning the text on frames 0 and 23 and not on 24, against the same export without it; a scene’s timeline whose spanning 24 fps clip resumes near its end in a 30 fps project exported with every frame (90 of 90, counted with the system’s FFprobe, its clips made with the system’s FFmpeg; skipped without them); a play from near the end stopping by itself at the last frame, its clock saying it stopped and one `ended` line, and a second play starting from frame 0, advancing and ending once more
`scripts/tests/test_make_timeline_fixture.py`	the fixture’s frame arithmetic and expected code sequence (cuts, the 23.976 conversion, the held frame); with the media made, `verify` passing a reference render made in numpy and failing one frame wrong, the sound 40 ms late, a music lane 2 dB loud, the right codes muxed at 12 fps and the cross-cut effect stopped at the cut; a file that cannot be probed logging the command, its exit code and its error
`test/timeline_engine_selection_test.dart`	the engine the build names (§19.16): `mlt` requested, and unset on Linux and Windows, with its library present and loading → MLT, its library looked for and opened once at the path `MltEngine` opens, each engine its own and in its log with its texture; the library missing → `engine.select.failed {stage: library_check}` and the fake, the reason naming `--engine mlt`; a check that throws → the same, its cause whole; present but not loading (the load stood in through `engineLibraryLoads`) → `library_load` and the fake; `fake` requested → the fake, reason requested, no failure and nothing looked for; an unknown name → `unknown_engine` and the fake, never another engine; Android and the web → the fake, nothing looked for; `engine.select.start` then `engine.selected` said once; the disk’s load door throwing for a missing library; `main.dart` overriding the factory once with the selection and naming no backend; the licence page following what ships — the fake selected with MLT’s library present still listing MLT’s notices, `licences.engine.start` then `licences.engine {adapter: mlt, entries: 18}`, each ending `licences.engine.done {adapters, entries, ms}`, no library present no engine notice, `adapters_present` empty and the end’s reason no engine library in this bundle, a notice asset that does not load said as `licences.engine.failed` with the adapter and the asset before the error goes on; FFmpeg, MLT and SDL2 in the licence page where MLT’s library is in the bundle, OpenH264 (its BSD notice verbatim) on Linux, the Windows runtime libraries not on Linux; on Windows the runtime libraries and the subtitles’ libraries MSYS2’s libass brings, each by name with its version, its DLL and its licence, OpenH264 not; each platform’s default engine (`platformDefaultEngines`: MLT on Linux and Windows, none elsewhere; macOS and iOS on the fake); `mpv` named by the switch → `MpvEngine` at `libmpv.so.2` / `libmpv-2.dll`, and on a default bundle the fake saying the bundle lacks it; a Linux and a Windows bundle built with mpv listing libmpv’s own notices, every asset there, the Windows GPL-3.0 text under FFmpeg and GCC’s runtime libraries alone
`packages/filmopen_engine_mlt/test/mlt_audio_device_test.dart`	MLT’s question before an engine’s first play (§19.16), over the native build and the fixture (skipped where either is absent), in a process of its own, through the shim’s seam `fo_mlt_test_audio`: SDL asked once per process, a second engine told the first’s answer (`source: kept`) and not the dummy driver’s one output; no sound output → the first play’s frames paced at once on the dummy driver, `no_audio_device` said as info with `driver: dummy` and `devices: 0`, a second play not asking again; a present device said as `audio_device` info, which leaves the play to the consumer’s own start, a start that fails (a driver SDL lacks) failing the play `audio_failed`
`packages/filmopen_engine_mlt/test/mlt_engine_stub_test.dart`	the barrel’s conditional export, and the stub refusing every operation with `unsupported` and owning nothing
`scripts/tests/test_native_stamp.py`	the native build’s completion stamp (§19.16): no stamp rebuilds everything, a written one matches until an input changes — the shim’s sources the shim, a patch changed or removed MLT and the shim, the script everything —, `clear`; `ready` building without a stamp, skipping with one, and stopping with the builder’s exit code and no stamp where it fails; both builders clearing the stamp before their stages and writing it last; every app wrapper handing every argument, as given, to `scripts/desktop_flutter.py`; `--engine mpv`’s own inputs and stamp, its build, skip and failed exit, and its builders clearing it first and writing it last
`scripts/tests/test_agent_run_home.py`	`scripts/agent-run.sh`’s home, with `dbus-run-session` and `xvfb-run` stood in: a new temporary home by default, a `FILMOPEN_HOME` given, and the person’s own folders only with `--real-home` (which reaches the app as `FILMOPEN_AGENT_REAL_HOME=1` and never `flutter run`), each named with its reason on the first line
`scripts/tests/test_test_all.py`	`scripts/test_all.sh` in a copy with `flutter`, `dart` and the quota’s `cat` stood in: the selection’s lists, the package runs, a bad entry refused, no arguments meaning full, a failing suite failing the run; `scripts/test_all.ps1`’s Python step, read as text, MSYS2’s `usr\bin` then `ucrt64\bin` appended after `PATH`’s own entries before `python` is looked up and logged as `test_all: path msys:`, its exit code read on the line after the call, kept through the later suites, and no `python` refused; a CPU quota in `cpu.max` passing `--concurrency` (rounded up) to every suite but one whose `dart_test.yaml` sets its own, which keeps it, `max` or no file passing none, each choice and its reason printed
`scripts/tests/test_wrapper_command_log.py`	the four shell wrappers (`build-`/`run-linux.sh`, `build-`/`run-windows.sh`), each run in a copy with Flutter, the stager, the stamp and the keys helper stood in: one line naming the command Flutter received with every argument — the caller’s `--debug` and `--target=…` included — and the keys file by its path, its contents nowhere in the output
`scripts/tests/test_desktop_flutter.py`	the desktop wrappers’ one command (§19.16), pure Python with the commands it runs stood in: `--engine fake` building no native layer and `--dart-define=FILMOPEN_BUILD=review` reaching Flutter as one argument after the keys’ file and `FILMOPEN_ENGINE=fake`, `--engine` itself never forwarded; unset and `--engine=mlt` readying MLT’s native build before Flutter with `FILMOPEN_ENGINE=mlt`; `MLT`, an empty value and `bogus` refused with `engine.route.refused … code=2` and the usage line, nothing run; a failed native build stopping before Flutter with its code; an interrupt ending `engine.route.done … code=130 … outcome=interrupted stage=flutter` and exit 130; the command said with every argument quoted, the keys said as found or none; each line under the wrapper’s name, `engine.route` first and `engine.route.done` last; `--engine mpv` or `FILMOPEN_ENGINE=mpv` readying libmpv’s stamp; the engine passed in the environment of every command; the bundle’s libraries listed after a build, each with the engine prefix it came from, a library both prefixes hold byte for byte the built engine’s; `--trace <folder>` on `linux run` starting the thread watcher on the bundle’s binary for the run’s mode and architecture (`profile` with `--profile`, `debug` when none, `arm64` on such a machine) and `<folder>/threads.jsonl`, saying `trace start` and `trace end … watcher=terminated code=-15` for a watcher that outlives the run, then `trace.failed stage=watch … code=1` and exit 1; the real watcher against a copied binary and a directory where its file would be failing the command with exit 1, its `stage=open` and the error; `--trace` never reaching Flutter, and refused `trace.refused … code=2` on Windows, on a build, without its folder, followed by a flag or with a folder that cannot be made, nothing run; on Windows the real watcher’s run skipped (its `/proc` and `os.sysconf` are Linux’s) and the `/proc` folder left out of the refusals
`scripts/tests/test_thread_watch.py`	the per-thread CPU watcher (`run-linux.sh --trace`): a spinning child’s main thread read near a whole core, one line per thread with `{at, pid, tid, name, main, state, cpu}`, the watch ended with the process (a zombie counting as ended); a stat line whose name holds spaces and parentheses parsed; a thread born since the last reading counted from nothing and CPU divided by the time that passed; a process that does not exist refused, and a file it cannot open (a missing folder, a directory in its place) or write (`/dev/full`) failed with exit 1, its stage, file, error and ms; `--exe` finding the process that runs an executable, none for a path nothing runs; Linux only (`/proc`, `os.sysconf`), the module skipped on Windows with its reason
`packages/filmopen_engine_mpv/test/`	the libmpv adapter (§19.16): its compilers to the EDL and to FFmpeg’s graph against goldens, `capabilities` answered without a probe or a child and the encoder chosen once per session, at the first export or through `debugEncoder`, the export and its cancel, subtitles written and released, the Windows audio output and process tools, every native and the person’s text logged as it is; `native_log_test.dart`: ten seconds of simulated native input (wakeups, property-change events through the drain’s own loop, handoffs, clock ticks) through `debugPrepareNative` and `debugPlayNative` adding frames and clock readings and no event but, on Windows, the decoder’s first reading and its one change; a play reaching the end (`eof-reached`) stopping the clock, said once as `ended`, and through `LoggingEngine` one `ended` summary with its frames and position, no second one at a later pause, and a play then starting from the beginning; an exact seek while playing, which mpv plays on after, ending the play before it in a `seek` summary and the play after it in its own (`ended` or `pause`) with every playback frame after the answered seek, the clock’s 100 ms ticks keeping their own phase across the seek; a seek near the end whose play reaches it before any playing reading: the adapter’s `audio` event `playing: true` at the answer, and the `ended` summary with its one frame and position; `spanning_export_test.dart`: a scene’s timeline (`SceneTimeline.build`, `toEngineTimeline`, `compileFfmpeg`) whose spanning 24 fps clip resumes near its end in a 30 fps project, its rate unknown and probed, run by the system’s FFmpeg with libx264 for libopenh264 and every frame there (90 of 90, the resumed piece held; skipped without FFmpeg, libx264 or FFprobe)
`scripts/tests/test_mpv_*.py`	libmpv’s builders and CMake (§19.16): the font libraries bundled from its prefix, the Windows filters and `pacman` line (libplacebo), the Windows native paths; a native prefix bundled and linked by an mpv build alone, the default and MLT builds holding none of it and never stopped by a half-built one; MLT’s and libmpv’s Linux plug-ins configured and installed with both prefixes present, each build holding its own engine alone, and MLT’s Windows entry bundling and installing nothing for another engine; the Windows runner’s clear, run on an earlier MLT build’s folder, leaving none of its DLLs, programs, `lib/mlt` or `share/mlt`, before the plug-ins install
`scripts/tests/test_trace_acts.py`	`scripts/trace_acts.py`’s lines around a command, with the CLI stood in: the command’s words logged (`call`) before it runs, its exit code, answer and time (`step`) after, between the act’s `start` and `end`
`scripts/tests/test_trace_report.py`	`scripts/trace_report.py` on an strace log written by hand: calls by kind with their time, a call split by another process’s joined; files opened, read, written, listed, renamed, deleted, made and failed, and the bytes read and written, by folder group, a group’s folder itself included and a sibling with the same prefix not, the SDK, the rest and no absolute path (a pipe, a socket) built in; each act’s window from `scripts/trace_acts.py`’s start and end lines counting only its calls; the app log’s events per act with the package whose `lib/` emits them — the name given to a log call: its first argument, a condition there or a later line included, or the second after a level —, a package holding it only as another literal (a semantics identifier) not claimed but given as `uncertain:` where no log call names it, `unattributed` where nothing holds it, and the most in one second, an act with none saying so; the stages logged: lines parsed, not understood and the first, the acts file’s lines that are not JSON and acts never ended, calls unfinished at the end
`scripts/tests/test_engine_mlt_docs.py`	the MLT engine’s README naming only arguments its builder takes and the stamp’s door, and its generated page saying that `MltEngine` is the native engine of `mlt_engine.dart` where `dart:ffi` is and refuses everything elsewhere
`scripts/tests/test_mlt_bundle.py`	the MLT plug-in’s Linux bundle shipping libass, FreeType, HarfBuzz, FriBidi, Fontconfig, libpng and zlib and nothing else of the system’s GUI stack, and linking the app’s executable with `--disable-new-dtags` (a transitive RPATH, so GTK takes the bundled font libraries)
`scripts/tests/test_mlt_windows_subtitles.py`	the MLT Windows build taking MSYS2’s libass, configuring FFmpeg with `--enable-libass` and refusing one without `CONFIG_LIBASS` or the subtitles filter (the LGPL checks kept), melt’s `-query filters` required to list `avfilter.subtitles`, the builder expecting libass’s whole DLL closure in the prefix and checking that no import resolves outside it, and a Windows notice naming each of those DLLs
`scripts/tests/test_mlt_windows_smoke.py`	the MLT Windows build’s melt smoke playing again on SDL’s dummy driver where SDL cannot open audio or start its driver, keeping the first play’s words, logging `melt.audio_dummy` and judging the last play, each play timed with its exit code and last position and logged whether the smoke passed or failed, no stale play of an earlier run left
`scripts/tests/test_mlt_outside_prefix.py`	the MLT build’s last check catching every shipped library — FFmpeg’s, MLT’s and MLT++’s, SDL2, OpenH264, libass and the font libraries, by their whole sonames — in an `ldd` line outside the prefix, and none of the system’s own (libc, libm, expat …)
`scripts/tests/test_font_abi_check.py`	`scripts/font_abi_check.py` refusing a prefix that lacks a symbol the system’s PangoFT2 imports (naming the `FT_` and `Fc` ones) or Cairo’s `png_` ones, passing one that exports them all; on compiled libraries an import at another version than the definer’s missing; an absent consumer skipped and said, none present refused
`scripts/tests/test_runpath_check.py`	`scripts/runpath_check.py` on compiled libraries: `$ORIGIN` passing, a library needing nothing of the prefix needing none, a mangled relative run path (`RIGIN`), on a library needing the prefix or not, and a library needing the prefix without `$ORIGIN` refused by name; a module in `mlt-7/` needing the parent folder’s library without `$ORIGIN` refused
`scripts/tests/test_make_subtitle_scene.py`	the subtitle scene’s script answering `--help` as a success, no failure logged
`scripts/tests/test_with_bench_lock.py`	two holders of the bench lock never overlapping, the command’s exit code passed through, the lock seen by a byte-range lock attempt
`scripts/tests/test_replay_readiness.py`	twenty-one deterministic replay regressions: a recorded Create followed by matching entity creation and project opening gates only its dependent navigation or tab, including a tab tap consumed into one set_tab; the expected selection comes from the recorded navigation or state, and polling requires that exact selection and an editable entity, waits at most 20 seconds, fails on malformed or refused state, and never repeats Create; unrelated events, user actions, earlier navigation or another tab exclude the gate; a real tab refusal is sent once and remains a failure; autosave and idle precede state comparison, which precedes picture comparison, an earlier transient checkpoint runs before a later tab gate, and canned completed Create answers retain both comparison failures against a recorded transient checkpoint; a digested `entity.created` stem, as the app now logs it, is waited for as a raw one is.
`scripts/tests/test_stock_dock_readiness.py`; `test_plans/030_issue-recorder.md`	the stock missing-key dock settling before a new recording and, in replay, after viewer restoration but before entity restoration; six helper tests cover the wide published row followed by frame settlement, the compact closed body, the existing twenty-second bound, immediate refusal or malformed-answer failure, safe unexpected-error diagnostics, first-offer profile selection and entry-point ordering with the final file comparison retained. The recorder plan prepares a displayed tree at its root before recording and keeps every original picture, state and file comparison.
`scripts/tests/test_replay_retention.py`	five runner regressions over a synthetic child and temporary folders: a nonzero replay remains a failed plan check; its full recorder input, including nested snapshots and binary files, and byte-exact child stdout, stderr and status are retained before the task home is removed; success keeps child output and status, copies no failed input, and remains a passing check. Repeating the same output folder for two failures keeps their exact separate file sets and byte streams without mixing or replacing earlier evidence.; a timed-out child retains partial output and its timeout status, while an input-copy failure remains FAIL and preserves the original task home without a bare traceback
`scripts/tests/test_replay_deadline.py`	four cooperative deadline regressions over the real replay main and controlled owned-server input: expiry releases a held reply, runs owned cleanup and returns 124 without touching another server; success keeps the actual file comparison and cancels late expiry; already-closed input errors are harmless; a non-deadline server exit remains an error after cleanup
`test/ui_boundary_test.dart`	five boundary checks: media UI, tree, browser and compare neither declare a jobs dependency nor import it; forms reads public job presentation data, including `JobPhase`, without jobs internals or engine, storage and journal declarations
`scripts/tests/test_gen_plugin_api.py`	the generator of the types file (§6.11) on an in-memory definition: a function with a built member (`http` and `http.read`) declared as a callable with properties, the namespace beside it unchanged and the definition read not written; the same member planned leaving the function as it was and written in `FilmOpenPlanned.PlannedContext` by its whole name
`packages/filmopen_plugin_host/test/http_stream_test.dart`	streamed heads before body completion, complete event batches, one pending read, whole-body non-SSE and non-2xx answers, frame ownership and EOF, raw byte bound, per-chunk timeout, broken bodies and cancellation, the transport’s headers withheld from the plug-in by name and every header in `plugins.http.response`, every vector reaching its reads as it came, each read’s events logged as they came, an echoed file and key included, events framed after a read and before a broken connection or a Stop logged under `unread` the same way, events queued when the response ends and then a Stop or the frame’s end before the last read logged once on `.unread` and never when the last read takes them, error events logged as they came with their code and whole message, a transport failure’s message logged; the head and each read with events told to the ledger once
`packages/filmopen_plugin_host/test/sse_framer_test.dart`	server-sent events (§6.11): every stream vector at its recorded byte cuts and in single bytes; incremental UTF-8, malformed bytes, CR, LF and CRLF, comments, names, multiline and empty data, discarded fields and unfinished events
`packages/filmopen_plugin_host/test/stream_vectors_test.dart`	the stream vectors in `test/fixtures/stream/` that the host, the plug-ins and the website test against (§6.11), kept honest: the manifest naming exactly the folder’s `.sse` files, each vector’s provider and `api` agreeing, chunk offsets inside the file and ascending, events of `event` and `data`, every body ending, each assembly’s keys; CRLF in the CRLF vector alone and kept by its `.gitattributes`; nothing matching the commit guard’s key shapes, read from `scripts/check-no-keys.sh`; the one planted credential in the error vector’s body alone and handed over as it came
`scripts/tests/test_runner_lifecycle.py`	seven Python regressions without an app: failed/malformed launches abort; owned-app `ended` aborts except an explicit final probe; successful launches and ordinary refusals remain observable; stale or wrong-child events cannot complete a folder mutation; a new matching event and both expected disk writes are required; a half-completed move fails immediately
`packages/filmopen_jobs/test/`	Jobs tests: JSON round trips and unknown fields; six `JournalWrites` failure cases for initial and replacement writes, leaving the old or new complete record, never a partial one (or no initial record before rename); unsupported schemas and malformed records preserved and reported; session jobs touching no disk; sequence order, capacity and holds, retry deadlines across restart, controls under full lanes, missing runners and presentation data kept out of persistence; targeted recovery regressions for a stored stop, rejected controls, observer removal after dismissal, takeover binding of newly discovered jobs, discovery after an explicitly restored journal was initially empty, and stale completion after a newer stop; lease fencing, throttled renewal with a fake clock, guarded-effect renewal reset and idle durable-session write counts; stale/terminal claim removal, live and held claim preservation, separate-process nonblocking execution claims, exactly one winner between subprocess contenders and repeated claim/sweep races; the producer stand-in opening its own bytes and acknowledging kept output; public boundaries. The web smoke compiles the public surface to JavaScript (§6.12)
`packages/filmopen_jobs_ui/test/job_row_test.dart`	state and phase sentences; display-name, reference-tail and kind fallbacks for additions and both sync directions; exact fetch-kind recognition pinned against the sync constants and near matches refused; receiving phases, error colour, progress, offered action identifiers, busy-action reasons and per-row semantics; done-fetch kept-local and already-agreed outcomes, with unknown, send and unfinished outcomes preserving ordinary words; the render manager’s refusals `noManager`, `journal`, `noJob`, `notReady` and `cleanup` each its sentence, the host’s `producer.journal` the same as the manager’s, an unknown code the phase’s; a failure’s `detail` read as its sentence, in the code’s sentence’s place, at 700 and 1200 pixels, light and dark, the code’s sentence where there is none, a possible charge said with no detail too
`packages/filmopen_jobs_ui/test/render_row_text_test.dart`	a queued producer’s real Activity row says Waiting to render rather than Waiting to start in English, light and dark at 700 pixels; its offered Stop action operates once and no Flutter exception occurs
`packages/filmopen_jobs_ui/test/activity_page_test.dart`	Activity above Share, each page’s rows on it (§9.7): open-film filtering, newest-first insertion (Activity) and sharing (Share) lists, closed-film and empty states; Activity’s usage first, then Adding media, in one scroll view, with a film or without one, its Dismiss finished on the heading’s line; Share keeping a sign-in’s wait and its one Cancel while the film closes, and asking for a film; Share with nothing listed saying where a film is shared, its Set up sharing opening Settings on General, its Dismiss finished on the Sharing heading’s line; each page’s Dismiss finished acting on its own jobs; each action sent to its owning service; Dismiss finished for done and stopped jobs, leaving failures; action refusals, safe exception reporting, erasure after job changes, busy-action suppression, sign-in ordering and cancellation; every send/addition phase at 375 and 700 px; receiving, received and reference-named conflict rows at 375, 700 and 1200 px, all three conflict actions routed to sync without overflow; row semantics, wait and refusal live regions; a render waiting for the plug-ins to be read again listed, its Stop going to insertion; an application-supplied unplaced unread render remains visible with a film open or closed, with Dismiss alone routed to its exact insertion-service id; other-film and malformed non-null places are hidden, the open-film prompt is absent while that row is actionable, and Dismiss removes only that row without a sync action; Cancel going to the job that started the wait, which also reached the sign-in, though its row or its film left; Activity’s Syncing lines: the film’s files queued, working or just done, each by name with a bar where its progress is measured and a check once done, failures and holds left to Share, logged once per change (`activity.sync.rows`); Share’s rows found within Share where Activity draws a line of the same send; every action logged as it starts, with its job’s kind, phase and state, and as it ends — accepted, refused with its code, a sign-in not finished, an action that threw — with its time, a refusal or failure as a warning; its two tabs: Now opened first with today’s rows, one scroll view under the tab bar; Files’ empty states with no comparison and with no film, its groups in order with their counts, the compared time, the Share hint under three groups, a long path wrapped and one measured bar at 375, 700 and 1200 pixels, light and dark; `activity.tab` and `activity.files.rows`, once per new comparison
`packages/filmopen_jobs_ui/test/job_settlement_text_test.dart`	the real Activity row says the whole attached-but-unsettled or film-wait sentence in English and Spanish, light and dark at 700 pixels; generic attention/import and lost-input text are absent, Try again/Dismiss or Stop fit and each offered action operates once; bindingChanged caption selection follows three exact action sets: Retry/Dismiss retains render recovery words, while Dismiss alone and Stop alone use neutral insertion words; English and frozen Spanish controls operate in light and dark, with the new English sentence checked in full
`packages/filmopen_l10n/test/step4_job_text_test.dart`	waitingToRender mapped to the existing queued-render sentence in English and Spanish
`packages/filmopen_jobs/test/job_api_test.dart`	equality across all eleven view fields, null fields, order-independent map entries and action sets with compatible hashes, and immutable copied collections; a `needsAttention` result’s `displayName` reaches the job’s view, null by default
`packages/filmopen_jobs/test/engine_report_test.dart`	preserved unsupported/malformed records reported at every load, a malformed one with its text; the public session engine reporting an unexpected runner failure; scheduled tick and refused action persistence reporting their codes, runtime types and whole messages; ten scheduled ticks with refused journal writes yielding ten `tickFailed`, each with the message, with no `operationFailed`; a done job a day old expired by the tick, durable (its file deleted) and session, a minute short of the day kept, `expire` reporting the job’s kind, phase, `doneAt`, age, rule and journal and `expired` the outcome `removed` and the milliseconds, with no error; a removal the journal refuses reported `expired` with `failed` and the error’s text, the record kept and the tick failing; a wrong-typed projection door reports once, omits its private value and preserves the ordinary view; a correctly typed projection receives the exact record and changes state arguments without persisting them
`packages/filmopen_jobs/test/binder_start_test.dart`	a deferred at-start binder failure isolated to one record with a one-second retry deadline and released claim, healthy work proceeding in the same tick, successful reconstruction after the deadline, diagnostics with the error’s text, views with codes only, and cleanup respecting the binding-failure deadline while retaining its pending cleanup intent; an accepted Stop retaining the stopping state and no second Stop action while failed cleanup binding waits for its saved deadline
`packages/filmopen_jobs/test/cancellation_cleanup_test.dart`	a recovered or live stop runs only its cancellation callback; a refused or thrown cleanup needs attention with its stop intent; a cleanup answering a held `waiting` leaves the record waiting with its actions, no stop intent and no cleanup pending, reported as `cleanupResult` with the decision `held`, its Retry running the ordinary runner and a later Stop the cleanup again, Dismiss removing it; a delayed retry from a cleanup is not held, needing attention with its stop and reported with what the cleanup answered
`packages/filmopen_jobs/test/claim_cleanup_test.dart`	dismissal of a terminal record while claim release drains still removes its durable run lock
`packages/filmopen_format/test/json_document_test.dart`	a root that is not an object as `NotJsonObjectException`, apart from malformed JSON and a duplicate key; deep-copy isolation and mutable document-root replacement followed by typed iteration and copying; run on both VM and Chrome to exercise the web decoder
`packages/filmopen_format/test/manifest_test.dart`	Drive, folder and FilmOpen Cloud sync parsing and serialization, username/tag identity round-trip, unknown-field preservation, malformed values and unchanged new-project template
`packages/filmopen_store/test/manifest_sync_loader_test.dart`, `manifest_writer_test.dart`	wrong-shape warning; fresh-text manifest writes, copied callback input, unknown fields, concurrent-write refusal, missing manifest/viewer and read-only refusals, no director gate
`packages/filmopen_platform/test/sync_directory_test.dart`	separate sync journal path without creation; web unsupported
`packages/filmopen_platform/test/monitor_window_test.dart`	the pop-out’s door (§19.15) on a stand-in channel: nothing asked before `check`; open, full screen and close through the runner, each logged with how it was asked, a full screen already on asking nothing; the runner’s refusal and a runner that does not answer disabling the door with their reasons; the runner’s events logged as `monitor.window`, the window’s own close taking the runner’s reason, the keyboard’s move handed to the views and kept as `focusedView`
`packages/filmopen_state/test/browser_edit_request_test.dart`	a navigation’s ask for View/Edit (§9.2): made only when asked, a token of its own each time, dropped by the next navigation, and kept as it was by a row opened or closed, every row folded and the selection pinned — so that a rebuild never asks again
`packages/filmopen_state/test/sync_provider_test.dart`	inert construction, open/change/reopen ownership, null captures, microtask coalescing, bounded close, real memory sends and seeded distinct film views; arrival bursts resetting the 300 ms quiet interval, other/closed/loading films ignored, pending reads discarded on close or film switch, and one follow-up after arrivals during a held read while preserving a remaining interval; durable disk agreement reused after service restart and session receiving with a configured directory leaving disk ledger and parts untouched; a manifest update written as the username in effect, an empty one being `default`; `accountReady` releases the service’s wait and reconciles the open film with `signedIn`; with no film open it releases alone and the film reconciles when it opens; a write of the app’s own that landed and is not yet published is the local side sync hashes, unread, and what a patch’s release is held against
`packages/filmopen_state/test/sync_status_provider_test.dart`	`syncStatusProvider` (§6.14): read at once, again at its film’s comparison and at a change of the jobs, another film’s comparison and an unchanged read adding nothing, cleared to null
`packages/filmopen_sync/test/status_test.dart`	the sync status (§6.14): a pass’s comparison giving every file of both sides its word — conflict, to send, to fetch, available, else the same — in path order with its counts; the jobs laid over it, moving with its progress, a wait and a failure with their codes, a finished one the same, a cancelled one the decision’s, the one moving winning over an earlier failure; the service keeping it at a pass with `status`’s line, clearing it for another target and for none with `status.cleared`’s reason, `statusChanges` naming the film each time; `NoSyncService` comparing nothing
`packages/filmopen_state/test/sharing_settings_test.dart`	machine folder persistence and Google sign-in hint independence; an agent build’s host neither reads the stored account hint (no restoration at its start) nor writes it
`packages/filmopen_state/test/film_replaced_renders_test.dart`	a producer’s job ending `filmClosed` counted once, whatever snapshots repeat it (§6.13, §9.7); an upload’s, or a producer’s in another state, not counted
`packages/filmopen_state/test/job_views_provider_test.dart`	equal seeded and later snapshots suppressed after place filtering; other-place changes ignored; changed fields, order and empty results published correctly
`packages/filmopen_state/test/sync_trace_install_test.dart`	the application’s sync service writes its trace to the log at info as `sync.<event>`, with the film key as it is
`packages/filmopen_insertion/test/insertion_logging_test.dart`	producer start and producer cleanup failures log the error’s type and message and the job’s stage; a file the store fails logs `insertion.upload.start` with the source’s description, `media.importFailed` with the input, what was written, the error’s type and its own text, and `insertion.attemptFailed` with the job’s stage, and the upload’s own end `insertion.upload.failed` with `writeFailed`, the error and its `ms`
`packages/filmopen_insertion/test/insertion_recovery_test.dart` (binding)	an English upload restored in Spanish retains its output and batch and completes attachment; a changed viewer remains refused; a producer whose record cannot be written keeping no output and ending `failed` with Dismiss alone; a partial producer’s record numbering its items as ordinals
`packages/filmopen_insertion/test/recovery_projection_test.dart`	the recovery’s kind and id remain on production, ingest, thumbnail and terminal views; restore projects from each exact loaded record, including terminal and binding-refused id-only recovery, replaces forged association fields while preserving ordinary state arguments and performs no entity patch; a render failing with the provider’s message keeps it as the state argument `detail` of its terminal row, after a restart over the journal too, and a later failure saying nothing carries none
`packages/filmopen_jobs/test/lane_hold_test.dart`	persisted interruption before cancellation, checkpoint and attempt-count preservation, idle and other-lane isolation, stop precedence during draining and cleanup, cleanup before requeue without a terminal view, failed intent leaving a runner active, failed cleanup retry preserving hold intent, immediate hold/release still interrupting an opted-in attempt, default non-interruptible work completing while its successor waits for release; interruptible runners without cleanup preserving `done`, `failed`, `needsAttention` and `retry` under a lane hold, with consumed hold intent cleared so retry deadlines and lane actions remain effective
`packages/filmopen_insertion/test/insertion_recovery_test.dart` (lane hold)	an upload interrupted after its first committed put takes it back and, released, imports it once under a new id with one batch; a failed second file takes the first back, and Retry imports both; a restart before the record asks for the source and attaches nothing; a running producer continues under a hold and attaches once without cancellation or another start
`packages/filmopen_sync/test/inventory_test.dart`	one source listing and lengths for the manifest, flat documents and media; document MD5s and no media-byte reads; thumbnails, nested paths and other files excluded; a held document hashed from its text unread where its length is the file’s, read once where it is not (a byte-order mark the reader dropped)
`packages/filmopen_sync/test/difference_test.dart`	the document decision table: local-only files sent, target-only files fetched without replacement authority, equal hashes recorded as agreement, only a changed target fetched with the local hash guard, only a changed film sent, and divergent copies with no agreement or changes on both sides held as conflicts; matching asides suppress both directions until either hash changes, and equality clears an old aside; absent or malformed target document hashes refused; sends and fetches ordered manifest first, then documents and media by path, conflicts ordered by path; present media never fetched, with a changed size remaining a create-only send
`packages/filmopen_sync/test/rules_test.dart`	the two lane names and all four send/fetch kinds, each mapped to its lane and direction while unrelated kinds are refused; default capacities of four media and one document, retry delays doubling from five seconds to fifteen minutes with jitter bounded to a fifth and never exceeding the cap
`packages/filmopen_sync/test/payload_test.dart`	required send/fetch direction, legacy directionless payloads refused, and stages restricted to their direction; a conflict requiring a document and both hashes; document hashes required, optional media hashes limited to fetches, a fetch replacing only a document with its local hash guard, and received counts bounded by file size; send-only and fetch-only fields refused in the other direction, including explicit nulls; retained send progress, checkpoint and replacement rules, path-to-lane matching and bounded opaque target identities; absolute paths and parent traversal refused as paths, a checkpoint’s paths and addresses kept as the target wrote them, and credential keys refused inside and outside a checkpoint
`packages/filmopen_sync/test/folder_target_test.dart`	flat manifest/document/media inventory with document MD5 and exclusions; media streamed through a temporary file and published whole; existing and concurrently created media names preserved, including one published after the last absence check; a file-system failure `unavailable` with the system’s words; document replacement visible only after completion and the old document retained after stream failure; truncated and throwing sends cleaning owned temporary files; redirected media parents preserving unrelated outside files and unexpected staging contents surviving cleanup; find, missing-root retry, zero committed offset, traversal and linked-directory confinement; whole-file, suffix and end-of-file fetches retaining the full length and document MD5, media streamed without a reported hash and empty files accepted from zero; invalid offsets and paths refused, missing files unavailable without creation, linked files and parents refused, and the path checked again at subscription so a removed file reports unavailable and a redirected parent exposes no outside bytes
`packages/filmopen_sync/test/folder_target_stub_test.dart`	the filesystem-free folder target refuses fetch as unavailable with a permanent failure, including zero, positive and negative requested offsets
`packages/filmopen_sync/test/ledger_test.dart`	memory and directory agreements isolated by film and target; manifest and document hashes written together, asides retaining both hashes and cleared only by agreement on their path; defensive result maps and concurrent updates without lost paths, including separate ledger objects using one file; unsafe paths and malformed hashes refused before mutation; the hashed filename and complete schema restored by a fresh ledger; missing files empty without a report, malformed or unreadable files empty for the run with one report naming the film, the target, the file and the error; a later agreement replacing a malformed ledger without preserving partial entries, and a throwing diagnostic callback unable to change the answer; `decide` reading agreements and asides once, recording what it answers and clearing their asides, an empty answer writing nothing and an invalid one refused
`packages/filmopen_sync/test/parts_test.dart`	memory and directory parts separated by film and job, two jobs of one film appending at once; ordered appends, held lengths, readback, repeated discard and exact-prefix resumption after a stream error; flushed files restored and extended by a fresh store; invalid film tokens, job ids and retained-id sets refused before a write or sweep; only unretained known part files removed, with retained parts, other films, unknown files, nested directories and links preserved; traversal unable to read, replace or remove a sibling file
`packages/filmopen_sync/test/local_bytes_test.dart`	memory and disk streams from the same byte offset, whole streams by default, and an empty memory stream at its end
`packages/filmopen_sync/test/helpers/web_smoke.dart`	the public sync barrel, rules and folder target compile to JavaScript without a disk import
`packages/filmopen_sync/test/service_test.dart`	one job per pending file and live deduplication; coalesced reconciles; four concurrent media sends and serial documents with the manifest first; document edits before, during and after sends, including a return to an earlier value settled by completion and an equal pair establishing agreement before a local edit and its return; missing and changed media; exponential retry deadlines and attention at failure eight; immediate sign-in lane actions; permanent failure blocking until dismissal; unexpected errors reported with their message; absent and closed-film bindings, restore, film filtering and a lost send answer settled by find; the local side from the text the app holds, a send compared with it when done (`send.compared`) and an edit landed meanwhile sent; a byte-order-marked document held without its mark agreed, or sent once, with no further pass; a pass asking the ledger one `decide` and nothing else; a send’s follow-up logged `job.settled`; the send’s compare logging both texts; a conflict set aside and unchanged passed over, the log holding the local and target hashes, the agreements and the aside’s pair, and each path’s decision
`packages/filmopen_sync/test/support/memory_target.dart`	The memory target reads snapshots from a requested offset and refuses absent files and invalid offsets
`packages/filmopen_sync/test/retarget_test.dart`	held document and media sends reach a newly selected target with session and durable keys and a two-second settle; changes and removals detected at runner entry and between chunks; completed and attention jobs retired, target removal leaving no live work, durable restore retiring old-target jobs, and refused retirement reported without blocking the new target, each retirement traced as it is sent and as it ends (`retire`, `retire.done`); send payloads carry the SHA-256 target identity and direction while place keys retain the original target identity and their four elements for media or five for documents
`packages/filmopen_sync/test/progress_test.dart`	durable progress throttled across a thousand callbacks while reaching 1.0; safe opaque checkpoints retained; every persisted payload checked; a token checkpoint refused before persistence or display and reported with its keys and refusal; a target failure code that is not a short word becoming `sendFailed`; target input-map mutations isolated
`packages/filmopen_sync/test/lane_hold_test.dart`	lane holds through the engine’s door: interruption after a media chunk and exact remaining-byte resumption from the safe checkpoint; documents running while media waits and queued Stop, traced as `action {stop, accepted}` with no `send.start` for the stopped job; Stop after partial transfer; a reconciliation preserving the sign-in hold; an accepted sign-in lifting it and the send running again
`packages/filmopen_sync/test/support/resumable_target.dart`	The target fixture keeps partial bytes private and gates each send chunk; fetches read snapshots in two-byte chunks, record their requested paths and offsets and can wait at separate cancellable media gates
`packages/filmopen_sync/test/fetch_test.dart`	a 300 MB fetch in 64 KB chunks written through one append, one flush and one `fetch.part` line; a held part write holding the socket read; a part write failing before or after the store reads ending the fetch at once, its line saying why; four media of one film receiving into their parts at once; a manifest-only film receiving two documents and two media files byte for byte without a put, with document agreement and exactly one arrival per published file; target changes replacing only agreed local text; named conflicts retaining both hashes and all three actions, Take theirs using the current text guard, Keep mine automatically reconciling and sending, and Dismiss suppressing the same hashes until either side changes; local edits after inventory and stale document writes deciding again without overwriting, including a newly created name and a copy now equal to the target; Take theirs retrying only its approved local hash and stale-write revocation surviving a transient re-read failure; single and double UTF-8 BOM copies preserving bytes and the source text guard, the arrival’s text the document as a reader decodes it, its mark consumed; rejected response metadata still cancelling the returned stream; existing media never fetched, whether lengths match or differ; live work excluding the opposite direction and duplicate conflicts; changed target bytes and media checksum mismatches retried before publication, with invalid parts discarded and retried from zero; vanished target files, invalid UTF-8 and newly occupied media names refused; receiving stream errors cancelling subscriptions and reporting their message; Stop preserving the unpublished prefix; no-copy kept-local and already-agreed outcome arguments, with actual-copy completions carrying no such marker; stale inventory automatically requeueing a changed path and an independent missing file; broadcast arrivals closing with the service and the inert service emitting none; stale captured equality unable to regress newer agreements in memory or on disk; overlapping bulk agreement and row-removal/aside persistence unable to recreate an unchanged dismissed conflict; immediate single arrival after document publication despite agreement failure and a no-write equality Retry; media cleanup failure completing with a contained diagnostic, with its retained part swept only for its own film at restore; a conflict decided from the local text the app holds, unread, or read once (`fetch.compared`)
`packages/filmopen_sync/test/restart_test.dart`	durable bindings, closed films, retry deadlines, restored place-key deduplication and exact-offset send recovery; wrapped close errors retaining their local cause, and reopening during target cleanup recovering automatically for durable and session jobs; media fetches resuming from their flushed disk prefix after a lane hold, a closed film and an application restart, with the same job and no repeated prefix or put; durable restore preserving live fetch parts and sweeping only this film’s terminal and orphan parts, leaving other films and unknown files untouched; session restore and successful receiving using neither injected disk parts nor a disk ledger or journal; conflict hashes, path and three actions surviving restart, with dismissal persisting the aside across another restart; persisted Take theirs authorization refusing a changed local hash after a failed transfer, and durable revocation surviving a stale write followed by a failed re-read, both through fresh disk-store instances; directionless journal sends needing attention as sendFailed after both restore and Retry; target retirement setting no conflict aside, so returning to that target raises it again; kept-local and already-agreed outcomes surviving real journal restoration, with an interrupted completion clearing its old marker before a resumed failed transfer and successful single-publication Retry
`packages/filmopen_sync/test/crash_test.dart`	real child-process exit after publication and after two durable chunks; recovery finds completed files or sends only the remainder.
`packages/filmopen_sync/test/support/crash_target.dart`	The crash target reads committed bytes through its backing folder target
`packages/filmopen_sync/test/boundary_test.dart`	runtime dependencies and import boundaries; exactly four I/O files for folder targets, local bytes, ledger storage and parts; exactly ten public barrel exports, including the ledger, parts and the shared transfer streams, with inventory, difference, payload, runner and storage helpers kept internal
`packages/filmopen_sync/test/trace_test.dart`	the sync’s trace on the memory target with a capturing `SyncTrace`: a reconcile’s `start`, `inventory`, `decided` and `done` with counts and milliseconds; a send’s `start`, `checkpoint` and `done`, a send already there `settled`; a local read failing as `failed {stage: read, code: sendFailed, verdict: needsAttention}` with no `nextMs`; a retryable target failure with its incremented count and `nextMs` equal to the delay the result carries; a fetch’s `start`, `decided` and `done`; a fetch failing at its local read (`read`) and at its publication (`write`) with `receiveFailed`; a reconcile’s `start` naming the target’s identity, and a folder target’s root; a conflict with its two whole hashes and its resolution; a running send and a running fetch stopped as `cancelled` with no `done`; a film closed under a send as `waiting {filmClosed}`, a sign-in refusal as `waiting {hold, signInNeeded}` beside `hold {signIn}`; a lane’s `hold` and `release`; `reconcile.skipped`, `reconcile.failed {stage: inventory}`, `restore` and `restore.failed`; a trace that throws changing nothing; a rejected payload’s own values in no event’s name or data; a submission refused after the decision as `reconcile.failed {stage: submit}` and a reconcile after close as `skipped {serviceClosed}`; on a real durable engine in a temporary folder, a Stop of the old target’s job refused by an unopenable journal lock as `reconcile.retire` then `reconcile.failed {stage: retire}`, the same exception propagating, and a restore after close as `restore.skipped {serviceClosed}`; `nextMs` equal to the delay the engine received, with one draw of a distinct random sequence; the film key, the paths and the target’s identity as they are
`packages/filmopen_sync/test/deferral_test.dart`	A document whose form is open is not submitted and `reconcile.decided` counts it, media never deferred; a send queued behind another before its form opened waiting `formOpen` with no read, then sent once resumed; a form opened at the submission boundary preventing the submission (`send.deferred`); a form opened during the target lookup holding the send before its snapshot is read; a send retrying after a failure waiting `formOpen` before any read; a `formOpen` wait committed after its form was left resumed with no further event; a fetch never deferred; a persisted `formOpen` wait restored while its form is open kept without a read, and resumed when nothing is open; a strict reconcile throwing on an inventory failure and on a superseded pass, an ordinary one keeping 0, coalesced strict and ordinary callers each getting their own outcome; an answer that throws holding the send. The restored-job harness waits for its third job to reach `JobPhase.done` before teardown can delete the journal folder; the deferred send’s line names its path
`packages/filmopen_sync/test/sign_in_wait_test.dart`	a target’s failure reads `SyncTargetException: <code> (<verdict>)`; FilmOpen Cloud with no token is asked once, reported `inventoryFailed` and held once (`reconcile.hold`), later passes skipped `signInNeeded` with no listing, a strict one `ReconcileIncomplete(inventory, signInNeeded)`; `accountSignedIn` releases once and the next pass lists; the wait read after the capture — a folder target listed, a removed one `noTarget`; a `refused` (Drive’s, a 401) holds nothing; the first strict pass with no token answers `signInNeeded`, a target’s other failure its own code (`unavailable`), only no token holding
`packages/filmopen_sync/test/local_changes_test.dart`	what of the folder is not yet on the target (§6.14), read against the ledger alone: a folder equal to the last agreement has nothing, the target not asked; a document changed since the agreement, or never agreed, named by its path; a film without a target has nothing to compare (`local.compared`); its trail — start, the ledger and folder reads, each document with its local and agreed hashes (`never-agreed`) and whether it differs, the end — and a folder that cannot be read failing with its stage (`local.failed`)
`packages/filmopen_sync/test/on_demand_test.dart`	Media on demand: a remote-only media file is available — not fetched, sent, deleted, agreed or a conflict; `fetchNow` joins one job per path; a slower inventory never republishes a fetched file; the snapshot replays; a target change clears it; null policy is eager
`packages/filmopen_format/test/stems_test.dart`	the filename grammar: every name kind, takes back to their source and batch, rejections (a version or take number too long for an int among them), naming warnings, the reserved owner
`packages/filmopen_format/test/set_stems_test.dart`	the stems of the pending sets (§5.1; Project Specification §5.3, §5.4): `cp` and `as` types of their own in the set category; `cp_`, `as_` and `rd_` parsed into one `BatchStem` whose `type` survives a round trip; a render batch’s stem unchanged, its type the default; an unknown prefix, a versioned shape and the reserved owner still unknown
`packages/filmopen_format/test/children_test.dart`	the script’s list (§5.11; the format’s §8.5, §10.1, §11.2, §17): `sc_1`, `fo_f4` and `sc_5_maria_v1` parsed to those, the last pinned; a dotted tag and a workspace handle; a bare tag, an entry of another type (a type the format does not know among them), a path and an entry that is not a string — a value JSON cannot hold among them, which never throws — each reported and never guessed; a type with no name (`sc_`) read as written; a second listing in one list reported on the second and later entries; 1.11’s four keys meaning nothing; the three edits pure and deep-copying, leaving every other key and every unread entry alone, a file alone when the entry is not there or already there under either spelling, clamping an index, addressing equal entries by occurrence, moving a pinned entry pinned; an entry that is not a string addressed by what a reader shows it as — `5`, `null` and an object removed, of `5` and `"5"` the one the occurrence points at, a number moved staying a number; `nextNumberedTag` on an empty list, over gaps, among other short names, with the `f` prefix, and past the longest number a segment holds; a cue naming a `folder`, a `scene`, neither or both, with 1.11’s `unit` unread; the `fo` prefix in the filename grammar and `folderKinds`; the many-entry edits — added from an index in the order given, a listed entry and one given twice skipped and the place kept, each entry removed once, every other key and a list of another shape left alone, an empty selection changing nothing, the document handed in untouched and the result a fresh copy
`packages/filmopen_format/test/scene_cast_test.dart`	a scene’s `cast` (§5.13): an absent key as an empty cast, entries read as copies all the way down, anything A.5 does not describe not read; `castWithCharacters` — the entry that stays whole, a new one the name alone, the order given, typing back a file that names a character twice changing nothing, a name given more often than the file has entries adding one entry; `writeCast` removing the key for an empty cast; adding once, removing by index, an entry’s own epoch set and removed with everything else kept and the entry handed in unchanged; an outfit set and removed alike
`packages/filmopen_format/test/script_block_test.dart`	a scene’s blocks (§5.13a; Project Specification §10.3): a stamped block’s `updated` kept by a change — nothing written on an identity edit, the callback unable to set it, the read time kept on a real edit; a block of 1.23 read and written with its other keys kept and `id` first; what is not a block — a string, an id that is not a string, a known key of another type, a `text` beside a `dialogue` or an `action`; the reading rule for each kind, `offscreen`, `voiceover`, `dual` and a title’s `duration_ms`, and the retired keys never written; `copyWith`; the next number over gaps, other ids, id-less blocks and `next_block` above and below the highest, read as a whole number however JSON stored it (`7.0`), and a deleted number — the highest included — never given out again, every delete of a numbered block writing `next_block` so that a later copy’s delete cannot bring one back; add and insert with the next number, a block put in keeping every key but its id, the list rebuilt and never edited in place, remove, reorder with an odd entry kept where it falls, change writing nothing where nothing changed and numbering an id-less block, `apply` unable to set the id and setting the output duration; `output_duration_sec` read, written and kept when not a number above zero, a value set replacing the kept one, `rendered_sec` an unknown key; a `blocks` that is not a script refused by every change; `blockIdsUsedTwice`, `speakersIn`, `blockSummary` (the speaker kept beside a direction and alone), `splitDirection`, `blockLineOf` on both shapes; the sample’s three scenes in the new shape with every id a cue or a shot names; `withBlockNumbered` giving a block with no id its number, raising `next_block`, and nothing else — a block written before 1.23 kept as written, a block with an id left alone; `blockLogName` naming a block by its id only where it is `bl_<n>`, else by its place; `blockIdsOf`, and a render on 7 covering 7 to 11 — `coverageFrom` consecutive and empty where an id is missing or the last stands first; `coverageIntact` intact unchanged and with a block inserted before 7 or after 11, not intact with one inserted between 9 and 10, 10, 7 or 11 deleted, 9 and 10 reordered, 11 moved before 7, never an error; a block’s speaker (`speakerOf`) the entity the name came from, at the cast entry’s epoch, else the scene’s from the document given, none for an unknown tag
`packages/filmopen_format/test/script_diff_test.dart`	the script as a block diff (§5.13b): identical sides; an edit as `replace`, agreeing with `blockCase`; an insertion and a removal at their places; a reorder and a reorder with an edit as `movedOut` and `movedIn`; ties toward the left, the same answer every time; empty sides and a document without blocks; a repeat paired by its occurrence and an id-less entry by its place; `display` shared by a move’s two rows; 12,000 blocks in an equal order paired in place, within a bound the common-subsequence table cannot meet
`packages/filmopen_format/test/beats_test.dart`	a block’s beats (§5.13a; Project Specification §10.3): three beats read and written as they came, after `duration_sec`; a beat’s unknown keys kept and a position outside the three kept as written; a `beats` that is not a list, or a beat that is not an object or has a wrong-typed key or a `duration_sec` not above zero, refusing the block; an empty `beats` not written; an ordinary dialogue, speaker or duration edit through `withBlockChanged` keeping the beats and their keys, and a beats-only edit writing them; a beat added (`during_dialogue` with dialogue, none without, a block’s number given at its first change), changed, removed — the last taking the key — and reordered, the other beats and the block’s id kept; a beat out of range `noEntry` with nothing written, an unreadable block `notABlock`, a `blocks` that is not a script `wrongShape` whatever the beat; `beats` among `blockTextKeys`; `beatsTotal` and `beatsSummaryOf`
`packages/filmopen_format/test/subtitles_test.dart`	a block’s subtitles (§5.13a; Project Specification §10.3), the beats’ cases over `subtitles` with `text` for `description`: read and written as they came, unknown keys kept, an unreadable list refusing the block, an empty list not written, kept by an ordinary edit, added, changed, removed and reordered, out of range `noEntry`; `subtitles` among `blockTextKeys`; beats and subtitles side by side, an edit of either keeping the other; `subtitlesTotal` and `subtitlesSummaryOf` as the beats’ total and summary
`packages/filmopen_format/test/prompts_test.dart`	the prompts a document holds (Project Specification §9): `promptPaths` on a character, a location, an outfit, a prop, a project file, a folder, a Style and a scene with two blocks, an unknown kind listed, a block without an id and the old spelling holding none; `promptStateOf`‘s table — blank, no `created`, zoneless, of another shape, earlier by a second, equal, equal to the second, in another zone, later, a holder with no time; `withBlockPrompt` changing that block’s kind alone and removing an emptied `prompts`; a block’s prompts its content and their `created` a time; copy-left never moving a prompt’s `created`, `plugin` or `writer`, words copied over an attributed prompt clearing its `plugin` and `writer`, same words keeping the pair, and a block copied whole carrying its prompts’ words alone
`packages/filmopen_format/test/prompts_test.dart` (the block index)	`blocksById` keeps the first block of an id and skips a block without one, `promptAt` through it answering as the search does; on 500 blocks every `created` set aside and the document left as it was
`packages/filmopen_format/test/prompts_test.dart` (a copied list)	a list copied left is the draft’s own: clearing it leaves the right’s as it was
`packages/filmopen_store/test/folders_index_test.dart`	a folder in the index: the versions of a `fo_` file under one group without an epoch and no unknown file; a short stem resolved as a short reference of its type (official with no viewer and for an author who has said nothing) and a pinned entry to that version alone; a folder and a scene sharing a short name; `nextSceneTag` and `nextFolderTag` over a loaded project — an empty one, one with gaps, several authors, hand-made short names, shots and cues — and a scene that is in no list counting too; and a dropped `ep_`, `se_` and `sq_` file as an unknown file — reported, never an entity, never a row — with the project’s scenes beside its script and the folder it lists that no file holds dropped; and a short name a list names — by a short stem or a pinned entry, in the project file or in a folder — spoken for although no file has it, a bare tag and another type naming none
`packages/filmopen_l10n/test/labels_children_test.dart`	the codes of an entry of `children` as sentences (§5.11): each of the three with a sentence of its own, the type an entry names quoted in another type, an entry with nothing to report having none, and every value of the enum said
`packages/filmopen_l10n/test/labels_sets_test.dart`	a comp and an assistant session as words: singular, plural and count; every entity type a word of its own
`packages/filmopen_l10n/test/session_review_text_test.dart`	an assistant session’s review answers as sentences (§9.3): each outcome and code `SessionReview` gives, and the page’s own `unsaved`, its sentence — Picked: this version is in use., Already decided. for a discarded item alone, a pass’s skip of a gone or discarded version that code’s own —; an unknown code the generic one
`packages/filmopen_store/test/script_outline_test.dart`	the script as one viewer sees it (§5.12) on `foldersFixtureFiles`: the project’s entries depth-first, four folders deep; a second listing in another list on the later row, its first clean; a cycle drawn, not followed, and the report where it is a second listing too; a pinned entry drawing that version while another is in use; a bare tag and another type reported, an entry naming a scene the project lacks dropped with no row and listed in `dropped`; `withoutDanglingChildren` leaving out only what is dropped; each row’s list, place, occurrence and depth; another author’s folder drawn with what it holds; each viewer seeing their own version’s list, official deciding for who has said nothing, and an undecided folder flagged with its group and not followed; not in the script — an empty project, a project made before folders, folders that name each other, a scene an unfiled folder holds, an entry pinning a missing version, a folder and a scene of one short name; `childRowsOf` for a version the script does not draw; `folderOutline` reading a version the script does not draw recursively, its version in use holding nothing, a list naming the folder a cycle, `childRowsOf` of it one list deep; `cueGroupsOf` for a folder and a scene of one short name; no project file chosen — no script and nothing beside it, a handle alone not choosing; and a cue no version of which is in use shown wherever any version says; `folderIsOrHolds` — itself, beneath it at any depth, never above or beside it, through a cycle the files already hold and out of it again, a scene, an unreadable entry and a missing folder holding nothing, a pinned entry read at the version it pins; a working version (`workingOf`) giving the lists of the project file and an unpinned folder while the rows draw the versions in use, a pinned folder read at its pin beside a draft, Not in the script ordered by the same lists
`packages/filmopen_store/test/fixtures_test.dart`	the shared fixtures’ headers from the format’s parser (§5.1): a version with and without an epoch, a dotted author, an official pointer, a commentary, a render batch, a comp and an assistant session; the body overriding the header, raw text as given, the manifest as its body alone, unchanged, and an unread name with `filmopen` and its first token as its type
`packages/filmopen_store/test/pick_test.dart`	the pick model on tiny fixtures (§6.1 step 2, §13.4): the collaborator rule (§6.1 step 3) — the sole owner’s plain handle before their derived handles, `aaron.ai_v3` never over `aaron_v2`, the highest derived version where the owner has no plain one, through `pickAt` and `officialPickAt` alike, a scene’s `maria_v1` over `maria.plugin_v2`; `pick` and its 1.5 spelling, `picked_at` in the shape of `pick`; the warnings for a pick naming no file, another epoch or another entity, an unreadable time and a pointer naming another key (dropped, never official); a duplicate commentary file; the director of record — a viewer’s fork of the project file selecting it but appointing nobody, in the model and in the writer — and a folder with no file of record, where a fork (once or twice, the viewer’s or a colleague’s) is followed back to its origin, an original decides, a loop or a missing source decides nothing, and a save that removes, changes or adds a project file’s `forked_from` (a `null` included) is refused while a scene’s is not; a misnamed project pointer leaving a library pointer standing; an offset without its colon; handles, not owners, for the project file; pick, official, own; a workspace’s chain; resolution through official for official files, the project root included; and the stale predicate: a later `set_at`, equal seconds with a fraction, the next second, a lower-case `z`, offsets compared as instants, no zone, no time, the official version and the tracking value never stale, an inherited pick never stale, a pointer to a missing file superseding nothing; the assistant’s draft: a draft fork the viewer’s next version, labelled and not picked, the label validated; an ordinary fork picked with no label; a draft creation labelled with no pick beside an ordinary one picked
`packages/filmopen_format/test/document_tokens_test.dart`	the tokens a document spells in lowercase `snake_case` (Project Specification §1.4): `first_frame` and `last_frame` read back through `Deliverable.token`, every other deliverable’s token its name, and the four spellings of a platform’s `auth.kind`
`packages/filmopen_store/test/written_keys_test.dart`	what the writer puts in a file is `snake_case` (Project Specification §1.4): a fork, an official pointer and a pick written through `ProjectWriter` on an in-memory project hold no camelCase key at any depth, the three hold `forked_from`, `set_by`, `set_at` and `picked_at`, and the fork no version label
`packages/filmopen_state/test/stale_pick_tree_test.dart`	the red chain in the tree for every kind of row: the Project row, a scene with its author rows and a shot row, a library entity with its epoch, a spec entity; the author’s latest row checked and coloured for an older stale pick, with no nested history; a unit pinned by a full reference left unpainted; and nothing painted for a newer pick, equal seconds, no `picked_at`, another viewer, nobody or a workspace inheriting the pick
`packages/filmopen_state/test/plugin_tree_test.dart`	a plug-in in the tree (§8.3, §6.11): one row per tag with no version rows, no stale paint for a stale pick and no no-pick flag for two authors and nothing picked, named after the highest document rather than the pick or the pointer, while a model keeps its versions and its stale pick; `PageAccess` refusing the pick and official on a plug-in to a director and in development mode (`choosesNothing`), and keeping both on a character and a model
`packages/filmopen_browser/test/version_row_test.dart`	the version row (§9.3): the author’s tooltip saying whose version it is and where the others’ are, drawn whole by a long press at 1200 and 700 px; on a plug-in the check and the star unlit and disabled with A plug-in runs the version installed…, the settled check included and for the director; and through the page a stale pick on a plug-in asking nothing while a character’s still shows the `StalePickBanner`; on a discarded version the check and the star disabled, each saying This version is discarded; the viewer’s pick on a discarded version leaving the version in use unchecked, its check saying the pick is ignored, with nothing official and with official in use; the check’s press logged as its own op, `write.pickFromCheck`, never `write.run`
`packages/filmopen_tree/test/tree_view_test.dart`	how a row is drawn: an overtaken pick’s label and check in the error colour with the reason on hover, an ordinary pick untouched, a parent row red without a check
`packages/filmopen_tree/test/tree_drag_test.dart`	the view’s half of a drag (§8.3), on four bare rows and a `TreeDragDrop` that records: a third for each edge and the middle third for itself on a row that takes all three places; halves on a row that takes only the edges; a refusal said and nothing dropped; a row that is no place asked with no place; a row over itself asking nothing, dropping nothing and saying nothing; a row that cannot be dragged staying put and still being asked; thirds at their borders (0.3, 0.4, 0.6, 0.7 of the row); the pane asked once while the pointer moves within one place and again at another; a draggable row still saying its tooltip under the mouse’s hover
`packages/filmopen_tree/test/place_in_test.dart`	the drop’s geometry alone (§8.3), by table: a third to each edge where a row takes a drop into it and beside it, the boundaries among them (1/3 and 2/3 mean into); halves where it takes only the edges; into anywhere where it takes that alone, one edge being no edge; nothing where it takes nothing or one edge alone; a pointer past either end read as the nearer end
`packages/filmopen_tree/test/tree_row_memo_test.dart`	what a row remembers under a drag (§8.3): a rebuild that leaves the row as it was keeps the answer, although the pane hands it a fresh `TreeDragDrop` every frame; a row handed another node asks again
`packages/filmopen_tree/test/row_menu_test.dart`	a row’s menu built when it is opened (§8.3): a frame of the tree asking a row nothing about what it offers, the ⋯ asking once and the frames after it not again, a right click asking the same way, a menu that answers nothing opening nothing rather than reaching `showMenu`’s own assertion, and a row that is no place of the script wearing no ⋯
`packages/filmopen_tree/test/new_project_cloud_test.dart`	the new-project dialog’s create (§9.2) over stand-in doors: the five paths in order — FilmOpen Cloud signed in (`create`, `cloud`, recorded once), Drive signed in (`create`, `record:drive`, `drive`), local signed in (`create`, `record:local`), Drive signed out (`create`, `drive`), local signed out (`create`) — each answering the project and showing the Project page; an empty director box creating as `default`; the partial results (a local record refused, its `markerNotSaved`, FilmOpen Cloud not set up, its `markerNotSaved`, Drive not set up, an unexpected throw after the project exists) each saying The project was created on this device., the stage and its action, no Create, and Open the project landing on the Project page; a director refused, a create refused and an unexpected create failure ending the trail `refused` with the sentence said / `failed` with the error’s message; the trail’s lines in order, the start holding the director, the folder, the tag and the name, and the record the username and the location; a Drive share with no notice and no Drive in the manifest the partial result (`notShared`); a held create keeping one director for every stage, the choices taking no pick and no focus meanwhile
`packages/filmopen_tree/test/open_project_dialog_test.dart`	The open-project dialog’s four sections signed out and signed in (grouped by username, marks, locations, greyed records), a failed read with Retry, an empty list, a sign-in while open, the phone’s platform without the picker, no overflow at 700 and 375 px in both themes; a sign-in published through `accountSnapshotProvider` alone reading the records, a sign-out clearing them
`test/token_choice_field_test.dart`	one token out of a list drawn the same way wherever it is asked (§9.3): a `within` of another shape drawn locked, which neither a person nor an agent writes over; a token the project has nothing for said under the box as an error and offered as an entry of its own; the field’s helper said in both modes, under the box and under the locked value; a key holding nothing read as None, with no entry of its own; choosing the entry on show writing nothing, so that a legacy `franchise` stays until the kind is really changed; choices made one after another before the save writing the last, the one on show included; and None over a key that is there holding nothing taking it out
`test/project_subtitles_test.dart`	the project’s subtitle font and size (§9.3; Project Specification §8.5): a font’s operation logged from its start with the value as entered, a person’s and an agent’s alike; a size taken named, as its number, by the write that carries it (`0040` written 40), a size typed letter by letter logging nothing per letter, refused or taken, and a text refused logged once, as the box is left; a face chosen by a person written and logged `{old, new, outcome}`, Default removing it; an agent’s face through the same setter, one not bundled refused `not_listed`; the size a whole number above zero, `36.5`, `0`, `-3` and a word refused inline with the old kept and each reason logged, empty removing it, an agent’s typing alike; a `format.subtitles` of another shape refused by both doors (`shape`); Kind chosen by a person through its own setter as before — an ordinary kind, a legacy spelling kept until changed, None — and Aspect, with no setter of its own, as before; at 375, 532, 700 and 1200 px, light and dark, an error shown, nothing overflowing
`packages/filmopen_plugins/test/plugin_digest_test.dart`	the folder’s digest (§6.11), which is what a person’s Allow is given for: a file changed, added, removed or renamed changes the hash; a folder past either ceiling — 2,000 files or 64 MB — is not read at all and says which limit it met, so the registry drops its code and it can never be allowed on the strength of a hash that stands for no file; a folder that cannot be listed likewise, and never hashing empty; and a file whose bytes cannot be read named rather than passing for an empty one
`packages/filmopen_format/test/json_shape_test.dart`	the checker of the definition (§6.11) and of the format’s records: an unknown keyword refusing the schema by name and by where it is, a keyword of the wrong shape likewise, a `$ref` that resolves to nothing refused, an unknown keyword inside `$defs` found as the library is made, a shape that refers to itself read once and checked at any depth, an empty schema taking any value; and a wrong value by its path for `type`, `required`, `enum`, `const`, `items`, `minimum`, `maximum`, `additionalProperties` and `oneOf` — the closest shape’s problems reported, a shape the value’s own tag rules out passed over, and neither a `oneOf` inside a shape nor a tag of one shape alone ruling anything out, a value that matches two refused, and a seed of `-1`, `4294967296`, `1.5` and `"7"` each refused where `7.0` is an integer; `minItems` and `maxItems` bounding a list, a bound that is no whole number refusing the schema; `anyOf` taking overlapping shapes, and a failing value told the shape of its own type, else not a deletion’s `null`; a key not allowed carrying the keys that are, outside its text and equality; where only a `null` may stand for another key, any other value a key not allowed
`packages/filmopen_plugins/test/exposed_offer_test.dart`	an offer’s exposure (§6.11): a camelCase offer exposed under its declared kebab name with its raw `args` and `returns` kept beside the parsed shapes, `effectful`, `readOnly` and `destructive` read; a bad `expose` — wrong grammar, too long, not a string — and a second offer exposing one name `badEntry`, the offer reading unexposed; `effectful` true and the annotations false by default, a wrong type `wrongType` and defaulted; an offer with unreadable `args` loading with no raw schema; an offer without the fields reading as before
`packages/filmopen_plugins/test/tool_turn_test.dart`	the text tool-turn shapes through the definition’s `$defs` (§6.11): the five shapes saying they are for the tool-turn loop, carrying no `since`; an assistant message with a tool call, with and without text, a tool message answering its id and refused without it, a user message; a final completion with text, a tool-only one, both together, one with a null `tool_calls`, and neither refused; the options’ tools and `tool_choice`; today’s `Message` and `CompleteResult` unchanged, a tool-only answer failing `CompleteResult` and a tool message failing `Message`
`packages/filmopen_plugins/test/plugin_api_test.dart`	the definition itself (§6.11), read from the repository: its two numbers, `status` required of every plug-in and answering `Status`, every function carrying what it receives, what it answers, its state, its revision and who may call it, every interface saying what a manifest adds (an interface may have no function where a declaration is required), `ctx` with every member’s kind and state, `render`, `complete`, `transform` and `verifyKey` reachable by no plug-in, and every example valid against its own arguments; and a file this reader cannot hold a plug-in to refused whole — an unknown keyword, an example that is not valid, a function without its state, its answer or who may call it, a `$ref` to nothing, a field nobody reads, a `since` after the revision, a state the file does not define, text that is not JSON
`packages/filmopen_plugins/test/prompt_builder_test.dart`	the built, declared `prompt-builder` with no function, required string catalog and target, manifest declarations retained, and a missing target reported and the interface left out
`packages/filmopen_plugins/test/prompt_targets_test.dart`	the prompt interface’s first eleven targets, `block`, `preset` and `tokens` among `buildPrompt`’s arguments and neither `entry` nor `tokens` required; the generated types carrying `tokens` as `{ token: string; name: string }[]`
`packages/filmopen_plugins/test/parse_script_test.dart`	the planned `parse-script` interface, its one function `parseScript` planned, required, since 1, called by a person and requiring `film`, beside the planned `import`; the generated types carrying `parseScript`
`packages/filmopen_plugins/test/text_stream_test.dart`	a text call that streams: `complete`‘s optional `stream`; `ctx.partial` and `ctx.http.read` async, since 1 and built, `http.read` answering `StreamRead`; `HttpRequest.stream`, `HttpResponse.stream` and `StreamRead` naming `ctx.http.read`, `StreamRead` requiring each event’s `event` and `data` and `done`; the generated types’ callable `http` with its `read` member and `partial` in `interface Context`, neither in the planned namespace
`packages/filmopen_plugins/test/clip_target_test.dart`	prop-sheet and clip targets and valid writer manifests; clip block/blocks/context/language arguments, context entity ids required; prompt/negative answer only; character-transform and its unused shapes absent; generated clip type retained
`packages/filmopen_plugins/test/server_stacks_test.dart`	a capabilities answer without stacks, the three-argument deployServer and a status without a stack valid; optional stack members and their types checked, requiredVramGB required; wan2gp named and cold-start minutes an estimate (§6.11)
`packages/filmopen_plugins/test/contract_test.dart`	the contract at revision 1, its byte hash and generated header pinned, its `versions` saying it is the first published contract, no `Revision N` in its text and every `since` 1; `ctx.note` a built door taking one string, beside `partial`; optional writer token estimates accepted, closed keys, required counts, nonnegative integer bounds; voice keep model and source alternatives, typed reference speech; script-writer has one required workflow declaration and no functions, wrong declarations leave offers usable; Workflow closed shapes, bounds and done alternatives; completion llms and result model/provider types (§6.11); `ToolCall.argumentsError`: its text and error required strings, beside empty arguments
`packages/filmopen_plugins/test/workflow_spec_test.dart`	typed sections, steps, fields, estimate and done values, retained JSON, folder filtering and defaults; UTF-8 byte bound, JSON and shape refusals, global first-problem order for offers, duplicate ids, missing choices and reserved focus; integer-valued doubles and deliberately unresolved values (§6.11)
`packages/filmopen_plugin_host/test/workflow_file_test.dart`	enabled declared file read without executing code; exact start/terminal logs with whole text and values; invalid offers leave real offers runnable, path and enabled refusals, null for unknown/undeclared writers, invalid UTF-8 bytes and malformed JSON logged, unexpected read failures logged with stage and cause (§6.11)
`packages/filmopen_plugins/test/prompt_context_test.dart`	every prompt target accepts context; block and treatment targets accept flat composed treatment, including palette leaves; context, language and picture-selection descriptions state their rules (§6.11); token numbering from live entries in file order, offered tokens only, and model placeholder words retained; the typed optional `llm: {id, entry}` handover, `options.model` absent, `noProvider` documented and the assistant’s removed members absent; the writers: a manifest declaring `writers` loading each as declared, one declaring `targets` and `models` alone refused its prompt interface (`unknownField`, `missingField implements.prompt.writers`), a writer of another kind, an unknown target or no asset refused; `buildPrompt`’s `writer` required and the declaration entry, not its id; the prompt interface declaring `writers` alone and no `estimateCost`; `ctx.log`’s summary saying every line reaches the log whole
`packages/filmopen_plugin_host/test/plugin_file_test.dart`	interface declarations retained in summaries; listed assets read only from enabled, runnable plug-ins; path, installation and enablement refusals; unexpected read failures logged and rethrown unchanged; start and terminal events with the path as it is, the codes, a failure’s message, stage, byte count and elapsed time; silent English-backed strings with locale fallback and interpolation
`packages/filmopen_plugin_host/test/contract_test.dart`	voice keep model, preview/reference/both/neither, audio grant and source refusals; the host against the definition (§6.11): every door of `doorNames` a member of `ctx` and every member the app answers a door, no door of `ctx` planned; the assistant’s three functions dispatched, and `ctx.stage` refused `noOutputs` to a function run on its own, `ctx.upload`’s refusal of media a typed run was not granted let through as the app’s own sentence, `ctx.now` the host’s clock when the call started with `ctx.job` null and `ctx.features` naming no inline bridge, what a running call is given equal to what the definition says `ctx` carries with `ctx.api` the file’s two numbers, the host calling the functions the definition says the app or a person calls and no other, and the arguments the host builds for a render (its entry, its seed and its source), a complete, an estimate, a key check, a `transform` and the three the developer page calls each valid against that function’s own `args` (the complete’s through the app’s call; `ctx.ai.complete`’s own road is `plugin_calls_test.dart`’s); `ctx.features` an empty map, and the definition declaring no inline-output flag; streamed completion partials crossing the real JS bridge in order without clearing prior control text, a developer page’s run holding the stream’s one row on the page and in `plugins-dev.jsonl`, `stream` passed only to `complete`, and nested `ctx.ai.complete` unable to deliver partials
`packages/filmopen_plugin_host/test/exchange_doors_test.dart`	the exchange doors through real QuickJS with the `fixture-exchange` plug-in (§6.11): `scopes` answering the registry; `export` answering the bound viewer’s film with its `export_id`, `badArgs`/`scope` and `arg`, `all` carrying a file’s notes, every door `refused`/`noProject` with no film, an export above 8 MiB `refused`/`tooLarge` with the size in the log alone; a call keeping four exports by distinct id, the oldest dropped and one exported again moved to the newest, and a later call keeping none; `import` proposing — its id, its origin, its base, nothing written — a dry run answering `checked` and an unchanged synopsis `nothing`, neither held; `badArgs`/`document` and `base`, `refused`/`otherFilm` and `noViewer`; an answer above 8 MiB refused before a proposal is held; a check refused `inCheck`
`packages/filmopen_plugin_host/test/exposed_offers_test.dart`	exposed offers registered as commands (§6.11, §7.3): an enabled plug-in’s offers under the `{input, session, operation}` envelope, a non-effectful one’s `input` alone, title and description from its strings and `label` serving, an `outputSchema` only for an object `returns`; an offer without `args` and a resolved description over 4,096 characters skipped and logged with the tag, the name and the reason; disabling the plug-in withdrawing its commands and enabling it bringing them back, a plug-in removed from the library withdrawn at the reload; a tag and name over the registry’s limit refused, logged with the name, the plug-in still on and runnable; a plug-in tagged `builtin` exposing nothing and the core commands surviving its refresh
`packages/filmopen_plugin_host/test/exposed_log_sentinel_test.dart`	the exposed offers’ log (§6.11): a sentence placed in an offer’s input, in its answer and as the one property name of an answer that breaks a closed `returns`, and a second one in a tool call’s arguments within the input, logged on the call, its end and the `bad-answer` line, and the session sent logged too, an identifier, through an effectful success, a non-effectful call outside the ledger, only checked at the gate, a `bad-answer` and a `stale-session`
`packages/filmopen_plugin_host/test/run_exposed_test.dart`	running an exposed offer through the registry (§6.11, §7.3): a closed-schema effectful offer run with `{input, session, operation}` and seeing exactly `input`, an offer’s own `operation` field reaching it; a replay under one key running once; after a disable a fresh call `unknown-command` and a command held from before `not-enabled`; an authority change before the gate refused with nothing run, one after it running on under the binding made before it, its answer kept; a non-effectful offer whose caller is gone `stopped`, nothing run; two calls of one plug-in at once both run, one after the other, each logging its wait; a call waiting past the bound `busy`, its key running on a later call; a queued call whose plug-in is turned off while it waits `disabled`, its wait logged with that outcome before `done`; a `refused` outcome answering its fixed reason; an answer breaking its `returns` `bad-answer`, logged with its problems and the answer, an array wrapped as `{value}`; `ctx.caller` null; a nested `ctx.call` under the offer’s frame; a failure answering its code, its message in the log; a plug-in with a billing key exposed, run and its spend in the usage chain
`packages/filmopen_plugin_host/test/exchange_authority_test.dart`	ordinary exchange through the assistant operation and the `fixture-assist-exchange` QuickJS fixture: export retained for the operation, import proposed with its operation id, release taking both; whole and scene scopes carry notes; a failed import holds no proposal, an unchanged synopsis answers nothing, a base kept by another operation is unknown, and an uncreatable folder yields no proposal
`packages/filmopen_plugin_host/test/lending_supplier_test.dart`	the lending loop (§6.11, Lending) over a fake client and a fake render manager playing a phase list: declared, published, available, the inbox read, the job read, accepted, rendered as a remote request with the job’s prompt and seed on its frozen stack and options, not the list’s current entry, its output uploaded through a stand-in media client and the job completed with a result naming its URL, length and SHA-256, then acknowledged, every stage’s line carrying the job and its milliseconds and none the URL or the prompt; a failed render failed `render-failed`, its camel-cased code in the log alone; nothing sent with no offer in the list, signed out or unregistered; `busy` leaves the job; a bad input — `params` or another key among the keys, a seed out of bounds or not an integer, an array, a scalar, nothing — refused once and logged with its reason, another plug-in, another version, and an offer with no route now refused before acceptance; an accepted job a restart left failed `supplier-restarted` once and never run, and one a sign-out left failed on the turn after the sign-in; the remote renders a restart left stopped at start, and no other; a closing refusal ends the handling with no retry, any other after acceptance — `payload-too-large` among them — fails the job once; an upload the media store refuses fails the job once with its code logged; an unexpected failure after acceptance fails the job in one line naming its stage, and one before acceptance is logged with its stage and nothing decided; the offer removed or disabled, and an unconfirmed stop, each fail the job, withdraw the offer, then say `unavailable`, and quit fails the job and says `unavailable` leaving the offers; a sign-out stops the render and sends nothing; an offer published while publishable and withdrawn when not, the device available while any is published, a turn that changes nothing sending nothing; a changed price or option declaring a new version and publishing it; an offer that leaves the list while published withdrawn and forgotten, one never published not, the first turn sending the desired state once; one offer’s refused write logged and the others still declared and published, and a requested job of an offer not published this turn refused `not-this-offer`; the offers built from the list and the installed plug-in — the unit from the manifest, the price from the entry, no server in the declaration, the same bytes at every turn —, publishable only enabled with the plug-in on and the server running, an operation the manifest lacks no offer, each offer not publishable naming its reason — `plugin-not-runnable` on a plug-in with no code among them —, logged `lending.offer.held` once when it changes — its declaration refused included —, as is an entry not built (`not-shared`, `plugin-not-installed`); `Lending.published` set from what the website acknowledged (a refused publish absent), emptied by a turn with none published, at sign-out and by a stop after the turn under way, and told only when it changed; a lending notice with no loop running waking nothing, logged `plugins.lending.poke {running: false}`; a share on a server only running where a running server holds its stack or names none, the decision logged `lending.offer.server` once each time it changes; a job’s route logged with its frozen stack and outcome; a completion the website took reads the balance again once, as `lending`, and a refused one does not
`packages/filmopen_plugin_host/test/lent_render_test.dart`	rendering on a lent plug-in (§6.11, Lending) over a fake `Lending`: an offer of the installed plug-in, at any version, one more route after this computer’s, at its price, named by its `configuration.name` (empty where it has none), and no route for another model, an unpublished or an unavailable offer; no offers read without a plug-in sharing the model, a refusal leaving the local routes; each decision a line — the start, no sharing plug-in with the tags installed and its milliseconds, the read with its count and milliseconds, every offer not taken with its reason (`unpublished`, `unavailable`, `function`, `model`, `plugin-not-installed`, `unpriced`) — the first it fails —, the end — and the candidates’ log naming the offer as found and as shown; `options` the price with no stacks or parameters; the price summed exactly and ceiled once, free zero; one job prepared under the render’s own id at the price shown with the prompt and the seed alone (the request’s params never travel), an unconfirmed preparation still pending and `terms-conflict` failing; a published result’s output fetched from the media store by its URL — `GET`, no redirect followed, no credential — while the job settles and staged as the run’s take; a URL off the media store (another host, `http`, another path, a port, user info, not a URL) refused unfetched; a length, a digest or a type that does not match failing `mediaNotWhatItSays` with nothing staged, a type not of the model refused before the fetch; 403 and 404 `expired`, a 302 refused and not followed, another status `mediaUnavailable`; a body crossing 32 MiB under a small length header refused and read no further, an entry declaring more not fetched; a transport failure and a timeout pending, each logged; a staging failure unconfirmed and logged; a client made per collect and closed after a success and after every refusal; a download URL logged whole, its query (its token) included, refused or fetched, and a failure’s message whole; a closed job failing with its code, a job never prepared `not-found`, a result gone `expired`, else pending; cancel’s answers; a completed job reads the balance again once, as `lending`, when its handling is settled — not on a waiting or closed read, a fetch to be collected again, or an unconfirmed failure (a 500) that a later collect stages
`packages/filmopen_plugin_host/test/reference_test.dart`	the generated documents against the definition (§6.11): both naming the script that writes them and saying they are not edited by hand; the types holding every member of `ctx` with nothing planned inside `interface Context` and every planned member in its own namespace; every function of the definition in `interface Plugin` or, planned, in `PlannedPlugin` and not in both; `REFERENCE.md` listing every function with whether it is required and its state, every member of `ctx`, every state and the file’s two numbers, and what each interface adds to a manifest; the guide stating no shape the reference does not — every shape `README.md` writes outside its examples, a function’s arguments among them, being one of the definition’s objects, whole unless it says `…`, each field optional exactly where the definition says, and neither `hooks` nor `provides` named; and the repository’s own template carrying `"kind": "tool"`, two code files, an offer and a call on itself, its two locales holding the same keys
`packages/filmopen_plugin_host/test/status_test.dart`	`status`, who may call what, and a plug-in that needs a newer FilmOpen (§6.11): each of the four states answered with the plug-in’s own words, a `status` called with `ctx` alone, one whose code has none told so with its other functions still running, one that throws a failed call with its own message, an answer the contract does not hold `badResult` with its path — `state` for a state the file does not define and for none at all — a plug-in that is off running nothing and one that is not installed said so; a platform plug-in answering `run`, `request` and `status` to a caller that declares the call, every plug-in answering `status` whatever it implements, and `render`, `complete`, `transform` and `verifyKey` refused `notOffered` even when the manifest tries to offer them, as are the names the language gives every object; a call the caller did not declare `no-grant`; a `minRevision` past this build’s listed, said and unable to run, and one at this build’s running; and `capabilities.upload` known, said on the page, and an action’s upload refused as media it was not granted, in those words; a check refused `ctx.ai.complete` with the reason `status`, and a plug-in the check calls refused it too, while the same chain started by a person’s action is not; and a `status` an action reaches through `ctx.call` a check too, refused `ctx.ai.complete`, and a platform’s `run` refused inside a check and reached outside it
`packages/filmopen_plugin_host/test/admission_test.dart`	admission by revision (§6.11): a package that renders and makes voices promising nothing or 1 listed with no problem and running `render`, `speak`, `verifyKey` and `complete`, each reaching the stand-in; one promising 2 listed `needsNewerApp` and not run; at the info threshold the refusal logged `plugins.revision.refused` with its plug-in, `needs` 2, `has` 1, the decision and the code, and the two admitted `plugins.revision.admitted` with `needs` 1, `has` 1, the decision, reason, code and milliseconds; the render dialog’s route waiting for no update
`packages/filmopen_plugin_host/test/render_choice_test.dart`	the choice by model and platform, the prepared request and the answer by state (§6.11), against a recording `MockClient`: two plug-ins on fal each naming its own model reached for its own render and estimate whatever the preference says; a model only a generic plug-in serves reaching it, and one naming the model winning over the generic; two naming it told apart by the preference and, without one, `noProvider`/`choose` with the app’s sentence; no model, no entry and nothing that serves it each said; a request naming `comfyui` never reaching a plug-in on fal, and none there said with the platform; the local one taken before one that bills, two that bill `choose`; the local one failing with nothing sent to fal and no key spent; an estimate told `operation`, and one without `badArgs`; an input the entry does not list, a required one missing and a required prompt empty refused by name, and inputs with no film open `noFilm`; an answer without `state` `badResult` at `state`, `failed` with the plug-in’s code and words, `pending` `notSupported` in words, a render job’s preview never staged; the item recording the app’s model, platform, prompt, params and inputs whatever the answer says, `stack` and `seed_applied: false` from it and then no seed, and a seed of 0 applied; an error page sent as `image/png` refused `failed`/`mime` with nothing kept; and the prompt in the record its take is written with and in the log, never in the usage records, the stored key in no log line; this computer’s plug-in before the person’s preference (a preferred fal plug-in not taking Z-Image from a local one naming it, a request naming fal followed, two local ones told apart by the preference, a preference cleared asking again); a `stack` past the old 200 characters recorded whole; and `ctx.ai.complete` with no model named answered by the only text plug-in, `choose` with its own sentence where two are on and nothing says which, and the preferred one where one is; and a required list that names nothing (`reference_images: []`) refused as missing
`packages/filmopen_plugin_host/test/key_paths_test.dart`	a key goes only where its platform file allows (§6.11), against a `MockClient` that records every request that reached it, with made-up keys in a store in memory: fal’s key to `https://api.fal.ai/v1/keys` refused `path` with nothing sent — by `url` from the plug-in that owns it, from one granted it, and through a platform plug-in’s `request` called by another — while `/v1/models/pricing` is reached with the key; a `path` joined to `queue.fal.run`, which takes any, and one naming another host (`//…`, a scheme) `badArgs`/`path`; OpenRouter’s `/api/v1/key` reached and `/api/v1/keys` refused by `path` and by `url`; twelve spellings of a way out (`..`, `./..`, `%2e%2e`, `%2E.`, `%2f`, `%5c`, `//`, an empty segment, a backslash, a control character, `..;x=1`, a `%` that is no escape) and two by `path` each `bad-path` with nothing sent; a redirect to a path outside the file refused `redirect` and never sent; a provider’s OpenAI key, granted, reaching `/v1/responses` and `/v1/models` and refused `/v1/organization/admin_api_keys`; a plug-in’s own platform file without `paths` taking any path of its hosts; and the seam carrying a called plug-in’s key platforms by name — its own keys, a key it asks to use and, through its own calls, theirs, a cycle walked once and the caller’s own keys left to its first line — none for one that may spend none, a grant’s platform whether or not its owner is on, the own slots in words, and a function of the contract called by name in the app’s words; and a key sent by its own platform’s file — another plug-in’s file for the same id, read first, allowed or never allowed, deciding nothing — and a plug-in’s `Host` and `Content-Length` dropped while its own header goes; and a plug-in that is off naming the platform it brings on its page, from its own file; a `*.` host of a plug-in’s own platform file refusing an address the plug-in names itself (`host`), nothing sent, its hosts named in full reached as before
`packages/filmopen_plugins_ui/test/consent_spends_test.dart`	consent says what a call may spend (§9.4): the app’s line, indented, under a call on a plug-in owning keys, one per platform, its words further in than the call’s, and under each key the plug-in asks to use — a provider’s and another plug-in’s — and nothing under a call on a plug-in owning none; the keys named in words and never by id; the longest line wrapping at 700 and 375 px in dark under its own words and not under its mark; and the page saying the same under the call and under each grant’s checkbox, and, in light at 700 px and in dark at 375 px, under each key it may use, which of the two it still lacks — no key saved, named by its platform, else its slot, then the box not ticked, not asked for before the plug-in is allowed — and nothing more once both are there
`packages/filmopen_plugins_ui/test/plugin_status_line_test.dart`	a plug-in card’s status line (§6.11), from a runtime whose record the test writes: each state in words, its colour and its mark — Ready green, amber, red, Checking… primary, Enabled — open to check. muted — light and dark, what it measured with the app’s labels and units in the reader’s notation, a label kept with its value by a no-break space, one not measured unknown, never zero; a plain Off saying nothing, a clean-up not confirmed, failed or skipped, a hang, a plug-in that did not come on and an Off or an On whose switch was not saved, each in its own words, said as a caution without Try again — a switch not saved beside a clean-up not confirmed, neither hiding the other — Turning off… while it tidies; a plug-in on that cannot run with no line; the line a live region; the switch on from the moment its On is accepted; a switch and an Allow whose writes fail caught, nothing thrown; a failure — the plug-in’s words, `badResult` with its path, a timeout, a check’s code — in red with Try again, which asks the runtime once; no box and no address on the card; words cut at their limit drawn with an emoji at the cut and half a pair alone, nothing thrown; a long line wrapping at 700 px, light and dark, with nothing overflowing; a check started on the page and left for the list showing Checking… on the card, then the answer on the card and on the page, the card asking nothing itself; and consent’s Cancel turning nothing on
`packages/filmopen_plugins_ui/test/plugin_check_test.dart`	Check on a plug-in’s page (§6.11): the button on every page, running only on the gesture and never as the page draws; each of the four states in the app’s words with the plug-in’s own message beside it; a plug-in whose code says nothing, and a check that failed showing `badResult` with its path; Check disabled with the reason while the plug-in is off; what it implements listed with its platform and its models; the upload door said to be not in this FilmOpen yet; a plug-in that needs a newer FilmOpen naming the revision at 700 px, and one that cannot run for another reason not told so, nor that this FilmOpen is the cause; an answer, the runtime’s shared record; and About saying `archiveTooLarge` and `badCodeFile` in their sentences, never by the code, while a code with no sentence is still named with its field; FilmOpen credit under the key cards through a stand-in resolver — sign in, ready and top up each one line, nothing for not configured, unknown or the person’s own key — asked once for the slot’s platform and `http`, not again while the generation stands, and again when it moves; a sharing plug-in’s page alone saying that it is shared from the GPU page, in one line with no switch, at 700 px too
`packages/filmopen_plugins_ui/test/plugin_card_test.dart`	a plug-in’s card (§6.11): one written for an earlier FilmOpen says Update required: written for an earlier FilmOpen. with its switch still live and the update said once, never counted among its files’ problems, a problem in its files beside it counted alone, and one without that problem does not say it
`test/plugin_api_asset_test.dart`	the definition travelling with the app (§6.11): the bundled asset equal to the repository’s own file and parsing as the contract, listed beside the stock plug-ins — `fo-openai`, `fo-xai` and the template among them, each with a manifest named after it — and no plug-in folder taken from a file at the top of the bundle
`packages/filmopen_platform/test/json_asset_source_test.dart`	the staged stock bundle as a source (§6.11): a listing and a text read decoding no binary, a binary that does not decode failing only its own read; its files listed, read as text and as bytes with their lengths, a file it lacks refused, the ref and the commit it was staged from, the asset read once, read-only with no disk or media; the `binary` map’s bytes and lengths (non-empty, empty, missing), its paths listed beside the text map’s, `readText` on a binary path refused
`scripts/tests/test_stage_plugins.py`	the staging of the stock plug-ins over a temporary git repository: its two packages staged and `dev/`, `tools/` and the top-level files left out, the interface definition at the top, the record’s ref, commit and time, nothing rewritten for the same commit and files, and without a checkout no file, exit 1 and the clone line; the shared text-rule fixtures; a picture staged as base64 with its bytes kept; a text-only bundle with no `binary` map; the staging’s start, stage and terminal lines for `written`, `unchanged`, a failed fetch, an unreadable ref with git’s own text, a refused write with its path and the system’s message, and an unexpected failure with its message
`packages/filmopen_plugin_host/test/dev_run_test.dart`	the developer page’s side of the host (§6.11): the development folder’s sub-folders read as plug-ins before the library’s and before a stock plug-in of the same tag, never trusted — so a working copy asks in ordinary use where the installed one asked nothing — a sub-folder that is not a plug-in passed over in silence, the preference winning over the environment and the environment serving where it is empty, naming and clearing remembered, and a folder that is not there listing nothing; a run of a plug-in that was never allowed, which still asks in ordinary use afterwards with nothing stored, a key nobody granted sent and recorded under the hook `dev.<function>`, a code file changed between two calls giving the second call’s result with no reload, a failure carrying its code, its message and its place, and a plug-in that is not installed answering `noProvider`; the log listing the request as sent first, in the page’s list and in `plugins-dev.jsonl` alike, then every `ctx.log` line and every door in order, the request with no credential and the answer as it crossed into JavaScript, and in `plugins-dev.jsonl` the outcome whole as its last line, each line reaching the caller as it happens and not when the call ends, a refusal as its own line with its reason, a request’s address and setting as given, a server’s route whole, its query included — a whole address written as a server’s route named whole too —, the page’s rows and the file keeping a URL’s user and password in every string they write, data and a message of any length kept whole; `last-run.json` holding the call, the outcome and the log under a megabyte at the path the page shows, and `devClose` forgetting it; and what the page is told — the functions being the actions, the hooks and the offers and never `verifyKey`, the problems by file, the two paths, and nothing for a plug-in that is not installed; and the repository’s own template, copied into a development folder as its README tells a person to, reading with no problem and running its functions from the page — `status` as Check runs it, the offer, the action that reaches it through `ctx.call`, and the `transform` on a scene, shown and not written; and, §3.6, the development folder read one level deep — two plug-ins beside `docs/`, `research/`, `.git`, `node_modules` and a plug-in folder that cannot be read, both listed and run, a reader counting what it was asked showing the folder asked once, only the tops of folders named like a tag, a plug-in’s whole files only for a plug-in and nothing of `.git` or `node_modules`, the unreadable one named with its path and logged once, and one that cannot be looked into passed over and said in the log once with its path; the function list `status` first, then what it implements, its actions and its offers, with the definition’s examples; a render as FilmOpen calls it prepared — its entry, its seed — shown first as the run’s `request` line and carried on the run, with no entity its outputs only answered; with an entity, a place’s render — the request the app would make handed to the insertion to takes alone as the developer’s, run by the page’s working copy nobody allowed, its record the app’s own, the host writing nothing itself, and refused `developerPage` once the page stops waiting — and as typed sent as the box with nothing handed on; a stop from the page stopping the job it handed on; a capability as FilmOpen calls it through the app’s door — its media granted, its leaves translated — and refused without an entity, as typed its box alone; a developer’s render on a key filed `dev.render` with its working copy’s calls in the page’s log, its seed as the preparation read it; one the app could not make — no model, an empty prompt, a model the plug-in serves nowhere, a kind no place is offered — refused with nothing handed on, and one where the insertion runs nowhere refused `unavailable`; one render at a time per plug-in, and another developer’s render of the same plug-in refused `developerPage` while the page waits for its own; `last-run.json`’s `mode` and its request as sent, an action as FilmOpen calls it with `ctx` alone; an answer of the wrong shape `badResult` at its path either way; and `status` unable to reach `ctx.ai.complete`, as Check, whichever way it is called, its `message` the plug-in’s own words and never looked up as a string key or written to the app’s log; and, as FilmOpen calls it, a model the catalogue lacks, one the plug-in does not serve and a completion’s `params` that are no object refused before the plug-in runs, `last-run.json` then holding no request, while as typed the same request runs; the developer’s file holding each value as it is — a request’s prompt, an answer’s picture and a message quoting the prompt — and never the key, the request being logged before the key is added; Stop before a held accepted submission returns reaches its exact callback id once, sends no provider request, and reports the actual cancelled job or normal completion after a refused Stop; an admitted music model refused badArgs/model because no output place takes it; ordinary log events carry the host’s elapsed time, replacing the plug-in’s ms, a whole number that never goes back (stamped on arrival, so no gap between two lines is promised); the console (§9.4a): the box run with `ctx` after the plug-in’s own files — a top-level name of the plug-in’s there — its `project.export` answer the result, its lines live and in `last-run.json` (`$console`, `console`, the script), `plugins.devCalled` carrying the script and the value whole; a script that throws failing at `console.js` on the box’s own line; the page’s Stop of a waiting render logged as it is sent (`plugins.devStop`) and as it ends (`plugins.devStopDone`), accepted at info, refused or thrown a warning, a throw with its error’s type and text
`packages/filmopen_plugin_host/test/dev_run_test.dart` (the stock sweep), `packages/filmopen_plugin_host/test/assistant_install_test.dart`, `test/assistant_composition_test.dart`	a stock folder the bundle no longer has (§6.11): one an earlier FilmOpen installed is removed from the library at the next start; the assistant in the normal composition (§4, §6.11a): the runtime `main.dart` creates carries the catalog road’s text service with no switch; `installAssistantService` installs the text service and, on Windows, Android and Linux, the voice service, each `installed` in `assistant.install`, and on macOS and iOS the text service alone, the voice `skipped` for `noVoicePlatform`; the agent build’s assistant fixture skips the voice by its own reason, `agentFixture`; where no host runtime runs nothing is installed and the log says `noHost`; `main.dart` and the agent build stage nothing, make their runtime with no assistant folder — the agent build’s after the driver’s binding, on its stand-ins’ connection — and nothing names `synopsis-voice`
`packages/filmopen_plugin_dev/test/plugin_dev_page_test.dart`	the developer page itself (§9.4a), over a fake runtime: the standing sentence; a plug-in chosen filling the function pull-down, a function filling the argument box with its shape as JSON; text that is not JSON said inline with Call disabled and enabled again when it is corrected; Call passing the function and the parsed arguments and the result line showing a `PluginCallDone`’s words; a failure showing its code, its reason, its message and its `file:line:column`; the log’s rows in order each with its own identifier, growing while the call still runs and a line that arrives after it dropped, and Clear; Stop (`plugin-dev.cancel`) only while a call runs, stopping the control; a stock copy’s sentence and a plug-in’s problems by file; `set_field plugin-dev plugin\|function\|args` typing as a person does and refusing what is not there; two entries of one name drawn as one item; and the page measured at 375, 700 and 1200 px in dark — every identifier’s rect inside the dialog and none crushed, taken while a call runs, so Call and Stop are measured in their `Wrap`; and, §3.6, the two ways of calling — As FilmOpen calls it chosen by default and passed to the host, Exactly what I typed a tap away, each with its line, `set_field plugin-dev mode` taking `app`, `typed` and `console` and refusing anything else — the line that the box is not sent for `status` and an action as FilmOpen calls them, a plug-in of the development folder that cannot be read named with its path, a failure’s path in the result line, `status` named every plug-in’s and never by its code, Save what it makes to there only as FilmOpen calls it, and the page whole at 375, 700 and 1200 px in dark and in light, the mode chips and the folder’s problem measured inside the dialog; the console at 900 and 375 px — its chip by `set_field plugin-dev mode console`, the Function pull-down gone, the box JavaScript and not held to JSON, Call disabled with its reason until a script is typed, the script sent as `$console` with the entity as the selection, the answer shown
`test/plugin_dev_entries_test.dart`	where the page is reached from (§9.4a): a platform that runs no plug-in shows neither Plug-in developer page… nor Plug-ins in development, and one that does shows both; the development folder typed and entered, and emptied; the entity the page is opened on — the version a tree row names, the version in use at an epoch row, and none on an overview or on an entity as a whole; and the seam’s own doors answering for a page that is not there rather than throwing
`packages/filmopen_plugin_host/test/lifecycle_test.dart`	turning a plug-in on and off (§6.11), against fake plug-ins and a counting HTTP client: the bounds ten and five seconds with a second’s grace inside them; the app’s start and a reading again calling no hook and knowing nothing; Allow showing Checking before anything is awaited, then `onEnable` once, told `consent` and an opaque `op-` token, and what it found kept with its facts, an absent one unknown; Off then On calling `onDisable` then `onEnable` once each, told `toggle`, and the same value again nothing; Off at once — the switch off and a call refused `disabled` before the clean-up ends; an Off while `onEnable` probes stopping the probe, never showing it, and still cleaning up; Off and On at once running the clean-up first, neither dropped, the switch ending on; a switch whose write fails settling with nothing left Checking; an On and an Off within one reading tidying nothing and making no problem of it, and an Off, On, Off from on cleaning up once; an Off that cannot be written holding for the session after its clean-up, not on again at a reading, whether the store holds what it could not save or keeps nothing; a plug-in that does not declare the interface never run, and one whose code leaves the hook out neutral; a throw and two answers the definition does not hold `activationFailed` with Retry, the plug-in on; a `failed` answer keeping its token, its words and its status; Try again told `retry` and clearing the problem; an `onEnable` past its bound stopped within it, its slot given back; a call under way holding the plug-in — Off at once, the clean-up timed out within its bound and the call run to its end; all five slots taken timing `onEnable` out; a clean-up that throws or says it failed not confirmed, Off all the same, cleared by the next success; the clean-up running the code that was on, not files changed after the switch; one whose code cannot run skipped; a reading that does not publish it on — new files needing Allow, read once, or a failed reading, tried twice more — running nothing, `notPublished`, with no Try again that would do nothing; a fact dropped for good by a saved address and a saved key and its words by another language; an address saved away and back, a key saved again or removed and saved, leaving nothing known, and an answer begun before an address saved away and back never kept; an Off in flight published off by a reading begun before its write lands, an ordinary call refused and nothing of it run, its write landing changing nothing, and an On in flight held off — by a reading already under way when it came too — an ordinary call refused, and published on only by its own reading, which then runs `onEnable`; a grant given and taken back, and code changed and changed back, leaving nothing known; a setting saved as a page closes, in its `dispose`, telling no listener while the tree is locked; a hook’s address, a host and port, an IPv6 address, an IPv4 address with a last dot, an e-mail address, words, a body, a nested map, a list, a count, a price, nothing, a code and a flag written as the plug-in gave them, in both hooks and in an ordinary call, an address as an event’s name written as a `line` with its `text`, and an address as a missing string’s key as it is given; a manifest’s label with no string of its own said as it is, once over three readings; and the template plug-in’s own line as before; an answer found under an address changed meanwhile never shown; Check shared with its details, logged as the answer’s values, and an Off stopping one under way; a check that finds no `status` keeping what turning it on found; an On whose reading another switch lets go read again, coming on with `onEnable` run and no problem made of it, while an On whose reading was published, or whose switch was not saved, is read once; a plug-in’s words reaching the record capped and cleaned of control and direction marks, a detail over 200 characters left out; a failure of turning on or of a check said under one address going with that address, as a fact does, and a timeout staying; an On or an Allow that cannot be written said as a switch not saved, never `notPublished`, with no hook run, and an On or an Allow the preferences hold in memory but could not save held off for the session, the next On that is saved turning it on, while a failed write of an On or of an Off holds nothing where a later switch decides, whatever the store kept, nor one of an Allow that turned nothing on; `onEnable` making an ordinary undeclared POST with its body; a server that never answers said `activationTimedOut` three runs of three though the plug-in turns the closed request into an answer; a request open at the bound closed by the transport within the bound; lifecycle outcome logs preserving the failure’s words and address while the stored key stays out. Test-host storage reads retry only Windows sharing violations (errno 32), with five attempts, requested 5 ms pauses and a 100 ms retry allowance; exhausted retries and other read errors propagate.
`packages/filmopen_plugin_host/test/lifecycle_fixtures_test.dart`	the host fixtures of the `lifecycle` interface (`test/fixtures/lifecycle/`, §6.11), run by the host against tiny stand-ins: the ComfyUI fixture found — Ready, Found ComfyUI., its graphics card trimmed of the service’s device index and allocator, its four facts with FilmOpen’s labels and units — after the one request it declares; nothing listening, and something that is not ComfyUI, unavailable with where to look, a status and not a failure; metrics missing degraded with each fact not given unknown; a slow endpoint under the app’s own ten seconds said as no answer in time — the plug-in’s five seconds deciding, its request closed; an address changed dropping what it found and asking nothing, the next turning on asking there; and the cloud fixture’s guidance — credentials missing, then saved — without one request, its English words gone with the language and a Check saying them again in Spanish
`test_plans/060_plugins.md` §5, `test_plans/run_mcp.py --plan 060`	Template tone on the project form: after accepting On, the runner waits for the existing settled Enabled — open to check. status before opening the runtime-snapshot form, reaches the tone field below the dock and checks the original saved value on disk.
`test_plans/060_plugins.md` §10, `test_plans/run_mcp.py --plan 060`	a plug-in told when it is turned on and off, through MCP: listed, and off with no line under its switch; its address typed on its page; on through its consent, Ready — Found it. and its four facts on the card, read from the loopback’s `/system_stats`; a check left for the list replacing that with its own answer on the card and on the page; off at once, the line gone, and `plugins.lifecycle` naming `onDisable` by its codes, never an address or the plug-in’s words
`packages/filmopen_state/test/plugin_readiness_test.dart`	what is known of whether a plug-in can work (§6.11): the four facts of a status’s `details` copied by type alone, the rest left out; an absent one, one of another type, below zero or too long unknown, never zero; a fact in another language keeping its state and facts without its words; a plug-in’s own words kept as written where they are plain, cleaned of control and direction marks with runs of space made one, capped with an ellipsis at a code point so that a cut never parts a pair, half a pair alone made U+FFFD, and nothing for nothing or for what is not text; Try again offered for turning on and a check, never a clean-up or a hook that hung; and the build with no plug-ins knowing nothing and retrying nothing
`packages/filmopen_plugin_host/test/jobs_capabilities_test.dart`	jobs, options, voices, servers and the describing capabilities (§6.11), run: the definition’s job lifecycle, capabilities, voices and servers built, and `ctx.now`, `ctx.job`, `ctx.features`, `ctx.stage` and `ctx.upload` built; the capabilities’ names reserved from offers while the platforms’ `availability` is not; fixture plug-ins in QuickJS answering `options` with per-stack readiness and a quote on the call’s clock, a `pending` job under `ctx.job`, `collect` with a staged output and its usage, `cancel`, `describeReference` for a picture and a recording with its kind, `describeStyle`, `designVoice`, `saveVoice`, `speak`, and a server provider’s capabilities, offers, start and a failure as data — each answer held to the definition, and a wrong one refused by its path, in the shape its tag names: an option of no known type, an output in two forms, a provider cost with no cost, a priced quote with no cost and an unknown one with a cost, an answer without its kind, a pitch or a grain outside the vocabulary, marks that are not a list, a preview without its id, a server without its reference, a server whose state is `failed`; a null or an empty list accepted as a leaf that could not be told; a failure that names its server, its offers or its servers read as a failure alone; and `ctx.upload` taking a grant or a media reference, never both and never neither; the server provider’s seven functions built and called by the application
`packages/filmopen_plugin_host/test/server_provider_test.dart`	the server providers’ door (§6.11) on QuickJS: a provider’s capabilities and quote reaching the caller as answered, quota included, a deployment through the door with the provider’s own word kept as `providerState`, a failed server `stopped`, a stop `stopping`; a refusal keeping its code while a deployment is refused on every other road; a provider implementing the interface called as it, an answer outside the definition refused; none but an enabled server provider and its seven functions, the lab’s `x.serverProvider` mark none, each refusal logged (`plugins.server.refused`) and each answer logged with its arguments, value and time (`plugins.server.answered`); the sessions over the host, their usage’s first record a compute session’s; the providers those that declare the interface, listed with the platform it names; a server whose own state is failed stopped, never a failed call; the sessions handed no endpoint; what the sessions report reaching the log as it is, a provider’s code (`capacity / no host`) and words whole; malformed offer members and missing or non-list offers refused by the definition check’s code, no checked quote and zero deployment calls; a valid empty catalogue and valid rows, with the local counter observing one valid deployment; a provider turned on asking for its servers through `startServers`’ own subscription, a server left unconfirmed while it was off settled at its deadline, and the plug-ins’ first reading at a launch no turning-on; the sessions’ reports at their level (`serverReportLevel`): a failure or a refusal by its name or its data a warning — `servers.quoted` with a `code`, `servers.refreshed` with an `outcome` other than `listed`, `servers.notMade` — and the ordinary work, `servers.refresh` through `startServers` among it, info; `servers.runsPastLease`, `servers.leaseOverrun`, `servers.notListed`, `servers.unconfirmed` and `servers.estimateCapped` at `warning` by their name
`packages/filmopen_plugin_host/test/start_renders_isolation_test.dart`	an installed agent remains an agent before its container becomes operational; memory and private journals preserve shared product staged files, including across fresh processes, each run from whichever of the package folder and the workspace root the suite is not in, so that its `flutter test` leaves the suite’s own `libfilmopen_js.so` as it found it; Linux relaunch restores the same private journal without resubmission; launcher-owned journal prompts disappear with that isolated home; no agent render journal reads or overwrites the supplied personal folder; the manager it starts writing a Stop’s steps to the log as `render.stop`, a refusal as a warning; the manager’s events reach the log, a refusal, a failure and an entry dropped unread as warnings
`packages/filmopen_plugin_host/test/server_binding_test.dart`	a render bound to a server (§6.11, §6.15), against a `MockClient` that records every request: its endpoint alone reached for the engine’s `server` and its output, the provider’s key only where the key’s platform file lists the host, the local model service not reached, no setting changed; a server its provider does not own refused before anything is sent; a redirect off the endpoint followed nowhere; a provider turned off mid-render sending no more key; a server call and a key’s check waiting their turn where a gesture is told busy, a call stopped while it waits never running and handing its turn on; two renders on two servers at once each reaching their own, a job holding its lease while it runs; a set local model service reading as unset in a bound run and asked in a local one; where the sessions run, a stopping server, or one they do not hold, refused before its provider is asked; a key’s check giving up after its bound; a destination captured before its server had a reference resolved through its session’s own
`packages/filmopen_plugin_host/test/comfy_platform_test.dart`	a ComfyUI platform and a render plug-in that calls it (§6.11, §6.15), against a `MockClient` engine: one candidate per place a route runs — a ready server the person started first, then the person’s own, then each server starting with its engine, each queued apart, none for another engine or a server stopped; a server found at the provider not put first, and `render.candidates` logging each one’s rank and reason; two plug-ins’ routes named alike each saying whose; a route asking nothing of its own ready as its platform’s `status` says where the render would run — the person’s own ComfyUI, down, a server’s through its endpoint, none on a server stopping; a render’s platform call, its engine’s jobs and its output reaching the place bound alone, the person’s own and a server’s, never crossing; the oldest server keeping its name when another of its GPU starts, and each place offered the queue a render there goes on; the platform’s own setting unchanged by a bound render; a platform whose check comes to nothing said in the app’s words; a route asking nothing of its own judged after its platform by the plug-in’s own `status`, asked where the render would run — its default way’s weights missing on a server said there, ready at home; a route’s own ways as the amended Z-Image plug-in will answer them, each with its readiness, sizes, needs and words, the ready one suggested where the default is not, and a render submitting the graph of exactly the way and size asked for, its take keeping the way; a server made per deployment sent its provider’s key through the platform file’s `*.` host, at the endpoint resolved and nowhere else; a route on the person’s own ComfyUI whose platform plug-in is turned off saying so by that plug-in’s name; a render whose engine could not load its model failing with the plug-in’s code and stage — one graph and one question sent, nothing unloaded or sent again, no charge said on a server of this computer; a route with no `options` asked twice and logged once as absent, never as a failed call
`packages/filmopen_plugin_host/test/first_frame_test.dart`	a clip that opens on a picture (§6.11, §6.15), with a platform shaped as the pinned `fo-cui` and a clip render on a fixture entry against a `MockClient` engine: the first frame sent, as a form of the file the film holds, to the place the render was bound to — the person’s own ComfyUI and a server’s, the provider’s key to its server alone — before the graph naming the picture ComfyUI answered; the clip staged as a video; the item keeping the frame in `inputs` and `inputs_by_name` and never its grant; a descriptor a render makes up, naming another of the film’s files, refused at the upload with nothing sent; the platform’s server changed while the frame is sent moving nothing; a frame of a format the entry does not list refused before the plug-in runs, in the app’s words, and one the import measured larger than an entry names; a render with a frame while another film is open refused, with nothing of either sent and `render.call.refused` its only line; and a render shaped as the amended package — its sizes offered, its job collected after a restart and cancelled at the place it was bound to, the frame and the graph sent once; a JPEG its record calls `image/jpg` taken; and a model given a picture offered only on a plug-in that names it, while one serving its whole platform still renders a model given words alone, in whichever film is open; the first frame copied before JavaScript with bounded MIME-checked staging and a streamed SHA-256, replacement after preparation leaving upload and embedding unchanged, tampering refused as `mediaChanged` before HTTP, original multipart filename retained, pending/success/failure input copies released, oversize/wrong-type/missing files refused before execution, the queued-wait replacement limit, frozen-reference precedence for duplicate grants, a ledger exception after preparation releasing its copy, bounded real-disk streaming without an allocating read, and no journaled input grant or digest
`packages/filmopen_plugin_host/test/render_inputs_test.dart`	what a render is told, and the script a plug-in reads (§6.11): a first frame and two reference images arriving as descriptors with what the batch recorded and no bytes, one reference where a list is expected read as a list of one, nothing and an empty object `{}` and an empty list refused `badArgs`/`inputs`; a name the catalogue does not know refused `badArgs`/`inputs` with the name, with no film open too, and a known one with no film open `noFilm`; a reference that is no media, an empty one, a number and null refused with the plug-in never running; every render with no seed given one in the catalogue’s range, six renders not all the same; a caller’s seed — 7, 0, 7.0, or in `params` — being what `render` receives and what a render job’s record keeps, the top of the range and 0 among them, and `-1`, `4294967296`, `1.5`, `"7"`, `true` and two seeds that disagree each `badArgs`/`seed` with the plug-in never running; `source` naming the entity with `ctx.project.get` answering its document, and no `source` for a render for nothing; `ctx.project.script` answering the folders and scenes in order with each row’s type, tag, stem, name, kind, depth and children, an entry that names nothing carrying its problem and no stem, and a film with no script answering nothing; and `kind` and an interface’s `models` — an entry the catalogue has listed, one it lacks reported with the plug-in still running, a kind the vocabulary lacks kept as written, and a plug-in that says neither having neither; and what a render job’s record keeps of its media — `inputs_by_name` under the catalogue’s names, with what the import measured, beside §12.2’s flat `inputs[]`, written per name: a name holding media is recorded and a name given an empty array is not, so the key itself is absent when no name holds anything, and none of its maps shared with the request it was prepared from
`packages/filmopen_plugin_host/test/completion_slots_test.dart`	FIFO completion slots: at most the width running, remaining work starts in order, a throwing body frees its slot, direct handoff prevents newcomer barging, and running/waiting counters return to zero
`packages/filmopen_plugin_host/test/plugin_calls_test.dart`	plug-ins that call plug-ins (§6.11), with the real engine: a granted call running as its owner — the owner’s tag, settings and storage, never the caller’s — `ctx.caller` naming who asked by tag and stem, and null where the person started the call, and only the JSON the function answers coming back; refused — a call the manifest does not declare (`no-grant`, declared by function and not by plug-in), a missing owner (`notInstalled`), one turned off (`notEnabled`), one on and unable to run, its code gone (`cannotRun`, never told to turn on what is on) and a function that is not offered (`notOffered`, an action among them), and a name that is not `<tag>:<name>` (`badArgs`); three levels below the person’s call running and a fourth refused `depth`, a function reaching itself through another refused `cycle`, and a plug-in calling its own offer, which is the template’s example; six calls at once from one frame reaching the owner one at a time, a nested call making a call of its own not deadlocking, a caller that answers without waiting ending its whole chain with no request after it, and a key the called plug-in sends recorded against the plug-in the person ran; consent’s lines grouped by the plug-in called in that plug-in’s words, a plug-in that is not installed named and said to be missing, what a plug-in offers listed in its own words, and nothing about calls stored after Allow; and an output on another plug-in’s server downloaded where a call on that tag is declared and `no-grant` where it is not; and `ctx.ai.complete` given no conversation, a string or a message without its content refused `badArgs`/`messages` with nothing sent, and a fifth completion waiting behind four refused `notEnabled` when its provider was turned off, while `ctx.call` keeps its own turns; an ended caller’s fifth completion refused before starting, and Stop with four active and two queued ending all six with only four HTTP requests; a nested call answering `state: failed`, throwing or refused at its gate (`notInstalled`; an undeclared call’s callee and function as asked) logged `plugin.call.refused` with the callee, the function and the arguments as asked, the code and reason as they are (`out_of_memory`, and a value the plug-in chose as it chose it), the callee’s message and milliseconds, the caller’s answer unchanged; from the developer page, a writer’s and a console’s `ctx.ai.complete` — logged by neither — showing the messages as asked and the answer on the page, in `last-run.json` and in `plugins-dev.jsonl`, and a refusal’s code with the messages still shown
`packages/filmopen_plugin_host/test/plugin_calls_test.dart` (the server provider’s group)	a server provider’s `deploy` and `wake` (§9.4a): refused on the developer page in both modes in the app’s words, which name the server’s own screen (GPU → Servers → Start server), nothing sent and the page’s record saying so, its capabilities still run; refused alike to another plug-in’s `ctx.call` and to an action of its own on its Settings page, nothing sent; a plug-in whose `server-provider` declaration the reader refused gated too; and a plug-in that makes no servers keeping a `deploy` of its own
`packages/filmopen_plugin_host/test/plugin_calls_test.dart` (usage through the chain)	what a paid call says it spent (§6.7, §6.11): `started` estimated at the catalogue’s price for the call as asked; a cost with its basis, units and the receipt the call received; an answer silent on its cost recorded as a cost nobody knows with its requests, never nothing; the top-level `cost` as the platform’s; units alone at the catalogue’s price; a paid failure and an answer the definition refused keeping their cost on `failed`; a receipt never received making the cost unknown, the billing’s own receipt held alike, and a receipt counting only for the key whose response held it; a platform’s `run` answering for the key it spent where the model’s answer says nothing, a job answered twice counted once at its later answer; a request the service accepted never free — an answer the definition refused or a plug-in that threw ending with a cost nobody knows and the requests accepted, a declined request with none, a stop before the answer came ended when it comes, a timeout leaving the chain open, a request that never reached its service ending with no cost, and a status counted before a body that never came; two first requests on one key opening one chain; a `provider` cost finer than twelve digits giving way to the price; the variant a call names giving the record its row’s model id and price; and a completion made while its caller’s own request is out, each priced by its own call’s model; two in-memory text entries on one key, asked concurrently or sequentially, each charged at its own unconditional rate with summed units; duplicate receipts count once and distinct receipts both count; a receipt echoed from the second completion’s own prompt makes the cost unknown; nested-answer logs identify both entries, the key, counting decision and elapsed time
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `implements` group)	`implements`, `minRevision` and the capabilities (§6.11): an interface read with its platform and the entries it speaks for, and the functions it brings; one declared without what it must add reported and left out with the rest working; a declared value of the wrong shape reported by its path; an entry id the catalogue lacks kept and one that is no id reported; `minRevision` a whole number from 1; `capabilities.upload` known and an unknown capability still reported; what a plug-in answers to another plug-in read from the contract (`platform`’s `run` and `request`, every plug-in’s `status`) and never a render; an offer’s own `args` and `returns` read, one this checker cannot read reported with the offer still readable; the door’s own rule, `plugInsMayCall`, refusing a contract name through an offer on a manifest built by hand to carry one; an interface bringing only the functions this build can call; and the plug-ins repository’s own two manifests — `fo-cui` and `fo-cui-zimage`, written to the contract — reading with nothing reported at all, their `x` kept and their `calls` in order
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `offers`/`calls` group)	`offers` and `calls` (§6.11): an offer’s name, label, help and example; one without a label reported and left out; a name that is not a plain name and an entry that is not an object reported; an unknown field reported with the offer still read; calls kept in order with a repeat counted once, the plug-in’s own tag allowed, and eight malformed ids reported and left out; `CallId` reading, writing and comparing; and a manifest that declares neither reading as it always did
`packages/filmopen_l10n/test/labels_plugins_test.dart` (part)	a render’s own refusals and one outcome’s one sentence (§6.11, §10): the eight codes `prepareRender` and `RenderInputs` raise, each with its sentence and none of them showing its own code or a field name; `pluginOutcomeText` over every code `PluginCallFailed` can carry × seven reasons, each answering a sentence and only `cancelled` counting as no failure; a call that finished saying Done. or what it wrote; a plug-in’s own words travelling; and the two the dialog alone used — a changed file and a missing handle — said here too; and the sentences of `ctx.stage` and of the media `ctx.upload` and a request’s `embed` refuse — not granted, missing, too large, not what it is recorded as
`test/plugin_hook_test.dart` (part)	a render’s refusals on a screen (§6.11, §10): three of them laid out in the hook dialog at 700 px — the media it was given, a model that needs an input it has none of, and a prompt it has none of — each found as the sentence the ARB holds, and each measured: no wider than the dialog, and as tall as the sentence needs at that width, so nothing is clipped (a clean console is no evidence that a narrow layout fitted). The dialog is a stand-in for the typography, not the road: a render’s refusal reaches it from nowhere today, since `prepareRender` is reached only through a platform hook, and the surface that shows one now is the developer page’s result line — a render dialog is the one a person will meet it on. A step whose product is words owes a screen, and the longest of these carries a catalogue input name
`packages/filmopen_plugin_host/test/one_pipeline_test.dart`	one pipeline (§6.11), against `MockClient` with the real engine: for the same box, the request the developer page sends as FilmOpen calls it and the one `call` sends are equal key for key, the seed aside where neither was given one, and a seed that was given is kept on both roads; the page’s own record of what it sent is that request; a completion’s `messages` are held to the definition on the page as in the app; a page render on a key is recorded with the model’s entry and the kind `image`, under `dev.render`, with `started` and `succeeded`, while the app records the same call under `render`; a render the plug-in says `failed` is recorded failed, not succeeded; `verifyKey` as FilmOpen calls it is `notFound` with nothing spent and nothing sent; a model the plug-in does not serve, and one the catalogue lacks, are refused before anything runs, as the app refuses them; and the first line of a page render is the request, before any door. The page runs the plug-in whose page it is: with two plug-ins serving one model the page answers the one it was opened on, while the app, asked the same thing, refuses `choose`; and a platform hook from the page sees the `ctx.selection` the app gives it, which is none.
`packages/filmopen_plugin_host/test/run_binding_test.dart`	a run is of the film it started in, and of no other (§6.11), against `MockClient` with the real engine: each test holds a render or a transform at a door, moves the running app, and lets it finish — which film a render’s takes land in being the insertion’s captured place (§6.13), not the run’s; the same where the second film is a copy with the same stems and the same text; the viewer alone changed and the author does not; a stop while the plug-in works ending the call with nothing written; the plug-in’s `server` setting changed mid-render and the output still comes from the address it started with; a render with no film answers its outputs and saw no entities; a `transform`‘s versions and batch in the film it began in, with a source changed in that film still `stale` and nothing written over it; and being bound is not being allowed — a render job whose server’s owner is turned off while it waits is `no-grant` with nothing fetched and nothing staged, while the same render is staged where the owner stays on; a handle typed while a run waits reaches neither what it reads nor what it writes — `ctx.settings` and a batch’s recorded settings are the project file of the person who began it; a write into a film that is not on screen re-reads nothing; and a call that waited for one of the app’s five slots, all five held by other plug-ins, is given the `ctx.settings` and the `ctx.l10n` of the moment it was asked for, not of the film and language it finds when a slot frees. The fixtures report a folder, each its own, so a binding test is not also a test of the refusal. With another app viewer selected, the latest raw base index preserves the bound viewer’s project choice, with and without an explicit pick, while exposing a write made after the run began.; a render’s record naming the group of its output by the host’s table; with no film bound, `ctx.project.entities`’ start and its `no-film` decision logged with `ms`
`packages/filmopen_plugin_host/test/host_environment_test.dart`	closing a film makes the container environment’s project null and triggers the registry reload; an install asks the library re-read, closed or not; a transform’s film — for its viewer and another — holds a save landed with its publication held, and its writer carries the controller’s record; a transform invoked on the published version while a save of it has landed, its publication held, is sent the view’s version and writes, logged `plugins.transform.source` `view`, its output logged as written; a transform’s failed write logged `writer.failed` with its path, the document, message and `ms`, and `plugins.writeFailed` with the message, the returned answer and `ms`; a transform that waited behind five held slots while a save of its source landed, its publication held, is sent the view’s version in `args.entities` and `ctx.selection`, read at admission; an answer refused as `stale` is logged `plugins.outputs.refused` with the answer, the texts compared and `ms`; a new film entity hook is refused with `notAvailable`, while the installed library plug-in remains registered; the plug-ins are read once at attach (`plugins.reload.trigger` with the cause `attach`) and never again for a content save, an official pointer, a pick or another film, while a change of viewer still reads them (`settings`)
`packages/filmopen_plugin_host/test/server_grant_test.dart`	who may fetch from whose server (§6.11), against `MockClient` with the real engine, on manifests shaped like `fo-cui`’s and `fo-cui-zimage`’s: the contract’s own `run` authorizes the fetch and so does `request`; each of five custom offers is refused with `no-grant`, as is a custom-only owner without a platform implementation, with nothing fetched or staged; `status` alone is refused `no-grant` with nothing sent and nothing staged, while `status` beside `run` is allowed; no declared call, an empty list, and a call on a function the owner does not have are each refused; the owner turned off and the owner unable to run are each refused; a plug-in that is not installed at all is refused; the answering plug-in’s own `server` works with no call to declare; and `fo-cui-zimage`’s four calls pass both as written and with `files` and `nodes` taken away; a call declared on a second platform plug-in does not authorize a fetch from this one; `run` authorizes only where the owner implements `platform`; a function of `platform` that is still `planned` does not authorize it, which is the tripwire for the day `collect` is built; and a refusal says so in the log with the tag, the cause, the setting and the path whole, its query included; a failed download from a server logged with the client’s message whole, its query included, and one from an address of the plug-in’s own with the message’s URL whole, its user and password included; a render’s server holding a user and password — a settings file edited by hand to hold one — refused as a setting and the default resolved.
packages/filmopen_plugin_host/test/receipt_binding_test.dart	A key replaced while a render is pending: the collect sends with the key stored now, the accepted job is not submitted again and no request carries the record id. A thrown provider error is never retried as transport. An explicit server receipt ignores the renderer’s local server setting. A running server whose provider declares no key stays ready without credential reads, provider calls or Usage.
`packages/filmopen_plugin_host/test/receipt_storage_test.dart`	the real stock `fo-fal` across the host’s boundary: an HTTP 400 or 403 with a `detail` keeps its words in the render’s facts and retires its receipt, a 402 keeps its receipt; ordinary host storage doors refuse malformed or non-object JSON, unavailable data folders, failed temporary writes and rename failures with `refused/store`, preserving prior bytes and sending no POST; a readable missing store remains healthy, written receipts read back, and parallel or nested writes preserve independent keys; the actual render manager journals output and the settlement’s confirmed provider end while the nested platform plug-in’s receipt still exists, and a rejected prepared journal deletes nothing; refused retirement writes and a crash after deletion before its applied marker recover from saved intent without another collection or submission, with one effective Usage end; restart collects the original accepted id without resubmission, with one paid Usage start and end; a lost accepted submission answer restores interrupted with one open Usage start, its dispatch fence unchanged, no collection and no resubmission; uncertain collection codes and Dismiss retain dispatch fences without a terminal Usage record or cancellation request; affirmative failure and confirmed Stop remove their job’s receipt, and repeated healthy churn keeps storage bounded while unrelated job and setting values remain unchanged; local and paid collection HTTP400/503 retain the exact fence and unsettled Usage, Dismiss preserves it, and Retry collects once without resubmission before the receipt is removed; a definite initial 400 removes its receipt after a durable failed settlement with one paid Usage end; a receipt set to null inside or outside the job’s calls, or rewritten inside them, is removed at settlement, and a completed unmanaged call leaves no confirmed end for a later managed call with the same id; interception fixtures use native file separators and normalized comparisons; repeated unreadable reads diagnose the plug-in, file and error once; every synchronous paid http-error503/key-refused/insufficient-credit/bad-response/submission-uncertain failure retains its provider cost and safe reason; uncertain paid collection survives a stale-journal restart and Retry, keeping both raw billing lines while distinct receipts total once and same-receipt correction replaces its prior total without a new submission; an unknown cancel keeps its receipt and open Usage through a generic Retry error and restart, and only confirmed late output confirms the end and supplies one effective Usage end across another restart; a confirmed end’s receipt removal is logged with its plug-ins, the job, the reason and its time; a Stop refused because the plug-in is off stays unconfirmed, and its log gives the refusal’s code, reason and message, the receipt’s provider job and the time
`packages/filmopen_plugin_host/test/sync_answer_test.dart`	a synchronous render’s answer after a 2xx on the person’s key (§6.11), from stand-ins shaped as an OpenAI platform and its model: an output the definition refuses after the picture was staged keeps `reachedService` and the staged handle in the call, and through the backend is a charged failure with no receipt whose handle is let go, sent once; the provider’s error in the body keeps `reachedService` and its failed Usage line of unknown cost; a managed job’s refused answer keeps its ledger’s chains for the job’s end, prepared as a charged failure; a failure thrown after the plug-in answered (the Usage log refusing its cost) is a `failed` call keeping `reachedService` and its staged handle, and through the backend a charged failure whose handle is let go. The release of a failure thrown before any answer is `first_frame_test.dart`’s
`packages/filmopen_plugin_host/test/provider_end_test.dart`	recognized initial HTTP rejection statuses are definite only during submission; collection HTTP errors and initial gateway/overload failures confirm no end; understood success/execution failure and explicit cancellation retain their phase-specific rules; a provider’s content filter (`safety_filtered`) is a definite end, an unknown code is not
packages/filmopen_plugin_host/test/settlement_restart_test.dart	The actual host, render journal and insertion consumer under cuts before the terminal journal, before and after Usage append, and after the batch write: no resubmission and one terminal Usage effect and batch. Stop remains incomplete while the paid answer is held, with no terminal journal write or terminal Usage record before that answer is released. A restored settlement logs the payload it replays and each Usage id with its amount, chain and decision — appended after a cut before the append, skipped after one after it — and a saved line that differs from the logged one skipped with both lines.
`packages/filmopen_plugin_host/test/agent_render_folder_test.dart`	deterministic Linux and Windows folder selection under synthetic roots: an explicit private root wins over the platform fallback, two private roots keep journals apart, relaunch finds the same journal, no ordinary jobs directory is used, legacy fallback remains available, and missing explicit and platform roots refuse startup
packages/filmopen_plugin_host/test/render_grant_lifetime_test.dart	Fresh input grants per render and staged handles per collect; expired grants and stale handles refuse without granting another call’s bytes; an actual output-ready journal restores into a fresh host and manager, its held staged reference survives the sweep while an orphan is removed, and the reopened output serves its original bytes while a previous collect handle remains refused; attachment is verified by the insertion’s tests.
packages/filmopen_render/test/attention_settlement_test.dart	Held stopUnconfirmed and collectionUnconfirmed actions, restart and Dismiss, terminal journal publication barriers, and idempotent settlement replay across cuts.
`packages/filmopen_plugin_host/test/render_backend_test.dart` (program routes)	A declared configured Codex route coexists with the key route, follows consent and enabled state, excludes non-text-to-image and required-media entries and undeclared programs, and has a distinct capacity-one resource despite a platform capacity of four. Options and render receive plan funding, the quote is unknown, and token-only Usage opens before dispatch and settles the returned account label and tokens without HTTP, a key or credit operations. Candidate and funding decisions are logged.
`packages/filmopen_plugin_host/test/render_backend_test.dart` (a plan sign-in)	a signed-in `oauth` slot listed first never funds a picture: the route sends on the `key` slot after it; an `oauth` slot alone offers no picture route, its decision logged `planOnly`.
`packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_dialog_test.dart` (program routes)	A key route and a Codex program route for the same model each survive Settings → Models, preparation, options, submission and reopening from the last render options. The dialog says through Codex while options are pending and after they answer, without claiming an account. Route and caption decisions are logged with the program.
`packages/filmopen_plugin_host/test/render_backend_test.dart`	render jobs through the host (§6.11, §6.15): a job run through the plug-in its route names, told its job and key, its output fetched and staged, opened with its provenance — the run and the record of what it was asked, no grant in it — and let go; work its service holds kept by its receipt and collected, the job’s usage one chain across both calls; `cancel` answering the plug-in’s state, a failure keeping the plug-in’s code and a plug-in not on the app’s reason; a stop ending the call in flight as cancelled and letting go of what it staged; `options` answering a plug-in’s stacks, readiness and quote and one without `options` a single ready way; the candidates, the person’s computer first, with readiness, and a resource named by no key id; the manager over the host rendering, handing its outputs over and letting them go once taken in; `options` that fail, or of a plug-in that is off, not ready, with why; a stop in the middle of a collect keeping the job’s usage one chain through its cancel and last collect; a job whose plug-in went away ending there with its usage; a platform plug-in’s declared capacity its queue’s, read only from the one that serves the route; a journal file that is not UTF-8, or not JSON, set aside and never written over; a render its service held collected after a restart by a backend that never saw it — its receipt read back from the manager’s journal — recorded exactly as without the restart, with the seed the application sent (the caller’s, or a new one) and never one an output names, and a seed not applied out of `params` with `seed_applied: false`; an output read back from its job’s journal taken in with the provenance it was staged with; candidates saying why a route is not ready — never allowed, turned off, no key saved as Provider keys records it, another plug-in’s key not granted — and ready once granted; `options` giving a plug-in’s words in the person’s language and the catalogue’s estimate where a route that bills names no price, none on the person’s computer; a model plug-in holding no key sending on the key of the platform plug-in it calls, no grant asked — not ready without that key, naming whose it is, ready with it, and, that plug-in turned off or never allowed, not ready naming it, its own state first; a build keeping its key records elsewhere answering alone, its record a key saved and the preferences’ none; `options` answered in an older shape translated by nothing, no choice read from it; a paid success whose output the model plug-in’s own check then refused keeping its charge in the job’s usage; a route through a platform plug-in that uses a provider’s OpenAI key — no key saved said before the grant, naming the provider, saved and not allowed naming that plug-in, allowed and ready on `fo-openai:openai`, revoked, turned off, and its capacity and health found through it — and a route calling `run` on a plug-in that is not installed naming it by its tag, while one calling a helper that is not installed is not said to run through it; the treatment a request froze in the record its takes are made with, and none where none applied; a stop while a render’s outputs are fetched ending the download in flight, fetching nothing more and letting go of what it staged — a download that lands afterwards included — the render then `cancelled`; a pending answer after a submission its service took carrying the possible charge; a stop landing as the first of two outputs arrives asking for nothing more; a stop that cut a finished render’s downloads answered `cancelled` at the stage `downloading`; a job asked about again after a restart continuing its usage chain — its receipt keeping the chain, never in the plug-in’s own receipt — one `started` and one end; after a restart, a chain priced as the job was sent — units at the catalogue’s price, under a receipt seen only before the restart — and a collect that fails before it sends anything still said to have reached the service, its end a cost nobody knows; a render’s use naming the version it was of and the group its takes go to; a failed render’s request logged as handed (`render.call`), its answer as it came (`render.call.answer`) and the outcome the backend read (`render.answer`), on the job’s id; a cancel logs the receipt’s fields it read and those it left unread, and the state it decided with its reason and time
`packages/filmopen_plugin_host/test/render_backend_test.dart`	render jobs through the host (§6.11, §6.15): a job run through the plug-in its route names, told its job and key, its output fetched and staged, opened with its provenance — the run and the record of what it was asked, no grant in it — and let go; work its service holds kept by its receipt and collected, the job’s usage one chain across both calls; `cancel` answering the plug-in’s state, a failure keeping the plug-in’s code and a plug-in not on the app’s reason; a stop ending the call in flight as cancelled and letting go of what it staged; `options` answering a plug-in’s stacks, readiness and quote and one without `options` a single ready way; the candidates, the person’s computer first, with readiness, and a resource named by no key id; the manager over the host rendering, handing its outputs over and letting them go once taken in; `options` that fail, or of a plug-in that is off, not ready, with why; a stop in the middle of a collect keeping the job’s usage one chain through its cancel and last collect; a job whose plug-in went away ending there with its usage; a platform plug-in’s declared capacity its queue’s, read only from the one that serves the route; a journal file that is not UTF-8, or not JSON, set aside and never written over; a render its service held collected after a restart by a backend that never saw it — its receipt read back from the manager’s journal — recorded exactly as without the restart, with the seed the application sent (the caller’s, or a new one) and never one an output names, and a seed not applied out of `params` with `seed_applied: false`; an output read back from its job’s journal taken in with the provenance it was staged with; candidates saying why a route is not ready — never allowed, turned off, no key saved as Provider keys records it, another plug-in’s key not granted — and ready once granted; `options` giving a plug-in’s words in the person’s language and the catalogue’s estimate where a route that bills names no price, none on the person’s computer; a model plug-in holding no key sending on the key of the platform plug-in it calls, no grant asked — not ready without that key, naming whose it is, ready with it, and, that plug-in turned off or never allowed, not ready naming it, its own state first; a build keeping its key records elsewhere answering alone, its record a key saved and the preferences’ none; `options` answered in an older shape not translated, no choice read from it; a plug-in’s `options` answer taken as it is, with its choices and the table’s price for exactly what was asked; a paid success whose output the model plug-in’s own check then refused keeping its charge in the job’s usage; a route through a platform plug-in that uses a provider’s OpenAI key — no key saved said before the grant, naming the provider, saved and not allowed naming that plug-in, allowed and ready on `fo-openai:openai`, revoked, turned off, and its capacity and health found through it — and a route calling `run` on a plug-in that is not installed naming it by its tag, while one calling a helper that is not installed is not said to run through it; the treatment a request froze in the record its takes are made with, and none where none applied; a stop while a render’s outputs are fetched ending the download in flight, fetching nothing more and letting go of what it staged — a download that lands afterwards included — the render then `cancelled`; a pending answer after a submission its service took carrying the possible charge; a stop landing as the first of two outputs arrives asking for nothing more; a stop that cut a finished render’s downloads answered `cancelled` at the stage `downloading`; a job asked about again after a restart continuing its usage chain — its receipt keeping the chain, never in the plug-in’s own receipt — one `started` and one end; after a restart, a chain priced as the job was sent — units at the catalogue’s price, under a receipt seen only before the restart — and a collect that fails before it sends anything still said to have reached the service, its end a cost nobody knows; a render’s use naming the version it was of and the group its takes go to
`packages/filmopen_plugin_host/test/render_backend_test.dart` (the record’s request)	the record’s `request` members through the carrier — its stage, the stems read beside the primary, its purpose and the take it continued, the server it was sent to as the request names it and none for this computer — the primary left out of `sources` (Project Specification §12.2)
`packages/filmopen_plugin_host/test/render_backend_test.dart` (a block’s place)	a render asked at a `BlockPlace` names the block’s group (`clips`) as its use’s `field`, as a slot’s names its group (§6.7)
`packages/filmopen_plugin_host/test/render_backend_test.dart` (what the plug-in said)	the shared container and each output’s kept whole under `item.metadata` and `output.metadata`, a value shaped like a key included and no `metadata_refused` written, the facts per output under `output.reported` with the duration alone respelled, the preview counted in `n`, `item` the same on every take, the submitted seed apart from the reported one; a plug-in that said nothing recording no container; each output fetched on its own — a failed second download leaving the first taken in and `delivered` saying which, a handle not staged and bytes not of their type that output’s alone, none fetched the render failed with the first one’s reason, an address that is not `https` and a shape the list does not hold the call’s with what it fetched let go (§6.11, §6.15)
`packages/filmopen_plugin_host/test/render_backend_test.dart` (the keeper’s points)	the keeper awaited at prepared, from the frozen request with no plug-in stem, at answered with no `delivered` and before any download, once per output handled with the whole map and `staged:` where fetched, never on a pending answer; a keep that throws at prepared sending nothing (`journal`, not charged), at answered fetching nothing (`journal`, charged, not confirmed), at the second handled output fetching nothing more; a job refused before preparation keeping every member its request holds; a failed answer’s words cut to 500 into `RenderFailed.message`, a value shaped like a key kept, none where it has none, its container and `error` kept; `stage` and `from` reaching a render as asked, never fetched from; an answered cancel’s container kept whole (§6.15, §6.11)
`packages/filmopen_plugin_host/test/voice_render_test.dart` (stage, from, the shared container)	`designVoice` and `speak` told `stage` and `from` whole, their shared container in each take’s record as a render’s, each output’s own as before, nothing fetched from `from` (§6.11)
`packages/filmopen_plugin_host/test/container_capture_test.dart`	a container kept whole, nested values, unknown members and a safe address included; absent allowed; `null`, a string, a list and a container without an integer `v` refused at its path; a value shaped like a key kept as given; a failure’s words cut to 500 characters, a value shaped like a key in them kept (§6.11)
`packages/filmopen_plugin_host/test/render_backend_test.dart` (FilmOpen credit)	a billing route with no key saved ready where the resolver answers `CreditFunding`, two plug-ins on the platform asking it once, its options the plug-in’s own with its quote; signed out or not configured, no key saved in the candidates and the options; a saved key asking nothing (§6.6)
`packages/filmopen_plugin_host/test/render_backend_test.dart` (the render container’s shapes), `host_runtime_test.dart` (readiness)	a container without an integer `v` refused by the definition at `metadata.v` and at an output’s, an absent one accepted; options without `params` `badResult` at `params`; `ctx.keys()` saying `usable` and `mode: own` with no `reason` for a key stored and allowed, `grantDenied` for one stored and not allowed, `needsKey` for one not stored (§6.11)
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `sharing` group)	`sharing` absent, empty and compliant read with no issue; a wrong shape — not an object, `operations` not a list, an operation not an object, a function, model or unit out of its words, `scale` without `character` — one `wrongType` at its path and no list (§6.11)
`packages/filmopen_plugin_host/test/terminal_disposition_test.dart`	original failure reasons survive manager preparation and failed downloads override success; stale managed histories reconstruct distinct, same and cited-to-uncited receipts with strictly increasing serialized timestamps; an incomplete reading refuses the restoration before a send; append-then-throw preserves one raw line and logs the error, its stage and the re-read’s decision, and one followed by an incomplete re-read is refused with the append’s error logged, repeat preparation preserves exact effects, a contained receipt id cannot erase a distinct raw record, and legacy/ordinary calls keep their existing semantics; same-receipt raw answers retain a distinct stable final witness; prepared outputReady effects replay through the real host at before-append and applied-then-thrown cuts without provider calls or duplicate lines; a saved entry that cannot be read is passed over while the others resume, and a valid older snapshot never replaces live request state; a settlement appends only the lines whose ids the log lacks, a differing line under a held id skipped and never refused
`packages/filmopen_plugin_host/test/gpt_image_render_test.dart`	GPT Image rendered on OpenAI as its adapters do it (§6.11, §6.15), a model plug-in reaching OpenAI through a platform plug-in borrowing a provider’s key, against a stand-in that records each request: the picture answered inline staged and opened with its record — no seed it did not apply, `seed_applied: false` — and its cost the tokens’ at the price with OpenAI’s request id, started at the quote it was asked at; a cost of nothing kept as nothing; a paid answer whose picture is no picture, a picture cut on a boundary of four, or base64 cut short, refused with its charge kept; a stop while the request is out cancelled, one request sent; its second route, on fal through a platform plug-in with a key of its own, beside it — both ready; fal alone with OpenAI’s plug-in off, a render there reaching fal alone and one on OpenAI refused with nothing sent; OpenAI alone with fal’s key and its record gone, a render there made and one on fal refused before anything is sent; neither with both — a render on fal whose paid answer its plug-in refuses ending there, its request counted as of a cost nobody knows, OpenAI never asked; and a render whose plug-in is turned off after it was asked refused, no other route chosen for it; a paid answer the host refuses, and one on fal the plug-in refuses, failing as possibly charged, and a render refused before anything was sent (no key) as not
`packages/filmopen_plugin_host/test/voice_render_test.dart`	declared reference uses exact platform/id sample and own text, archived live/deleted refused, other film no grant; requested-film language only, omitted with otherFilm logged when another film is open, and byte-identical ElevenLabs provider request; keeps carry model; recording A/B/A reuse, model/film separation and selected clone price or unknown; voices through the host (§6.11), against a stand-in ElevenLabs, by a plug-in that implements `voice`: offered for a voice design and a line on its platform and for no picture, designing by `designVoice` with its seed and speaking by `speak`, each output keeping its binding; a design that made no preview a bad result with its usage recorded, sent once; an ElevenLabs-shaped paid failure retains reported provider cost, characters and credits before voice-result translation; the seed applied read from the answer’s `metadata` flag where it is a boolean — true and false, for a design and a line — and the function’s default where it is absent or not a boolean, the take’s seed following and `voice.seed` saying which; fo-fal-tts’s design answer, one MiniMax preview, one output bound to its generated id on fal
`packages/filmopen_plugin_host/test/voice_analysis_test.dart`	a recording described through `reference-analysis` by an analyser that hands a platform plug-in the recording’s granted descriptor, which submits it to fal’s queue, polls it and reads it, against a stand-in fal: the recording written by `embed` in the submission on the platform’s key, a descriptor and its grant, never the recording, in JavaScript; the voice back with its kind; its cost unknown and never nothing where the billing is not the key’s to read, and fal’s own billing its cost where it is; a WAV taken as a WAV; words that are no JSON ending the call as failed with the plug-in’s code, what it used and fal’s request kept, never sent again; Spanish words back as they are with the tokens as the vocabulary has them; a recording of another type the analyser’s to refuse, one over the HTTP door’s 16 MiB or not there refused at the door with its code logged, and one asked as a picture refused before anything runs; the analyser listed by the interface it declares; a package of the plug-in lab’s first contract, loaded and on, listed with no interface and no hook, its description `notFound` and nothing of it run
`packages/filmopen_plugin_host/test/output_check_test.dart`	what a file’s first bytes say it is (§6.11): the common pictures by their signatures and markup or JSON as text; a PNG, a JPEG, a GIF or a WebP never taken on bytes that say nothing, or cut short, or an error page; a type with no signature taken on them; a picture no sound; SVG unread; a type that is no media never a take; a PNG, a GIF or a WebP whole only where it ends as one does — its `IEND` chunk, its trailer, the length its header gives — a JPEG’s end not read
`packages/filmopen_plugin_host/test/openrouter_text_test.dart`	a text platform that owns its key, as `fo-openrouter` does (§6.11), against a stand-in OpenRouter that records every request: its key checked by its platform’s file and never by the plug-in, its check one read of the key’s record on the key’s own platform, the key on the wire and neither it nor its last four characters in anything the plug-in sees, the check recorded as no use, since a status on the person’s own key is free; alone on the platform, chosen for the model asked for, the request carrying the entry’s model id, the call’s `max_tokens`, a zero `temperature` and `top_p`, no stream, and the key in its header alone; beside a second text plug-in on the platform, the person asked to choose in the app’s words with nothing sent, then the preference settling it on the preferred plug-in’s own key; the tokens and the platform’s reported cost recorded as it reported them, a zero as known to be free, and none as a cost nobody knows with its units, since the catalogue prices each text model on OpenRouter several ways; a malformed answer, a refused key and no credit each ending the call in the plug-in’s own words after one request, the first a cost nobody knows and the others none; its key removed, its check asking for it and a completion refused before anything is sent, nothing recorded — the pinned plug-in’s words for it being those of an outcome unknown; a key its platform refuses, the check saying so in the plug-in’s words after one read; an answer lost after the request went said to be of unknown outcome, sent once, its use left pending at its estimate; a key its record names but the store no longer holds refused `no-key` at admission before anything is sent, never an outcome unknown; a lost answer’s refusal logged at the stage `transport`
`packages/filmopen_plugin_host/test/openai_transport_test.dart`	a platform plug-in borrowing a provider’s OpenAI key (§6.11), against a stand-in that records every request: its page told whether that key is saved, as Provider keys records it, and, in a build keeping its records elsewhere, as that build says; its read-only status sending the key on the wire and nothing the plug-in sees holding it or its last four characters; a key saved and not allowed, or allowed and revoked, and one allowed and not saved, refused before anything is sent; a refusal and a lost answer coming back to the model plug-in as the platform plug-in gave them, each after one request; the platform plug-in turned off, not called; a grant, and its withdrawal, in force for the next call at once, before the plug-ins are read again
`packages/filmopen_plugin_host/test/media_back_test.dart`	the film’s media coming back (§6.11): `ctx.stage` keeping a service’s inline picture behind a handle and answering it, an output naming the handle staged for the insertion with those very bytes, the staged copy let go once released; bytes not of their type refused in the app’s words, bad base64, a type that is no media and a role not named `badArgs`; a handle staged by an earlier render refused `handle`, nothing staged; what a call staged let go when it fails; an output whose bytes are not what it says refused `mime` in the app’s words with nothing staged; a picture, a sound or a clip given as a `data:` address a wrong answer, `badResult`, nothing staged; an output whose address is not `https` — `http`, `data:` or another scheme — `badResult` at `outputs[i].url`, asked of `stageOutputs` itself; a handle staged by a platform plug-in the render called being the render’s to answer; a handle answered as another type refused `mime`; what a call staged let go when it is stopped and when a render has no film to take its outputs in; a `status` staging nothing and a clip refused `badArgs`; what an earlier session left and no render keeps swept, and this session’s own staging spared; inline media over the limit refused before it is decoded and after; a download’s stream staged whole by `putStream`, with no cap of the app’s on its length
`packages/filmopen_plugin_host/test/media_out_test.dart`	the film’s media going out (§6.11): a render’s inputs each carrying a grant, and `ctx.upload` sending the granted file to the plug-in’s server as one multipart form — its parts, its name and type, its bytes as they are in the media folder — by its grant or by its media as fo-cui sends it; the grant travelling with `ctx.call` to the platform plug-in that sends it; media not granted refused in the app’s words, both forms or neither `badArgs`, a file missing, not what it is recorded as, or over 16 MB refused, a plug-in without `capabilities.upload` refused, an upload naming neither a key nor a server `badArgs`, a grant kept from an earlier render refused, nothing sent in each case; an answer handing the file back handed on as it came; an estimate granted nothing and able to send nothing; a `status`, a key check and a call whose caller has ended sending nothing; an upload on a key going to its platform with the credential as a request of its usage chain; a request’s `embed` placing the granted file as a data URL or base64 and an echo coming back as it came, and nothing embedded by a plug-in without `capabilities.upload`; a pointer with no place, a grant not given and more than 16 MB in all refused, nothing sent; a request’s embed on FilmOpen credit: a data URL piece uploaded through the media client and its download URL at the pointer, sent to the pass-through with no `data:` in the body, an echo of the URL or of the file’s base64 handed on, and on a key an echo of the file’s base64, or on credit of the URL, in the answer and in `plugins.http.done` as it came; `plugins.http.start` holding the plug-in’s own `embed` body on either road, no base64, download URL or `<media>` in it; a base64 piece inline and nothing uploaded; on a key the data URL as before and nothing uploaded; the media client’s refusal `media:<code>` and nothing sent; an unexpected upload failure logged with its stage and type and nothing sent; a bad pointer, more than 16 MB in all, a key beside a server and a key not granted each refused with no upload and no send; a grant not given logged by its code from the placement’s first line, the grant never; a small piece to upload beside 13 MiB inline as base64 refused `body-too-large` before anything is uploaded, the measured body beside the bound in the log; the `plugin.media.*` lines with one placing id, the operation joined at `sent`, and no download URL in the log; a key the store no longer holds is refused `no-key` at `admission` before anything is uploaded or sent
`packages/filmopen_plugin_host/test/server_door_test.dart`	`ctx.http({ server, path })` and a render’s output on a server (§6.11), against `MockClient` with the real engine — a held value that does not parse refused `no-server` at the door and in an output alike, with nothing sent, the plug-in’s own tag allowed to qualify the name in both places, the download of a server’s output told not to follow a redirect (asserted on the request, since a handler-backed client never follows one) while an https output is fetched as it always was, and an address whose last part cannot be read named by its type rather than thrown: the stored address used with its base path joined, the manifest’s default where nothing is stored, no credential in a plug-in that owns a key and no usage record, an `Authorization` header the plug-in set itself sent, every method and a body and a query as written; refused — a name that is no `server` setting, `key` or `url` beside it, no `path` and five paths `resolve` refuses, nothing stored and a stored value that does not parse, and a redirect to another port, host or scheme while one within the address is followed; a `server` value in a project file never read; an `http` `url` at the door still `insecure` and a `capabilities.network` host still `https`, while a render’s output at an `http` address is `badResult`; a request carrying an `embed` to a server refused `badArgs` with nothing sent; and a render job’s outputs — `{ server, path }` downloaded without credentials and staged, the qualified form of the plug-in’s own tag, another tag `no-grant`, both forms in one output `shape`, a `handle` the call never staged refused `handle` and never taken for an address, with nothing fetched, and a name that is no setting, no address stored and a path that cannot resolve
`packages/filmopen_plugins_ui/test/server_box_test.dart`	the address box and consent’s line (§9.4): an address saved normalised once the typing settles, text that is no address said inline and saving nothing with a later address still saving, emptying the box removing the value, a public `http` address warned in the tertiary colour and saved all the same, a private address and a host name and `https` not warned, the plug-in’s own help winning over the app’s, an agent’s `set_field` following a person’s rule and refusing what is not an address, the box whole in dark at 375, 700 and 1200 px, and consent naming the setting in the plug-in’s words with and without its default
`packages/filmopen_format/test/project_key_test.dart`	which film this is (§5.15): two folders holding the same film have two keys and one folder read twice has one; one folder spelled five ways — a trailing separator, forward slashes, mixed slashes, doubled slashes, leading and trailing spaces — is one key, while case is kept whatever the path looks like, a false join costing more than a false split; a root path that names no folder is a session of its own; a Windows share’s root keeps its two leading separators; a root is itself (`/`, `C:\`, `E:`); two projects in memory are two films however alike their files, and one keeps its key through a write and every re-read; a session copy over a base is a film of its own and not the base it reads through, which is the shape the bundled sample’s is (the real one is `filmopen_platform`’s, which the format may not reach); and a `FilmProject` is keyed by the source it was read from, every load of one film answering one key
`packages/filmopen_format/test/server_address_test.dart`	the address of a server a user runs or chooses (§5.14): this computer, a name, a base path and IPv6 read; the scheme and host lower-cased, a trailing slash and the scheme’s own port dropped, the text trimmed; a dot segment already removed by `Uri.parse` and unable to climb above the root; refused — another scheme, no scheme, user info, a query, a fragment, an empty host, a port of 0 or 70000, a `//` path, nothing at all; `isThisComputer` and `isPrivate` over every range of §5.14, a host name private and a public address neither; `resolve` joining with and without a leading slash, a base path first, a query kept and a fragment dropped, and null for an address, a `//` start, `.`, `..` and an empty segment; `sameOrigin` over scheme, host and port with a scheme’s own port counting as none; two spellings of one server being one value; a percent-escape escaped exactly once — a base path of `/My%20Comfy` sent as itself and not as `/My%2520Comfy`, a route’s escapes read back, a literal space or accent escaped once, a segment mixing the two surviving whole, a character above the basic plane among them, `%2F` kept inside one segment, `%2e%2e` refused as `..` is, and an escape that is not two hexadecimal digits refused — a sign or a space among them, so `100% final.png` is a refusal and never a different route — while `Uri.parse` rewrites `%zz` and `%2` in a base path to a literal per cent sign; an escaped dot segment (`..%2F..`) refused while `a%2Fb` passes, a control character refused so a server that truncates at NUL cannot be fooled, and an escape whose bytes are not UTF-8 answering null rather than throwing, since a person types into the box and a manifest ships a default; an IPv4-mapped IPv6 address read as the IPv4 address it names and a rooting dot not part of a name
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `server` group)	the `server` setting (§6.11): machine-scoped with no scope and with `scope: machine`; `scope: project` reported and machine-scoped anyway; under `entitySettings` reported and left out; a default that is this computer kept and normalised, one elsewhere reported (`badHost`) and dropped, one that is no address `wrongType`; `accepts` taking what `ServerAddress` reads and nothing else; the label and help locale keys
`packages/filmopen_js/test/files_test.dart`	a call of several files and where an error is: three files loaded in order into one scope with a `const`, a `let` and a `class` of an earlier file used by a later one, a later file replacing what an earlier declared, only the last file’s value the plug-in, one file’s own name in its error, the sandbox the same in every file, a door reached from a function an earlier file declared; a `throw` on a line of the second file giving that file, line and column, from an `async` function too, a syntax error giving its own file and line, no `<prelude>` frame ever counting, a value thrown that is no error having no place, a script’s own `stack` believed only where it names one of the call’s own files and bounded, a limit keeping no place, and a door’s refusal naming none
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `entry` group)	`entry` as a file name or a list: absent it is the stem’s own name; one string is one file; a list is kept in order and a folder inside the plug-in allowed; `..`, an absolute path, a drive letter, a backslash, an empty segment, `./`, a file that is not `.js`, the same file twice, a thirty-third file, an empty list and an item that is not text are each reported by the path they concern and the plug-in does not run
`packages/filmopen_plugin_host/test/plugin_files_test.dart`	the host’s side: three files running as one scope through an action, a one-file plug-in unchanged, a file the manifest names that is not in the folder listed and refused `noCode`, a bad `entry` leaving the plug-in listed with its path named and unable to run, and a file of the folder that cannot be read reported and hashed as no readable file can be, more than 2 MB of code refused with the limit named, an `app:` string named in any file resolved; a throw and a syntax error each giving their file and line through `PluginCallFailed.file/line/column` and `at`; the consent hash changing for a byte of `assets/`, of a platform file, of a locale file or of the code and for a file added or removed, a picture hashed by its bytes, and a plug-in a person allowed asking again once any file changes; the stock record’s trust check over the same files — every file matching is trusted, a changed asset is not, a file beside the record is not, and a file beside the record that cannot be read is not either; project `plugins/` files register nothing and remain untouched under Other files; a `data/pg_` entity supplies no executable plug-in; development and library plug-ins register with development taking a shared tag; the installed default runs whatever the film points to or picks — a pointer to v1 and a pick of v2 leave v3 running, and a stock author’s version comes first — each choice logged as `plugins.registry.chosen` with the tag, the version and `highest` or `stock`; a reading lists the library once, a superseded reading stops before the next plug-in, and of two reloads asked together the first stops before it lists; with a trace-level sink, a reading’s start, listing and publication, a reading held in the catalogue already logged in that stage, the superseded one’s stage, a library that does not list logged as `plugins.registry.listFailed` and `plugins.loadFailed` with what was published left in place, and an empty library a listing of none
`packages/filmopen_plugin_host/test/install_archive_log_test.dart`	Install from file’s log (§6.11): a damaged file refused with its code, step, reason and time; no library refused as `no-library` with the plug-in read, a read-only one as `library-read-only`; an install’s start, each file read and written with its target, and its end with the stem and time; the same file again refused as `tag-present` with the tags present; a failing write logged with its step, target, the error’s message and time and answered `writeFailed`; a library whose listing throws logged as `plugins.installFailed` at the `present` step with the message and time and answered `failed`, never thrown; a listing that throws only once the files are written logged as `plugins.loadFailed` with the message, then `plugins.installFailed` at the `reload` step as `registry-reread-failed` with the files written, answered `reloadFailed`, the files in the library and no `plugins.install.done`
`packages/filmopen_plugin_host/test/action_failure_test.dart`	an action that answers `state: 'failed'` failing on its page (§6.11), over a plug-in shaped as a repair through a separate model service on this computer: the service not set, a failure in the plug-in’s words with its code as the reason and nothing sent, ComfyUI’s own address not standing for it; the service refusing, a failure after its one request; the service verifying, done in the plug-in’s words; a message alone an answer; a failure with no message key, or one its locale files do not hold, said in its problem’s words, its code kept as it is; a failure with no code logged as `failed`; each failure logged as `plugins.actionFailed` with its code and its words
`packages/filmopen_plugin_host/test/server_deadline_test.dart`	every server call bounded (§6.11), on the actual host with a short bound against a provider whose requests a stand-in answers or holds: the default bound is the thirty-second discovery budget with a second’s grace; `deployServer` alone bounded at a hundred and fifty seconds, a deployment slower than the other calls’ bound answering inside its own while a list as slow is cut, each bound logged (`plugins.server.bound`); a deployment whose terminal Usage holds answered within its bound, the grace inside it — this and the other held-Usage cases on FilmOpen credit, the only route on which a server function writes a record; a call refused before admission logged with its code and why (`plugins.server.refused`); all five slots taken past the bound, the call leaves the queue as `timeout` with no reason and its provider is never asked, and the next call answers; a stalled `serverCapabilities` cut at the bound, its turn and slot given back — a call beside four others starts at once and a sixth beside five waits; a quote whose request asks for five minutes ending at the bound with nothing asked after it, one timeout event containing only plug-in, outcome and elapsed time, no counts, and the key in no log line; a caller’s own stop staying `cancelled`, before the bound, nothing asked after; an answer at the instant of the stop one outcome and one slot given back; a stalled `deployServer` kept by the sessions as uncertain with `timeout` and looked for through the list, never deployed again; a render whose server’s resolution stalls refused `no-server` at the bound with its engine never asked and `plugins.serverUnresolved` logged as `timeout`; a nested call’s five-minute request ending at the server call’s bound, nothing asked after; parent expiry and precompleted cancellation refusing before admission; cleanup reserve, short/long parent clamps, twenty-second capabilities leaving ten seconds for catalogue and its fallback; queued cancellation leaving an unrelated call alive, owned clients closed, first stop cause retained while terminal Usage is held, and admission freed promptly after the append completes
`packages/filmopen_plugin_host/test/usage_once_test.dart`	a cost said on a pending poll is no cost (§6.7, §6.11): two pending polls each saying 0.10 and a terminal answer saying it give one Usage line at 0.10; two polls citing the job’s receipt still give one line at 0.10; the top-level `cost` on two pending polls gives one line too; a managed job’s pending polls saying a cost persist nothing, its end prepared once at the terminal answer’s cost; a job cancelled after a pending poll saying a cost ends `canceled` at a cost nobody knows with its accepted requests, never free and never the poll’s sum; a managed job’s `failed` answer that confirms no end keeps its 0.10 at once, before the job’s end
`packages/filmopen_plugin_host/test/unmanaged_replay_test.dart`	both cancellation outcomes replay the original pending receipt after restart, submit and cancel once and permit late collection; unmanaged, the repeated answer under the id the log holds is not appended again; the registered variants defer terminal Usage to settlement; an answer under an id the log already holds, with other content, is neither appended again nor refused, unmanaged, managed or restored
Usage once (the audit, §6.7)	one test per rule of the chain: `started` with the catalogue’s estimate (`plugin_calls_test.dart`, started is estimated at the catalogue’s price…); the actual cost from the answer (`gpt_image_render_test.dart`, the picture answered inline is staged…); a cost of nothing kept as nothing and a cost nobody knows kept distinct (`gpt_image_render_test.dart`, a cost of nothing…; `plugin_calls_test.dart`, a receipt counts for its own key…); a request lost leaving its chain open (`plugin_calls_test.dart`, a request that timed out…); a charged failure kept (`gpt_image_render_test.dart`, a paid answer whose picture is no picture…; `sync_answer_test.dart`, through the backend, that refused answer is a charged failure…); a receipt answered twice counted once (`plugin_calls_test.dart`, a job answered twice is counted once…; `usage_once_test.dart`); a pending poll’s cost not summed (`usage_once_test.dart`); a key check unrecorded (`host_runtime_test.dart`, verifyKey reaches the candidate credential…); a compute session’s records apart from a model’s price (`server_provider_test.dart`, the sessions over the host…); restored answers after a restart adding nothing (`receipt_storage_test.dart`, paid uncertain collect survives restart and Retry counts … once; `settlement_restart_test.dart`, a paid single-call Stop settles its late answer exactly once; `render_backend_test.dart`, a job asked about again after a restart continues its usage chain…)
`packages/filmopen_plugin_host/test/server_offers_test.dart`	a server provider’s quote through the whole host (§6.11), from a provider shaped as the published `fo-salad`: forty-nine GPU classes probed four at a time with the requests in flight together, the key added at the door for its own host alone, a disk size of fifty gibibytes sent as the exact integer it is, every offer read by the quote, and `plugins.serverOffers` logged with the offers, the counts answered and read and the time, the key in no line; one probe refused failing the whole quote with its code, never a list cut short, and no count logged
`packages/filmopen_plugin_host/test/render_journal_file_test.dart`	the render manager’s and the server sessions’ journals named so that the jobs’ own journal passes over them — a jobs engine over their folder reporting nothing, where the earlier name `renders.json` reads as a job of a newer build’s — an earlier build’s file taken over the first time the journal is read and read as it was, and a journal under its own name never replaced by an earlier one beside it; a journal set aside renamed `.old` byte for byte, the next read finding none, the folder’s jobs untouched, and a second set-aside replacing the first
`test/film_replaced_message_test.dart`	on the whole app: the message that something asked for finished after its film with no folder was replaced (§9.7), said when the count grows and never before
`test/compare_heading_test.dart`	Compare’s left heading (§9.3) at 700 px keeping the version’s number whole inside its column where the handle is cut, with nothing overflowing, and one line as before where the whole heading fits (runs alone)
`packages/filmopen_state/test/project_test.dart`	loading the sample: counts, warnings, resolution rules, the tree’s shape — the script drilled down through its folders, every row name first (a folder its name, its kind in words and its stem, a scene, a shot and a cue their name and their short name), the episode’s music cue under its folder before what the folder holds, nothing under Not in the script — and a pick an official version overtook painting every row up to its entity (§13.2)
`packages/filmopen_state/test/clipboard_asks_test.dart`	the clipboard asks (§4.2), on replies the test completes: 500 concurrent `Clipboard.hasStrings` one native ask whose bytes every caller gets, `start`, 499 `joined` and one `done {callers: 500, answer}` under one `op` and its `via`; at the default threshold each join logged with its `op` and `callers` before anything answers; an ask after completion a new one, and one made from a caller’s own completion too, the slot released before any caller sees the reply; `Clipboard.setData` during a pending ask logged `stale {reason: setData}`, the ask after it a native one of its own, the three sends in their order, each caller its own reply, and the stale ask’s completion leaving the fresh one in the slot; a failure failing every sharer, logged with its error, the slot released; a send that throws at once the same; an error envelope reaching every caller as its bytes and logged decoded (`code`, `message`); no reply a `done` with no answer; other methods and channels passing in order with nothing logged; the messenger delegating handlers, their removal and inbound messages
`packages/filmopen_state/test/open_settles_first_test.dart`	opening another film lets the film being left finish its writes first (§7): a pick clicked behind another still being written lands in it, the person’s last click, before the other film’s folder is read; picks clicked while a draft is being written land too, the last in A, nothing in B; a fork asked as the drafts settle and a pick chained on another landing in A first; a star still being written landing whole — the director’s own pick taken off — before B opens; writes queued again on every pass spending the passes and refusing the open; a pick still held at the limit refusing the open, A staying; of two opens asked while a draft is written, the one asked last opens and the other’s folder is never read
`packages/filmopen_state/test/outfit_tree_test.dart`	a character’s outfits under their epoch (§8.2): one epoch row per epoch the character or an outfit is at, declared first and an undeclared one after; each holding the character’s version rows and then its outfits at that epoch only, each named by its version in use, opening the outfit at that exact epoch, with its own author rows; an epoch with outfits and no character version holding the outfits alone and opening the character whole; no Outfits wrapper; a hand-named id flagged with its sentence and readable; a dotted orphan and an undotted outfit listed under Characters with every reason; unique row ids, a tag spelling another row’s id escaped; an undotted outfit legacy whatever follows; an outfit named at its own epoch only, by its id where nothing resolves there; an outfit’s stale pick painting its own rows only, and one with no pick flagged; the sample’s two symbolic outfits under the hero at thirty, flagged and readable
`packages/filmopen_state/test/create_outfit_controller_test.dart`	`ProjectController.createOutfit` (Project Specification §9.2): created by name with the writer’s allocated id, the name trimmed, picked and re-read; a `gate` run in the queue after the wait refusing a creation stopped meanwhile, nothing written, and a `draftLabel` passed on, the outfit labelled and not picked; two in a row allocating two ids; ids staying as allocated after the epochs are reordered, an outfit’s file deleted and the folder read afresh, the next creation never filling the gap; an id taken meanwhile — a file arriving, or the writer’s indexed-group refusal — the answer, nothing tried again, the arrived file never overwritten and read into the index for the person’s next try, which allocates the next id; a pick the writer could not record making no second outfit; an undeclared epoch, a missing character refused and not retried; another handle, a film closed, a film switched while it collided — refused, no second attempt in either film; another film asked while it collided — the creation landing in its own film first, then the other opening; a re-read asked while another film opens reading nothing of the film being left; an owner and their workspace creating at once taking two ids; `OutfitParentUnavailableException` said in the app’s sentence, never its text
`packages/filmopen_state/test/fixture_test.dart`	spec behaviours on tiny in-memory projects: a file official names reading the official world while the same reference read from its author’s own file reads theirs (§6.1 step 2), ambiguous resolve, `default`-only fallback, project selection (ask, invalid pointer, sole author handle — a workspace’s project fork counts as another author), tolerance of wrong types, leaf scenes and unresolved rows in the tree, cycle detection; and, the Script branch on folders — an entry naming a scene the project lacks left out, an ambiguous scene a warning row from which its versions are still reached, a folder that lists itself through another reported and not recursed, and on `foldersFixtureFiles` a folder row’s name, kind and stem with a token the vocabulary lacks as written, folders and scenes mixed in one list with a pinned entry drawing that version, each of the five reports as a flagged row with its sentence, a folder’s cue under the folder and a scene’s under the scene, Not in the script flagged below the script with a folder’s contents beneath it, and two equal entries as two rows with two ids; a kind the vocabulary lacks as written with its capitals and the vocabulary’s own in lower case; the Script row counting items; a folder’s Cues tooltip, a scene’s two, and an explicit list naming one cue twice as two ids; no Not in the script while no project file is chosen
`packages/filmopen_state/test/entity_patch_test.dart`	per-film/version serialization; no-op without a write; closed/different film refusal; writer refusal codes and unchanged files; an explicit expected entity preserving stale detection; project-qualified open draft and pending typing; viewer binding while queued; film recheck after queue; detached-write barrier; ordinary save source guard and no adoption of a replacement film
`packages/filmopen_state/test/write_path_test.dart`	the write path’s invariants (§7.5): a stale refusal reading that one file into the index, the refusal standing and the retry succeeding with nothing more read; a patch that writes nothing releasing and publishing nothing, and through an open draft telling it nothing; insertion’s attachment through `ContainerInsertionEnvironment` refused stale with its one file read, Attach again landing on the outside text; an upload’s capture, a save landed and its publication held, taking the landed text, and its batch, held at the disk, in the record and not yet landed, then published once with nothing read; a Stop while an upload’s batch is written, the batch and its take kept unattached and published once, the job cancelled; two direct patches of one file, the first’s publication held, both landing — the second starting from the first’s landed text; a standalone patch one write and one publication, nothing read; two gestures under the fake clock published without pumping time, and one across `runAsync`; a pick and a visit of one commentary file, the publication paused, in both orders, the second waiting and both landing; a save landing while another publication lists, kept; a full read paused after it read a file whose save then lands, the save kept after both and after the next gesture; a re-read of a film left paused while another film opens and saves, taking none of the open film’s writes, whose own step publishes the save; a write of a film left landing after another opened, no news there — a no-op publishing nothing, the next save’s step taking its own write alone; a save through a patch’s kept write context after the patch failed, a gesture of its own that publishes; the library read once per attach, a development-mode library save held and surviving an open; an install’s re-read listing and reading the library again, a closed film not read and its next open reading the library afresh; `noticeWritten` taking a burst: each text landed unread, one without its text read, one publication as its gesture
`packages/filmopen_state/test/decision_view_test.dart`	one view for every decision (§7.5), through the real open and the command registry: an update decided while the last update’s publication lists reads that write, so a reversal is written, never `unchanged`; an update decided while a pick of the draft publishes reads the pick and forks, the picked version never written over; Discard refused while the version’s official pointer is being written, the star then landing alone; an update decided while the person’s pick of the draft, or the director’s star of it, is in flight forking the draft and never writing into it, the choice landing whole; Restore of a deleted draft an update landed in while its publication lists keeping that write, never refused stale; an update and a scene whose publication fails answered `failed {stage: publish, stem}`, the next publication taking the landed write; Add scene and Fork refused by the disk logging what was entered and the source’s message; no decision door reads the published index, takes one from its caller, or is handed one by the page’s actions or Restore’s banner, which read it for a film’s identity and for what the person saw at the click — the project version in use an epoch is declared on, checked again in the controller’s queue — and never resolve an entity, a version or a pick on it to write against (a scan of the doors — the insertion environment’s, an import’s Apply and the plug-in host’s environment among them —, of the controller’s members and of the callers)
`packages/filmopen_platform/test/folder_watch_test.dart`	the folder watch’s seam (§6.1b) on streams of paths: the `.json` paths heard settled once, 400 ms after the last, a `.tmp` and another file left out; a watched folder that goes away stopping the watch and its timer, nothing settled after, logged `gone` with what was pending; a failing watch stopped with its message; a folder that is not there not watched, `project.watch.unavailable`
`packages/filmopen_platform/test/folder_watch_fs_test.dart`	the folder watch on a real folder of this machine (§6.1b), tagged `fs` and skipped in the gate (`flutter test --run-skipped --tags fs`): a document another process writes into `data/` through a temporary file settled as the document alone; a root another process removes stopping the watch, nothing settled
`packages/filmopen_state/test/folder_watch_settle_test.dart`	the own-write test at settle (§6.1b), through the real open on a watch over a stream: a document changed outside, one added and one removed judged `differs`, `new`, `gone` with the text read and the text compared against, the film read again once (`project.refresh` `reason: watch`); the app’s own pick passed over as published, in flight and landed, an absent file as ours, no re-read; a read paused after taking the old text while the app’s next write lands and publishes judged ours, with no listing, and a genuine outside change after it still read again; Close project stopping the watch; a file sync received lands with its text in one `sync.arrived` publication, unread, and the watch passes over it; an arrival held behind a running publication ordered where it arrived, so the person’s later save is what the index and the view hold, the arrival logged with its text
`packages/filmopen_store/test/held_loader_test.dart`, `write_record_test.dart`	the loader’s re-derivation (§7.5): listed and not held read, held not read, gone gone; landed writes laid over, a deletion dropped though listed, a write in flight skipped and absent; the library listed and read once per `HeldLibrary`, equal relative paths kept apart; a takes-only arrival appearing in the next re-derivation with nothing read; no source class answering through `noSuchMethod`, the scan proven to reach the sources; the record: a landed save handed back, an unchanged save writing nothing, a stale refusal — a write’s or a fork’s check — kept with its root, a failed write dropped; the record’s in-flight writes seen by the guards — Discard refused while the version’s pointer is in flight, the star while its discard is, a pick or a pointer in flight or landed unpublished naming its version as in use (`inUseRecorded`: which choice, and whether it landed), another version’s or another author’s not; the overlay laying the landed writes over a published index, reading and listing nothing, the index left as it was
`packages/filmopen_forms/test/draft_write_context_test.dart`, `form_side_context_test.dart`, `patch_draft_race_test.dart`	bound revision writes, own-write adoption, failures/retries/disposal, compatible and incompatible contexts, an incompatible writer refused at once over a write in flight or pending typing, the person’s save in flight and the typing during it written before the patch, which a form gone meanwhile writes detached before apply answers and without a re-seed, later typing, discard, rendered film identity, equal-stem film switches, selective synchronous reseeding and caret, a box typed into drawing the form once, at its first letter, while the draft’s card hears every letter preservation; two queued real-draft patches and later typing surviving one or four overtaken refreshes before a widget frame, without adopting a different outside edit; a stale refusal’s re-read ignored by the dirty draft until it discards
`packages/filmopen_state/test/job_report_log_test.dart`	`logJobReport`: an engine event with its values written at info under the prefix given, an event that failed and a failure at warning with the error’s whole text, a failure without values keeping the id alone; a value named `id` or `error` never replacing the job’s id or the error
`packages/filmopen_state/test/insertion_shutdown_test.dart`	a bounded shutdown keeping a copy journalled with its last intent, the copy’s start (progress 0) among it; reopening the film restoring the unresolved job through the application binding without a second put; its bytes input not at hand after the restart, the job needing attention as `sourceUnavailable` with Dismiss, the import the exit left draining standing as its take with its record, nothing attached
`packages/filmopen_state/test/epoch_writes_test.dart`	the controller’s two epoch writes (§8.2) on in-memory projects: a declaration saved in the viewer’s own version in use, and a fork of another author’s made, picked and answered; a project pick completed in the queue first, another handle, no handle and a film replaced each refusing it with nothing declared; a copy of the version in use — another author’s, or the library’s, read there and written in the project — as the viewer’s picked v1 with `forked_from`; a pick completed in the queue first, the same version’s bytes changed and re-read while the copy waits, the source changed on disk unread, a version made at the target meanwhile, the target no longer declared, another handle, no handle and a film replaced each refusing it with nothing written; a declaration whose write answers after another film opened answering no version of that film; a changed binding refused as such, with its own sentence; `PageAccess.canCreateVersions` on a writable project with a viewer, without one, and on a read-only project; and the three refusals’ own sentences, never a developer’s text or a token; a save lowering the epoch floor said in its own sentence; an epoch whose every version is discarded still taken, nothing written; `PageAccess` refusing the check and the star on a discarded version under both guard modes; each changed binding refused with its reason — `viewerChanged`, `projectChanged`, `sourceChanged`, `targetUndeclared`, `targetExists`, `targetExistsDiscarded` — and the line `write.epochBinding.refused {op, stem, reason, expected, found}` pinned for another project version in use, another viewer’s declaration, another source, a target taken and a target no longer declared
`packages/filmopen_store/test/next_epoch_floor_test.dart`	a project file’s save that lowers, drops, spoils or makes fractional its `next_epoch` refused by `checkSave` and `saveEntity` with nothing written; the same floor, a whole double of it and a higher one saved; the file’s own floor deciding, not another version’s higher one; a file holding 4.0 refusing 3 and saving 4, one holding a string saving without a floor, and one holding 0 or 1 refusing its removal and 1 refusing 0; a cross-owner fork’s floor of 1 refusing its author’s save of 0; development mode refusing it still; a file without a floor saving without one and a character’s `next_epoch` an ordinary field; the writer’s own declaration still raising the floor
`packages/filmopen_state/test/epoch_tree_label_test.dart`	the tree’s epoch row named by the label with the year as its detail, else the year, else the token of an unlabelled declaration, its id unchanged; `epochLine` putting the year beside the label
`packages/filmopen_state/test/commentary_queue_test.dart`	one queue per commentary file (§7): a visit and a pick in either order both landing with no stale refusal, a fork’s pick and a visit both landing, a visit asked in another film opened meanwhile being a write of its own there while the first film’s is never written into it, a visit its film closed before it started freeing its place for the next, a stale visit refused, logged and the file read in, the next visit landing, one refused twice logged as `visit.failed` and never thrown, no visit without a handle nor on a read-only project; the controller’s delete refusing another author’s take and a take another file of the film keeps, each said in its sentence, and deleting the owner’s unnamed take
`packages/filmopen_state/test/children_controller_test.dart`	adding to and removing from the script in the controller (§7): a move beside a row landing beside it, in another list and in its own, and one beside a row the list no longer holds refused with nothing written; a folder on the script and a scene in a folder — the file, the pick, then the entry at the end of that parent’s list and of no other; another author’s parent, no handle, a taken short name, a `children` that is not a list and a parent a save would refuse each refused with nothing written; a parent changed on disk meanwhile — the new file made, beside the script, the answer saying why, the changed file not overwritten; an open draft that cannot be written refusing the add; a form open on the parent — what was typed after the settle and the new child written together through its draft, the next keystroke saved against the text that write left, a draft on another file left alone, a refusal of the draft’s write as the add’s answer; removing — nothing deleted, the scene then beside the script, the occurrence choosing among equal entries, another author’s parent and an entry that is not there changing nothing; the one walk — `scriptOutlineProvider` answering the same object to a second reader and to the tree, following a write, and a `TreeBuilder` handed a walk drawing that walk and making none of its own; `moveChild` — within one parent one write to the place asked, to the end without an index, and nothing written where it already is; between two parents in the destination and out of the origin, a pinned entry still pinned and the pin still choosing its version, a place in the destination; one gesture — two writes, both patches in the gesture `moveChild`, one publication, and the move’s start, its decision on each list, its answer and a refusal logged; the children queue — an add queued behind another written as the viewer who asked though the handle changed meanwhile; two folders moved into each other at once, the second refused as a folder into itself and no cycle written; the destination written first, a second write that fails answered with the entry listed twice and reported; from beside the script one write; a folder into itself or beneath itself refused with nothing written, and beside it allowed; either parent being somebody else’s refused before anything is written; a destination that names it already taking no second listing and answering `alreadyListed`; the origin written as it was checked — a source that rewrites the origin while the destination is being written, the move’s second write then refused as stale, the outside change whole and the entry listed twice, `folder.childMoveHalfDone` an error naming both lists, what landed and the refusal, and the destination published once; an entry that is not a string removed as the row that was pointed at, its neighbour of the same text staying; many rows moved at once (`moveChildren`) — one write of each list in the order given, to a place, three origins in one gesture and one publication with its logs, a reorder within one list one write, a folder, its child and a scene after it landing in that one order, an entry the destination names already the removal alone and said, an origin’s write failing with the destination and the other origin landed and `folder.childrenMoveHalfDone` naming them, a publication failing with the answer carried, an own children edit landed between the dry run and the write with its publication held built on and proved, a selection of one through the same path whole, half-done and unpublished, a gone entry, an entry or a `beside` row listed twice and a folder into itself for the second entry refused before any write, the same decided again after the dry runs — an own save through `saveEntity`, its publication held, landing while a dry run awaits a draft’s settle and removing the origin’s entry, listing it twice, listing the `beside` row twice, taking it out of a destination that already held it, putting it back in an origin found without it, or making a cycle: each refused before any write with its logged reason, and a move that changes nothing writing and publishing nothing; a write whose own re-read is overtaken — a source that starts a second, slower re-read from inside the first one’s listing — still read as landed, the re-read made again; an origin that no longer lists the entry making the move the add alone; a destination that is gone refused as `ChildrenChangedMeanwhileException` with nothing written, and the three refusals’ sentences coming from `WriteProblemText`; a parent the draft would make unsaveable refuses the add before the file is made — a name emptied after the last settle, the dry run made against what the form would write, nothing created and the draft not written either
`packages/filmopen_state/test/series_scale_test.dart`	the owner’s example at scale (§7.3, §8.3): ten series of a hundred empty episodes each made through `addChild` on an in-memory source, every child listed, a fresh load with each series listing its hundred and the `TreeModel` holding every episode row; the times logged, never pinned
`packages/filmopen_store/test/directory_source_test.dart`	on a real temp folder: the path sandbox, skipped folders and `.tmp` siblings, and the write path — the sandbox again, a changed file and an existing file refused, no temporary left behind, a delete that honours what the caller read; and the binary half (§6): a picture written and read back byte for byte with its length, the same sandbox for bytes, an existing media file refused under `create` with no temporary left behind, and a 500 MiB stream copied through without the process growing by a tenth of it; a stream its caller stopped (`WriteCancelled`) logged `folder.write.cancelled` at info, its temporary deleted and no file left; the label being the folder’s name whichever separator the path was written with — two of the six spellings biting on either platform — and the project key of §5.15 on the real folder source — one folder one film however often it is opened, a trailing separator the same folder, another folder another film; text and byte writes through external `data`, `media` and `thumbnails` links refused before creating a missing destination or its intermediate directories, with outside bytes and directory listings unchanged; dangling directory links refused; internal directory links to the source root and ordinary nested destinations still writable; the listing from a background isolate skipping hidden entries, temporary files and build folders; a large file read whole as text and bytes; a 1 ms timer serviced while 500 files are read one after another, armed after the listing; and the listing’s and reads’ log lines, on success and on refusal, with the folder and the paths as they are, a file that does not decode a warning at the default level and a missing file below it; a write into a read-only folder `folder.writeFailed {step: write, osError: 13}` with the system’s message; a rename refused while a read of the same path is held in flight naming that read in `reads` with its kind, start, age and caller, the system’s code and message, the target and the temporary file, and the same refusal with no read in flight naming none; a read that finishes during the temporary file’s cleanup still named, as sampled at the catch; a cleanup that fails after a refused rename logged `folder.write.cleanupFailed` apart, the rename’s refusal the one logged and thrown; a byte write that fails naming the read its sink’s close lets finish; a stale save’s and a stale delete’s `expectedText` step carrying the expected text, the text on disk and the attempted text (none for the delete); and `osErrorCodeOf`
`packages/filmopen_format/test/session_copy_test.dart`	the canonical session-copy predicate accepts writable memory and overlay sources, refuses writable disk-rooted sources, and refuses read-only rootless sources
`packages/filmopen_format/test/project_groups_test.dart`	the index’s derived readings (§5.3, §5.4): every scene of a 500-scene film resolved with each author’s pick, the commentary walked once; every scene’s shots in natural order, children only, the groups walked once; a tag ending in a dot, a double dot and an empty parent as the prefix rule reads them; a list a caller is given its own; an author’s first commentary file about an entity theirs, the others still listed
`packages/filmopen_format/test/project_source_test.dart`	binary I/O in the sources that need no disk: a memory source writing, reading, listing and locating bytes as `BytesMedia`, text read as bytes, `create` refused whichever kind is already there, a delete taking the bytes; and `OverlayProjectSource` — reading through, keeping every write and delete to itself, refusing `create` for what the folder behind it holds, refusing a stale write against what it shows, and of two writes, two create-only byte writes or two deletes at once against one expected text landing one and refusing the other as stale
`packages/filmopen_format/test/media_names_test.dart`	what an upload is called and where its thumbnail lives: the kind from the extension (upper case, a dotfile, a name without one), the prefix naming the purpose on every library type (a character’s audio `vo`, an outfit’s and a location’s `am`), the names of one action numbered per purpose and parsing back through the grammar as takes of that source with no naming warning, the eight-hex id of the second, a second later, the next free one when it is taken, a local instant and its UTC twin; the thumbnail’s path for a stem, a file and a nested path, and none for a URL; `projectAreaOf` for root, documents, media, thumbnails, unknown and nested paths, and the document/media path helpers; layout classification preserves a literal backslash in the file name while extension helpers still accept operating-system paths
`packages/filmopen_format/test/media_slot_test.dart`	a slot’s JSON round trip with its discriminator; a group’s name a lowercase snake_case word that is not reserved; a path outside the container; the retired `refs` and `voice` slots and every other shape refused as `invalidMediaSlot`
`packages/filmopen_format/test/media_entry_test.dart`	§9.0’s entry: usable when neither deleted nor archived, kept or unreviewed; `audio` true or false read and written, absent where unmeasured, another shape read as absent and kept; read and written back with every key it does not read, in its order; one with no record by its reference alone; a known key of another type kept and read as absent; a flag or the note changed in its place and a cleared one removed; equality whatever the key order; a string, a null, a number and an object without `reference` unreadable — skipped, reported by their group and kept by a writer; a repeat reported once and its first place read; a key that cannot name a group, a group that is not an array and a `media` that is not an object reported; an entity’s `mediaWarnings`; the seven keys of 1.27, `spans` read through `MediaSpans`
`packages/filmopen_format/test/spans_test.dart`	a block media’s `spans` (§10.3): the four forms of the two shapes byte for byte through the entry, a fractional `seconds` as given; every wrong shape — both keys, neither, an extra key, an empty list, a non-string or empty id, a non-list, an `until` of another shape, a `seconds` of zero, negative, infinite, not a number — read as absent with the entry’s value kept; the constructors refusing an empty list, an empty id and a `seconds` not greater than zero; the six groups in order with their allowed shapes and defaults, and their kinds, which `acceptedKindsFor` answers; `spansAllowed` — a clip’s `blocks` kept and its `until` null, music and sound effects either shape as written, frames and voice lines none, an unknown group none
`packages/filmopen_format/test/block_media_test.dart`	a block’s media read by the one walker (§9.0, §10.3): the entity’s groups first, then each block’s in order, the first place of a reference the one read, an object of `blocks` that is not a block or whose `media` is not an object passed over; a clip a block names found in a scene with no media of its own and never in an entity group of its name; an entity group’s reorder, flags and copy untouched by a block’s entries; an insertion adding nothing a block holds; a take a block’s entry alone names kept on delete; a block’s unknown group and unreadable entry warned at `bl_8.<group>` and `#2.<group>`; a document without block media as before; inserting into a block’s group — first in the first block of that id, its container made, no `preview`, a reference held in the entity or any block not added, a missing block or a `media` of another shape `wrongShape`, a group not of the six an argument error; the readers taught a block (`block:`): `entriesIn` answering a block’s first places, the first block of an id, and the entity call passing them over, and with the document’s `MediaPlaces` answering as it does walking the document itself; a favourite, a note and Keep (`unreviewed` gone, `kept_at` written, in one edit) changing the block’s array alone; a delete there clearing the entity’s `preview` and `picks`; a reorder of the block’s array, its repeat following
`packages/filmopen_format/test/media_test.dart`	§9.0’s container: insertion adding only what no array holds, first or last in the block’s order, making the array and the container, keeping every odd item, changing nothing on a replay, refusing a container or an array of another shape and a name that cannot be a group; `preview` set at the first picture and never over the author’s; flags set and cleared in place, `deleted` clearing `preview` and every `picks` value naming the reference; a reorder with an odd entry and a repeat kept after, another set refused; the live references; `isArchived` and `isDeleted`; each type’s places in order, and `acceptedKindsFor`’s matrix over them, a group no table names taking every kind; a delete clearing a `preview` and picks that name the take by its other spelling, stem or file name, and never a file of the same name and another kind; a take’s entry found by either spelling, and a file of the same name and another kind not; a take held by either spelling, so a deleted one comes back under neither; an address and a file placed by hand each their one word; each place’s prompt kind (`placePromptKind`) — a reference, a sheet, the voice — and none at inspirations, motion clips, a cover or a group no table names
`packages/filmopen_format/test/place_rules_test.dart`	`acceptsFile`: a picture, a clip or a sound of a kind the place takes, never another kind, never a file of no media kind nor a name without an extension though a group may hold one; `arrivedAfter`: an entry whose named batch was created after the look, not one created before, never an entry that names no batch or a batch the film does not hold, nothing without a look
`packages/filmopen_format/test/take_naming_test.dart`	the take a reference names, by its stem or its file name, and none for a file placed by hand, an address or another extension of a take’s stem; the take index by stem, the first listed where two share one, built once; only live entries keeping a take, under either spelling, an archived one included and a deleted one not; every object of every array of `media` keeps a take — one under a key no reader reads as a group, and a repeat behind a deleted first place — while a deleted object keeps nothing; a take the viewer’s own when its renderer is the viewer or a workspace of theirs (`ann.fo-cui` for `ann`), and never another’s, a workspace viewer’s for its owner’s plain take, or anybody’s without a handle
`packages/filmopen_format/test/plain_text_test.dart`	another author’s words as one plain line: controls, line breaks and direction marks out, spaces collapsed, and a long one cut with an ellipsis, never inside a character; the other breaks and marks, U+0085, U+2028 and U+061C, out too
`packages/filmopen_format/test/commentary_visited_test.dart`	§13.4’s `visited`: per epoch from its object shape; a plain value answering only for an entity without epochs; absent, empty or of another type saying nothing; read beside the pick without touching it
`packages/filmopen_format/test/batch_item_test.dart`	a record’s item by its `n` on the sample’s two records, with the `group` a group took the output into and none for a take found by name; the first of a repeated `n` in a hand-written record; a `group` of another type read as none
`packages/filmopen_format/test/set_record_test.dart`	a pending set’s record (§5; Project Specification §12.7): the header, the items as maps and each type’s members; `next_item` absent, `7.0`, below the highest `n` or not a number; the viewer’s pending record per type, `open` for a session, none without a viewer; two pending records, the newest by `created` (an instant in two offsets), one without `created` last, equal instants by stem; an unknown status as history; `sets` empty by default and kept by `withSelectedProject`
`packages/filmopen_insertion/test/thumbnailer_test.dart`	the thumbnail (§6.3): a 1000 × 750 photograph fitted to 300 × 225 inside the budget, a busy one inside it, a tall one fitted on its height, a small one never enlarged, a transparent PNG flattened on grey, EXIF orientations 1–8 preserving upright aspect, a GIF’s first frame and non-picture bytes returning none; stock pictures at 300 × 300 with stable bytes differing by kind; trusted bounded dimensions measured without retaining pixels; small PNG clones with checked IHDR dimensions and checksum refusing400-megapixel and just-over80-million-pixel headers, while real1000 ×1000 and1001 ×1000 PNGs keep photograph thumbnails; a header-only 65535 × 65535 JPEG refusing both measured dimensions and thumbnail promptly, truncated or inconsistent frame lengths, zero dimensions or component count, duplicate components and zero sampling yielding no trusted dimensions; a valid small JPEG padded beyond8 MiB keeping its own thumbnail without an input-byte ceiling; a24-megapixel JPEG keeping its300 ×200 thumbnail on the IO worker with its actual whole decode/fit/encode time printed; the IO helper using a different isolate debug name with no caller Zone marker; a duplicate valid PNG IHDR is rejected before it can replace the guarded dimensions; hostile PNG axes of 0xc0000000 and axes above the signed 32-bit limit yield neither dimensions nor thumbnail; the pixel bound is checked without overflow, while ordinary 2048 × 1080 and 1024 × 1024 pictures retain their own thumbnails; JPEG, GIF, BMP and static WebP headers share the exact80M boundary guard without bitmap allocation
`packages/filmopen_insertion/test/thumbnail_formats_test.dart`	BMP INFO-family and top-down dimensions, colour, palette/offset/mask bounds; oversized BMP and VP8/VP8L/matching VP8X headers yielding no dimensions or own thumbnail before allocation, which the importer replaces with stock artwork; static lossy/lossless/alpha WebP dimensions, shape, colour and grey transparency; RIFF lengths, padding, duplicate/competing headers, actual encoded bounds, VP8 scaling bits, malformed and oversized headers; animation deferral; ordinary importer original bytes, measured dimensions and nonstock thumbnails
`packages/filmopen_format/test/media_paths_test.dart`	path splitting (§5.10) on Windows and POSIX: drive, UNC and relative roots, either Windows separator, `.` and `..` resolution without climbing above an absolute root, and POSIX backslashes retained as name characters; the platform is passed explicitly so either machine checks both conventions
`packages/filmopen_insertion/test/media_importer_test.dart`	the one way media enters a project (§12.3): undecodable picture bytes given the stock thumbnail of their kind; a fetch’s client closed once, refused or read whole; each take’s `media.thumbnail` naming its source (decoded or stock), the reason, the size and the time; a picture becoming a take in `media/`, a thumbnail in `thumbnails/` and a batch record in `data/` with `original_name`, `sha256`, `bytes` and the picture’s size; two pictures and a clip in one batch numbered per purpose, with the clip wearing the stock picture; a second upload a batch of its own and a second in the same second taking the next free id; a sound taking its purpose from the entity it is dropped on; the refusals — not media (before anything is written), empty, too large, no viewer, a file that is gone by the time the import begins, a name the store already holds making the import take the next id instead, and a store that refuses a name half-way leaving nothing of the batch behind; the URL door against a `MockClient` — fetched and named like any other file, refused for a content type that is not media, the log carrying the address, the status and the content type, refused for a server’s answer without its words or the address reaching the exception, the log carrying the address, the status, the reason, the content type and the server’s words whole, and refused for a scheme that is not `http` before anything is asked, and on the desktop a link declaring past the old 2 GiB taken, not refused for its size; an upload found as a take when the project is read again, its thumbnail not an unknown file and its display name the original; and the importer leaving the entity alone, the entry going in through `withEntriesInserted`; one import’s items numbered `1..k` over every kind with the file numbers still per purpose, each naming its input’s group or none; the groups one per input; a record that cannot be written taking every file and thumbnail back out and refusing as `recordNotWritten`; a group that is reserved or no lowercase word refused before anything is written; a file too large logs `media.importRefused` with its name, bytes, cap and stage `declared`, a link by its declared length with its address, status and content type, a link declaring no bytes refused empty with the same, and a link with none at stage `streamed` as its bytes pass the cap, with its address; a file that fails as it is read logs `media.readFailed` with its name, its path and the operating system’s words and code, and is refused `unreadable`
`packages/filmopen_insertion/test/import_timing_test.dart`	how long a picture on this machine takes to come in: a photograph of about 100 KB and a small file of large dimensions (6000 × 4000), each imported into a project on this machine’s disk five times by the importer — read, hashed, measured, thumbnailed, copied and recorded, an upload’s whole road before its one checkpoint — and the project read again after each, the times written to the test’s output; a measurement asserting each import is whole with one real photograph thumbnail, the large PNG’s300 ×200 size and source colour retained rather than stock, and whole decode/fit/encode time on the IO worker printed separately
`packages/filmopen_jobs/test/journal_test.dart`	recursive payload credential-word refusal at a submission, a checkpoint and a file-journal read, each reported, and never on a record’s own construction or change, including text nested in maps and lists under `apiKey`, `openai_token`, `Token`, `accessTokens` and `projectKey`; `tokenCount: 3`, `submission`, `project` and noncredential word tails accepted; record-owned `projectKey` and `placeKey` remain valid
`packages/filmopen_jobs/test/boundary_test.dart`	the jobs barrel exports only the shared `refuseCredentialKeys` helper from the record file, keeping records and other persistence internals private
`packages/filmopen_insertion/test/insertion_boundary_test.dart`	three boundary checks: runtime dependencies and imports use only the allowed pure Dart execution, media, storage and format layers and third-party packages, without Flutter or dart:ui; development dependencies are limited to test and test support; media UI declares and imports no insertion dependency; forms construct no MediaImporter.
`packages/filmopen_format/test/render_treatment_test.dart`	the treatment a render was made with (§5, the Project Specification §8.7, §12.2), the one shape of a render’s request and its batch item: a batch item’s `treatment` — the leaves that applied and the document each came from — read and written the same, and again after its own JSON; a leaf set for one render alone naming no document, and no `sources` written where none is; what it holds copied and frozen all the way down, the palette’s list too; a treatment never empty and a source always a document’s stem; what is not a treatment — no `visual_style` object or an empty one, `sources` that are not documents’ stems — read as none, and an item without one having none
`packages/filmopen_format/test/usage_estimate_test.dart`	what a call is expected to cost and what its units cost (§6.7): a text call’s input tokens, or a quarter of its characters, and its maximum output, 1,024 where unsaid; a picture’s images at the variant’s price, the resolution’s where a price names it, else the least (a price’s `match`: `match_price_test.dart`), and by its megapixels; a clip’s seconds at the least rate, as a number or its digits; a piece of music’s minutes; a voice line’s characters; the least of the prices that name the resolution; nothing where nothing prices a call or a unit is unbounded, and a request it cannot read estimated, never refused; used units at the one price — minutes among them — tokens that add up, cached input tokens counted within the input tokens and at their own price where the row names one, and no answer where prices are unchosen, two units may price one thing, or nothing is priced; what nothing prices, or a unit the request does not bound, having no estimate, never one of nothing; bundled t2v, i2v and flf2v H3 Max at five seconds quote $0.25 at 480P and $0.40 at 768P by when, lower-case 768p silently falls to $0.25 by least, h3 at 768p is $0.30, and Seedance i2v at 480p is $1.1025; GPT-5.6 Terra’s used tokens at 272,000 and 272,001 input, with cache reads and writes, and a long input whose uncached rest falls below the band, priced at the band the whole input chose, as the portal prices them; a band this reader does not know prices nothing
`packages/filmopen_format/test/input_limits_test.dart`	what an input of a model’s catalogue entry takes (§5, the Project Specification §14.8): the formats a piece of media is by its media type — a type the catalogue does not name by its subtype less any `x-` — and by its name’s extension and the other spelling of it, either enough, none for a take stem or a dot in a folder; an input’s formats lowercased in order and its size; a format it lists taken, another refused, any where it lists none; a size over the one it names refused, read as mebibytes, and one nobody measured taken; the format judged first; a sound’s recorded length outside the seconds its input names refused (`min_s`, `max_s`), a length nobody recorded taken
`packages/filmopen_render/test/render_request_test.dart`	a render’s request and the shapes the manager, its backend and its producer share (§6.15): the request’s JSON, with the insertion’s own target in it, passing the jobs’ credential check and read back equal, its treatment the batch item’s shape, the key’s id written `key_id`, a negative prompt among the params; what it holds — the target, the inputs, the destination’s server — copied and frozen all the way down; whether it goes to a place, entry by entry in any order; a seed out of range and a place with no project or stem refused when made; what is not a whole request — no model, no target, no origin, an empty target or one without its project, a route or a seed that is text, a seed out of range, an unknown origin, a date that is not one, a destination of no known kind, a quote dated wrongly — read as none; a render the developer page asks for read back as the developer’s; a quote’s basis its cost’s own, an unknown one with no cost and with nothing it buys, what one cost buys and the service’s name for it kept; a resource’s capacity, the person’s number, else its plug-in’s, else 1 here and 2 on a key, a number below 1 none, and the ceiling of three; a quote’s times kept in UTC, so that it is the same quote after its own JSON; a staged output, with the stack that made it and the provenance its take is recorded with, frozen, read back by its reference, and one whose provenance is not an object read as none; a job’s and a pending answer’s receipt frozen, and a job’s outputs; which phases are over; the empty manager holding nothing and refusing each door by its code; the producer’s kind and its saved key, `id`; a render’s id in the form both the jobs’ journal and the insertion keep — the jobs engine’s own, or a random UUID, one of its own for each render — and ids too short, too long or not hexadecimal refused
`packages/filmopen_render_ui/test/render_dialog_test.dart`	the render dialog (§9.3): the Prompt card at a character’s reference, a location’s sheet, a prop’s sheet and a block’s first frame, holding the page’s words, editable and logged `render.prompt.bound`; an edit in the dialog the page’s draft’s, reseeding, a changed word taking the plug-in away, the page’s typing reaching the box and Render sending the draft’s words, the words typed logged in `render.prompt.typed` and `prompt.pluginCleared`; no prompt written by the dialog itself, on opening or on a model change, Generate writing the page’s draft which the box and Render follow; Render held while the card’s Generate runs, saying so, and sending the words written once it ends; a side of another shape locked with the page’s reason, the request without it and the draft unchanged; no page open, or a page in View, the card read-only saying why, its words still sent; a voice and a place of no card keeping the box, a take continued too; with no model a route here can run, saying so and what would, Settings closing it and opening Plugins; where no route is ready, saying no model is ready and why, a model needing a picture the dialog cannot give and another kind’s model not offered, Render disabled, Settings opening Plugins for a missing key too; on a ready route, the person’s computer first, the route’s ways and choices, a value the model’s entry does not allow not offered, a choice that changes the price asking again, a seed out of range holding Render, and Render answering the request frozen — the model, the route and way, the entity’s prompt and negative prompt, the choices, the seed, the quote shown, the captured place, the version, the purpose and when; the price shown and frozen the one for exactly the way and the values chosen, asked again for the way the route suggests and a size the model allows; an answer to an earlier question dropped, the last answer winning, Render waiting for the price; another way giving its choices their own values with no pull-down asserting; a box whose text is no value holding Render, and an emptied one never sent; a number its route allows one value of shown read-only and sent as it is; a value the dialog changes drawn in its box, and an error typed for one way gone with it; a route that cannot say what it offers not ready, reported, and not waited on for ever; a voice sample’s words starting at what the voice says, labelled as words to say, an empty prompt holding Render for a model whose entry names none, and a picture’s prompt at the open form’s own words; nothing overflowing at 700 px; Render available where renders run and disabled, saying so, where they do not; the dialog pointing to the GPU page — one line and Open GPU, which closes it and opens the page — where a server provider is on and no server is live, and neither where none is on, with a server starting, with a stop still owed, or with every provider off and a server still costing; a server started while the dialog is open one more place the model runs, the choice made kept, its price the server’s time; a server chosen that stops giving way to the first ready place, asked again, a line saying so and naming it; with a choice of places left, Render held until the person chooses one; the amended Z-Image plug-in’s ways — Fast’s weights absent and Quality’s there, as on the Salad recipe, Quality offered and chosen and Fast saying why with Render held; Fast, Quality, Fast keeping a size the new way takes, else its own default, Quality’s 1024 surviving the move to 24 GB, each way asked about as it is chosen and no stale size sent; 24 GB on an 8 GB card held with the plug-in’s words, nothing sent and no Settings, while a way missing its files offers Settings, opening Plugins; a way not ready that says nothing of why still said to be not ready under it; a key’s reason naming its platform rather than the route’s label, and the plug-in whose key it is; a grant’s reason naming the platform; a platform the catalogue does not hold said by the label; a route whose platform plug-in is off naming that plug-in; a key the platform plug-in may not use yet naming that plug-in, Settings opening Plugins, and a platform plug-in not installed named by its tag; a route’s choices it names no words for said in the app’s, and turning a priced switch asking the price again; Render pressed twice before the dialog has gone answering one request and closing the dialog alone; GPT Image’s choices — the variant in the catalogue’s words, Variant and Background in the app’s — sent as shown; another route of the same model keeping the choices the person made that it takes and giving every other its own default — a format nobody chose its own, not the last route’s — a background it does not offer dropped, the request frozen on it with those, and a price the last route answered late dropped for the route chosen since; a server that stops giving way to the first ready place with the size chosen on it kept; a character’s voice (§9.1): Generate voice offering voice design alone, starting at what the voice is designed from — `prompts.voice.positive`, else its description — and at what its previews say, holding words outside the model’s bounds with its error, and asking for both; no empty words sent, the help saying that the plug-in then says its own sample text; a line spoken in the voice the character keeps on the route’s platform, its id sent, and with none kept there Render held, saying it keeps none there; a line’s price following its words at the catalogue’s price by the character, frozen as shown; a route speaking in a character’s voice not offered on a location’s place; the film’s treatment (the Project Specification §8.7): its words after the entity’s prompt and its negatives after the negative prompt, and the request freezing what applied — the palette lowercased — with the document each leaf came from; a change to its words the render’s alone, naming no document, a box emptied leaving its leaf out, and the next render starting at the film’s words; a model that takes no negative prompt given none of the treatment’s, and a line spoken or a voice designed none at all; no box and none frozen where nothing applies, and where one applies without words the box the person’s; a folder’s picture taking the project’s, each folder’s that holds it and its own, its open form’s included, asked for with the treatment’s words alone; a folder listed twice taking the project’s and its own, the dialog saying why; a scene’s Style over its folders’ and a change for one render over its Style; the negative words’ help naming their source; a render keeping what applied when it was asked, the treatment changed afterwards changing the next render; the treatment’s primary leaves after the entity’s words and before the treatment’s, in their order and in English, said between the prompt and the treatment’s box as the model is given them, the box’s help saying its words come after them, and frozen with their documents, the older scale frozen and never named, a retry sending the prompt frozen with the request, rendering again naming nothing twice, and no line where no primary leaf applies; the line naming the document the leaves come from; the primary leaves alone no prompt, Render waiting for the entity’s words or the treatment’s; its two boxes at 700 px; a clip that opens on a picture — the version’s pictures its first frame takes, its reference images first and never the archived, the deleted, an address or a format it does not take, the first chosen and another chosen by a tap, the request carrying it; with none, what to add in the error colour and Render held with the same words; the motion prompt empty with its help and an example drawn in the box in italics, Render waiting for the motion’s own words though the film’s treatment gives words, the request then carrying the motion and the treatment’s words after it, at a block clip, a model that opens on no picture starting at the looks, the person’s words kept across models; the clip said to be silent; a clip’s sizes those both its route and its entry allow, the size chosen sent; the row of pictures wrapping within the dialog at 360 and 700 px; a route’s common values said in the app’s words where the route names none — GPT Image’s qualities, backgrounds and formats — and sent as their ids; opened while the plug-ins are read again, Render held with the line and its tooltip saying so — in place of No model can render here where nothing is offered yet — and once the reading ends the model it allowed offered and chosen, where the person chose nothing; a model or a place chosen while the reading lasts kept when it ends; a reading of the models begun before and landing after the next one dropped; a reading that never ends holding Render for no longer than 30 seconds; a reading that ends while it is open adding the models it allowed, the model chosen kept; the reading’s line within the dialog at 375 px and 700 px; the end of a reading on the model and the place on screen keeping them as they are — a value’s menu open staying open, nothing asked again, the value then chosen sent — and a reading that would move the dialog waiting while a menu is open over it, Render held, landing once it closes; a model chosen in a menu a reading landed under found as it is offered now, nothing asserting; Render held until the last reading has landed, a plug-in change while the end of a reading is taken in read in turn; a choice made while the models are read after a reading standing; a reading that leaves no model after a choice saying that nothing runs here; the way, a value and the first frame the person chose kept across a reading and sent; a reading that leaves only the place chosen waiting while the places’ menu is open, then saying where it runs; a reading that says the place on screen in other words keeping it, a value’s menu open staying open and its value sent; a menu opened in the very moment a reading lands not torn down; a hold whose bound passes while a change waits under a menu lasting until the change has landed; once a menu closes on a change that waited for it, Render waiting, saying so, for what runs where to be read again; the model picker’s default (asked once for the place’s kind at the character’s stage) opening a character at Draft on its model, route, way and settings, which Render sends, a setting the route does not offer dropped and logged; no picker, or its route not offered here, opening as a new dialog would, `render.route` saying why; its route not ready opening there with its reason and Render held; a reading that restarts the dialog with nothing chosen landing on it, and no other reading moving the dialog; a character’s sheet naming `@reference-1` offering only edits and sending that picture in the row’s words, the file keeping its token, the first usable picture may be unreviewed and is never deleted or archived, no hidden pick logged; a sheet naming none offering pictures made from words and sending none; a token naming a deleted picture, five pictures where the model takes four and a row with no form each holding Render with its sentence (`render.prompt.tokens.refused`), fitting at 700 and 1200 px; a dialog opened on a sheet without a token whose words gain one, and one opened with a token whose words lose it, holding Render until the words fit the opening’s kind again; a take rendered from `@inspiration-1` continued from the take sending that picture again with its words unchanged, offered edits, `render.final.carry` naming the door `continue`; busy asks observing the 2–30-second delay bounds, the 3-second absent/past-hint delay and a positive 4-second hint, with at most five automatic re-asks per person-choice episode with the chosen way, values and prompt kept, even when its cold answer lists only a default way; that wait shows no not-ready sentence or Settings action, a close or another route cancels its retry, a paid changed-parameter answer keeps choices while holding Render without a price, and an unchanged busy speech answer retains its earned route quote; a ready busy speech way with no route quote retaining its catalogue estimate and freezing that price in the submitted request, while changed values without a ready way retain the existing price hold; a server missing its route key or gateway key uses the required-key sentence without guessing a platform, sends no options ask, disables Render and opens Plugins; cold busy default preserves an explicitly chosen default way’s label, controls and values through retry; not-ready busy answers say the waiting step inline; busy replies do not reset that budget, a new priced person choice starts it again, a held automatic reply, cold busy reply and inspection exception preserve earned Render, options and price for the unchanged episode until a genuine nonbusy refusal, and a noKey issue on the chosen stack opens Plugins; an equal recreated offer during a held automatic ask preserves earned Render and quote through cold busy and exception replies, while genuine changed choices and nonbusy refusals keep their guards; on a dialogue block’s Speech, only the routes that speak in a voice the speaker keeps — not a route that speaks in nobody’s, a ComfyUI one, or one on a platform the speaker keeps none on — the block’s line in the prompt box, read-only and filled, kept when the model changes, read from the scene’s open draft, and the request carrying it with the speaker’s voice id, never another character’s, at the film’s stage, its place the block’s with no spans; changing stack re-settles resolution and duration to the variant, logging render.variant only for changed stacks; character motion clips offer i2v alone and log the offer kind with noDefault while the picker names none; the treatment’s style (§8.7) stored, never added: the line naming the leaves alone, the request the prompt and the leaves, the plug-in never read; at a block’s clip without a kept first frame, Keep a first frame to use it for a clip and each model left out logged with what it lacks, and nothing of it at a block that keeps one
`packages/filmopen_render_ui/test/render_offers_test.dart`	what the render dialog offers (§9.3): the models of the kinds a place takes, by kind in its order and by name, naturally, whose inputs the dialog can give, a voice sample offered speech and not voice design; a place of one kind only the entries of that catalogue `tag`, and a place of none every model; what a model takes and requires, a model with no name named by its id; a choice’s values those the model’s entry allows too, in the route’s order; GPT Image’s catalogue entry allowing every size its adapters offer, the six; variants decoded by string id, only existing root keys replaced whole, absent/unknown variants using the root, and resolution, duration and quality aliases bounding choices; at a block’s clip a route offered only where its platform’s row — the marked one, else every row — maps each block input the model requires, a row naming no `params` stating none; the bundled Wan 2.2 TI2V 5B offered at a block’s clip holding a first frame, silent, and not at one without, handed over as left out with the first frame it lacks; a character’s voice place offered Eleven v3, Eleven v4 and MiniMax’s speech from the real catalogue, none left out; a model left out logged at a place that is no clip with what it lacks, what is given, the kind and the command’s reference, and not handed over
`packages/filmopen_render_ui/test/first_frames_test.dart`	the pictures a clip may open on (§9.3): a location’s reference images, then its sheets, then its other places in the order of its file, a character’s sheets only another place on a location; a picture larger than the input names, as its record measured it, not offered, one unmeasured offered; any picture where the input lists no formats; a block clip’s inputs from its own block, never the scene’s or another block’s, each left out with its bound and reason, a refused favourite giving way to the first, and a voice line only on one block
`packages/filmopen_render_ui/test/server_panel_test.dart`	the servers’ window (§9.7a), opened by a test launcher with the fixture’s clock, and the GPU page’s list after a Deploy: the window checking first, then the GPUs with priority, availability, the whole hourly price, the time of the prices and Refresh, a search that narrows them; the default inactivity minutes at 15, refusing 4, 61 and anything not whole; a provider-declared default and range governing the editor and explicit deployment, inclusive bounds and no automatic deploy, Deploy waiting for a GPU and fresh prices, 44 px; Deploy starting one server with its message, the list showing its state, lease and Stop, which says Stopping; the window closed while a server is asked for losing no stop; nothing overflowing at 700 and 375 px; a Deploy the provider refuses staying in the window in the provider’s words, nothing said to have started; one nobody answered closing the window saying the server is looked for; a quote refused for want of a key in words; Stop’s tooltip once asked; a Deploy refused after its server was made staying in the window, saying the server is listed to be stopped; a server its provider stops listing said to be not listed, with when it stops at the latest, its doubt said once and its Stop kept; the same server past its lease saying it stopped, its doubt not said again; an unsure server whose Stop its provider refuses keeping its doubt, its deadline and its Stop, the refusal in the provider’s words and never as the plug-in being off; a server its provider runs past its lease saying so, never the passed time as one to come, and Stopping once its stop is asked two minutes on; at 700 and 375 px, that line and Stopping without an overflow; a stop owed said, listed past the hour, its Stop asking now; a stop taken and not carried out said; past its lease with its provider turned off, saying FilmOpen cannot ask, the provider still named and the plug-in said to be off; a stop owed with its provider off saying FilmOpen cannot ask, and Stop saying why it asked nothing; Stop refused said once; at 700 and 375 px the lines for a provider turned off fitting; a 33-row catalogue followed by one selected check and one explicit pre-deploy recheck; retained rows, typed capacity/quota refusals and Refresh recovery; superseded checks and rechecks authorizing no deployment; the lease staying legible and read-only while a check or deployment owns its minutes; one shared discovery instant and signal with fresh selected/recheck budgets; held capabilities, catalogue and selected checks ending at thirty seconds; replacement and closure cancelling their operations; stale cleanup never clearing newer state, and a sent deployment surviving closure without discovery controls; engines and model stacks: the stacks those of the engine that fit the GPU, their download and minutes where given, the choices sent and logged, a GPU that cannot hold the stack chosen sending none, the engine narrowing the stacks, a GPU no stack fits saying so, no picker for one engine and no stacks, both fitting at 700 and 375 px; the agreed price: a price changed at the recheck shown with no deployment, a second Deploy at it sending exactly one, a further change asking again, each recheck logged with its decision; a recheck refused for capacity or a failed quote logged `refused` with its code
`test_driver/salad_catalogue_capture_test.dart`	Repeatable images of the real server dialog with SDK fonts, an injected shared UTC clock and a local 33-row catalogue at 1200×800 and 700×800 in English light and dark; unchecked rows, selected checks, a held recheck before one explicit deployment, retained zero-capacity refusal, the exact 30-second timeout and Refresh recovery, and replacement selection with the older answer ignored; exact catalogue/selected/recheck arguments and deployment counts, forwarded gesture controls and the durable unscoped handoff are asserted; cleanup releases held replies and closes sessions inside the widget test clock.
`packages/filmopen_insertion/test/render_takes_test.dart`	a render’s outputs through the insertion (§6.13, §6.15): its takes and its record the run’s, under the viewer’s handle for the plug-in, a `plugin` batch with the run’s `plugin` and `hook`, each item what the run was asked, with its group, no nested provenance and no file name, attached where it was asked from, and nothing it was asked in the journal; a producer’s forged keys (`sha256`, `output`, `group`, `n`) never reaching the record; a render to takes alone writing the takes and the record, attaching nothing, each item with no group; outputs that name no run an import as before, whatever records they carry, and a run named otherwise — a tag that is no tag, another hook, a stem not the tag’s plug-in’s, no record, runs or records that differ between outputs — refused with nothing written; an ingest resumed after a restart keeping the run’s names from its journal, its one record and its takes under the plug-in’s handle, a run with a name more than its three included; a record written before a restart found again under the run and the entries attached once; a plan made naming no run an import after a restart, whatever the outputs say then; a stop recovered after a restart recording what the render wrote, as far as it was written, `partial`, and stopping the render; what it wrote taken back where the restored render hands nothing over, and where the work is not restored at all, the job then waiting for the person; a take written before a restart whose bytes changed left alone and the others recorded, `partialIngest`; a written take the replay cannot read for a moment tried again, never taken for another’s, and both recorded on Retry; a stop landing before a restored render was heard hearing it again, recording both takes and stopping it; a render that says nothing leaving the stop to be tried again, nothing taken back and the render kept; a stop whose version is gone stopping the render and leaving what it wrote; a stop tried again after its own settlement still stopping the render; a record written before a restart standing, and nothing it names taken back, stopped or not; a voice sample’s binding (§9.1): each output of a run into `voice_samples` keeping the `voice_binding` its output gave it — the preview it is — anything else an output says of its entry dropped, a binding a reader cannot read none, and a picture place keeping none; and planned with the job, so that after a restart whose restored render says nothing of the entry the one planned is attached; the treatment a render was asked with kept in each item as it came (§12.2); a replay whose restored render fails, or is no longer held, taking back what the job wrote before the restart and ending with the render’s code; a stop while the record is written keeping the takes and acknowledging the render rather than stopping it; a refused acknowledgement still allowing its durable take to attach, with renderRecordUnsettled and Retry/Dismiss, Dismiss leaving the reference, media and thumbnail in place; a render whose takes were kept before a restart acknowledged after it, and one its producer no longer restores confirmed only with its successful settlement tombstone; without that tombstone, Retry retaining `renderRecordUnsettled`, Try again/Dismiss and the attachment marker without an acknowledgement marker, another submission, output open, patch or duplicate writes; a render into a film with no folder that another film replaced writing nothing, keeping what it made until the person stops it, the stop letting it go; a render into a film with no folder that is closed waiting for it with nothing written, and another film opened in its place ending the job with its outputs kept; a film replaced while the record is written never telling the render its takes were kept, its Stop letting the render go; a render told its takes were kept whose film closed before the attachment and was then replaced offering Dismiss, dismissed and never stopped; a same-film acknowledgement-only retry after viewer or guard changes restoring the original producer once with no start, output listen/open, document or media write, thumbnail put or attachment patch; unverified attachment, another film, missing started-producer authority and invalid source retaining their binding refusals and effects unchanged. Recovery of unverified attachments holds the first media write and refuses it after engine close, so the original attempt ends without writing media before the changed binding is restored.; what the plug-in said (Project Specification §12.2): the shared `metadata` and `metadata_refused` at the record’s top and neither `delivered` nor `error` there, the request keeping its own keys, each fetched item the plug-in’s `n`, `reported` and its own `metadata`, an unfetched output’s item `fetched: false` with its `error` and no `output`, `reported` or `metadata`, the items in `n` order and each entry naming its item’s `n`, no container address in the journal; and a restart after the record whose attaching pass asks the render nothing finding the same record, never `nameTaken`; the entry’s facts — a picture’s measured size over the reported one, a clip’s reported duration and size, nothing where nothing says it, 0 for a still, the stage asked, `unreviewed` on every render output and on no upload, no `kept_at`, an existing entry untouched, the same entry attached after a restart; a block as a target — a clip into a block’s `clips` with the blocks chosen, a soundtrack into its `music` until the scene ends by default, both recorded under their group, a clip’s `until` dropped, the first block of a duplicated id taking it before what it holds, a missing block and a `media` of another shape `wrongShape`, a picture refused by `clips`’ kinds; a lent render’s output, the installed plug-in’s run with what was asked and the result’s facts, taken in as the run’s; the place the render ran kept in the record’s `request` where the run names one, none where it names none; a render’s clip measured for sound after the replay writes it, `audio` on its item and its entry; an unavailable probe `no_probe`, a failing one `failed:<code>` logged at warning with its file and message, the clip imported either way; a stop whose version is gone logs `insertion.settleSkipped` with `versionUnavailable` and the stem
`packages/filmopen_render/test/render_manager_test.dart`	the render manager over a stand-in backend (§6.15): a cancel answered `unknown` followed by one collect, which tells: a provider’s confirmed end stopping the job at once, finished outputs let go, a pending reply or an unconfirmed failure staying `stopUnconfirmed` with the newest receipt and a Retry then reading the confirmed end, a collect or a cancel that throws logged as `render.cancelFailed` at its stage, a cancel answered `cancelled` collecting nothing, and one answered `finished` collecting once, each with its log lines; every operation of a render told with its values, decisions and milliseconds — submit, admission, send, finish, acknowledgement, write — and a refused journal write reported with the error and its message; a render run, its outputs ready, taken in and let go; each resource as many at a time as its capacity and three in all, in the order asked; work a service holds asked about again at its hint, kept to at least a second; a failure keeping its code and never sent again; a queued render stopped never starting, a call in flight ended as cancelled, held work cancelled at its service with what it had finished collected and let go, and ready outputs let go; a restore keeping a queued render, calling a call in flight `interrupted` and never sending it, asking about held work and keeping ready outputs; the journal holding the renders not over and the newest of those that are; `watch` until a render is over, `noJob` for one not held; the producer relaying phases, handing the outputs over and taking them in, a failure’s code, and a run restored only onto a render the manager holds; a job’s journal form read back as itself, and its facts read back, carried by the next phase and frozen; a backend that keeps facts told by its interface; and the money rule — an intent the journal did not take never sent, a stop or a close while it is written sending nothing, a restored render waiting unsent until it is watched, a restore that runs nothing before the application’s own work and only once, what this build cannot read logged and dropped, its outputs not held, a journal of another version — older, newer or with none — set aside and a fresh one started, the current version restored as it was, a stop and an acknowledge letting go once, and renders that are over leaving memory as they leave the journal; a stop cancelling by the new receipt its awaited call answered, and after a collect that succeeded cancelling and collecting nothing; a render asked for, and a producer’s run restored, waiting for the journal to be read, nothing written over it; nothing asked for during a restore running before its work before running is done; a queued render nobody followed for a week given up, never sent; and a close before the journal is read writing nothing over it, a failed wait before reading still reading it; a failure a paid service took a request of marked `charged.<code>` by the producer, the flag kept on the job and in the journal and refused where it is no flag, and a stop never marked; a stop that ended the fetching of what a finished render made cancelling nothing and fetching nothing again; a render on a server holding that server from its sending to its outcome, between the questions asked of it too, let go at a stop and a close, and one on this computer holding none; let go when it fails; one restored taking its claim at its first question, its server read back by then; a failure handing on the provider’s message as its facts keep it under `request.error.message` — 500 characters arriving whole, never cut again — and none where the facts keep none; each step of a Stop told to `events` as `render.stop` — requested, accepted, completed with the job’s phase, a Stop of an unknown job refused `unknown` — with the milliseconds; `pokeNow` asking about a held job at once and nothing more once its outputs are ready, sharing a question in flight and waiting for it, and asking nothing for an unknown job, one with nothing held or a restored render waiting for a person (`stopUnconfirmed`), each said before it waits as `render.poke.start {found, branch}` and at its end as `render.poke {found, inFlight, reason, ms}`, the empty manager’s completing; a render run’s cancel answering from the manager’s state — held after a stop left unconfirmed and after one refused while the render finishes, over after a confirmed stop — each logged as `render.stop {outcome: answered, accepted, over, reason, ms}`
`packages/filmopen_render/test/keeper_test.dart`	the keeper over a stand-in host that keeps at prepared, answered and once per output (§6.15): the keeper attached at construction; the facts on the job and in the journal as `keep` returns, a second keep replacing the first whole, a staged output and its facts in one write, a keep for an unknown render doing nothing, every keep published; a journal refusing one write, armed just before the keep under test — at prepared nothing is sent, at answered nothing is downloaded, at an output the next download is not made, the first call ending `failed` with `journal` and a collect `collectionUnconfirmed` with Retry, what was journaled kept; a refused pre-effects settlement save applying nothing and publishing no end, the facts present; the settlement prepared once and applied once across two restores cut between its save and `settle`; the facts reaching `settle` as given, the settlement the prepared payload unchanged; an immediate completion one row; a failure after a staged output holding none; a restart after a terminal answer sending nothing and asking at most one collect; a receipt-less crash between two downloads restoring `interrupted` with the first output held; the queued write durable before any send; the producer’s `noManager`, `journal` and `noJob` as `JobUnavailable`
`packages/filmopen_render/test/ack_regression_test.dart`	acknowledgment waits for its durable journal write before releasing staged outputs; repeated and concurrent acknowledgments perform one effective cleanup, while refused writes, lost cleanup replies and shutdown remain recoverable through Retry and restart; unfinished cleanup protects its references without holding an execution slot, and completed history remains bounded
`packages/filmopen_render/test/step4_regression_test.dart`	each submission of one request is its own job, the backend told its id beside the request as given; queued Stop removes runnable work before its journal write yields; an unreadable journal refuses work while an unread entry is dropped and work proceeds; applied settlements and refused markers recover without repeating their effect; transport collection retries after 1, 2 and 4 seconds with its bound preserved across restart, then requires attention, while canonical answers clear uncertainty
`packages/filmopen_render/test/carried_entries_test.dart`	an unread render entry — a future phase, or the `bindingChanged` phase an earlier build saved, its receipt never collected — is dropped beside a readable queued, rendering or ready render, which runs: no view, nothing managed or collected for it, not written back, and an unknown envelope field is not written back either; a readable unapplied settlement, acknowledgment cleanup and unprepared end complete beside one; a restored end writes the journal twice, its prepared payload before settlement and its applied end after; each entry dropped is logged with its saved id, phase, the whole entry and why, and a restore logs its start, each job’s decision, how many it dropped and its end
`packages/filmopen_plugin_host/test/resource_scheduling_test.dart`	the actual host and render manager share local capacity across models while independent paid work and options advance; queued Stop sends nothing; queued calls preserve their captured provider and resolved server through configuration or manifest changes, refusing invalid, absent or newly ambiguous routes; restored receipts count every holding without resubmission, preserve historical display labels, and ambiguous or missing local routes share a conservative capacity-one fallback; a queued render whose route now calls another platform refused `binding-changed`, `render.call.refused` naming the check `captured` and both platforms
`packages/filmopen_render/test/boundary_test.dart`	the render queue’s boundary (§4.1, §6.15): its pubspec depends on the jobs and the format alone, read past blank lines and comments, and not on Flutter; its files import nothing else of FilmOpen and only the libraries every platform has, never `dart:io`
`packages/filmopen_render/test/server_sessions_test.dart`	the servers a person starts, over a stand-in provider (§6.15): the default lease of fifteen minutes with inclusive five-to-sixty bounds, or a provider-declared default and inclusive range, with invalid leases asking for no deployment; a quote with its offers, their whole hourly price and its time, starting nothing; a quote older than five minutes, a lease outside the provider’s range, an offer not quoted, a receipt that cannot be kept, a second start while one is asked and a provider turned off refused before anything is asked; a deployment’s name kept before it is asked for, its usage’s first record at its lease’s estimate; a lost answer looked for by name and never asked again, one that made nothing failed with nothing to stop, one refused after the server was made what the provider lists; the lease renewed while a job holds it or a start is supervised, for at most the start’s cap of ninety minutes — renewed at minute 46, not renewed when due at exactly ninety and said once, a held start renewed beyond it —, never while nothing holds it; a lease run out expired, its usage ended with its minutes; two servers’ leases apart; a stop `stopping` until the provider says stopped, a refused one leaving the server as it was; a restart reconciled with nothing started, a deployment being asked failed where the provider lists none, a server found with its stop; a session’s JSON; an unanswered deployment looked for three times before it is taken as never made, and one listed after all followed again with its stop and usage; a refused deployment the provider made keeping the provider’s words through its list; a lease run out with no instance expired whatever the provider calls its state, a server with no instance not running; two deployments of one provider at once, the second busy; a start found at the provider not kept alive; what could not be kept reported; a lapsed lease ended at its deadline when noticed an hour late; a start its provider refused not kept alive; an unanswered deployment listed after all saying nothing of the answer that did not come; a session’s engine its provider’s one engine where its status names none; a server its provider stops listing unsure and never taken as stopped — its stop kept, no render sent to it, followed again once listed, and expired at its lease’s deadline, its usage ended there, its doubt cleared — and a server asked to stop that its provider lists no more stopped; an unsure server looked for at once, then not again within five minutes, and past its lease’s deadline kept while its provider’s list goes unanswered; a lease its provider overruns left to the provider for two minutes, then its stop asked once and the server ended when it stopped, not at its deadline; one a job holds not stopped until the job lets it go; a stop its provider refuses asked again five minutes on, not at every round, its provider listed again only then; a lease that ran out while the provider still starts the server owing its stop — asked at once, again five minutes on — and the server followed again when an instance runs after all, stopped, its usage’s end written again; a stop owed no more once the provider holds the server stopped; a stop the provider took and did not carry out asked again five minutes on, and one it says it is carrying out never asked again; a server past its lease offered for no render; past its lease with its provider turned off, asked at the same pace and not logged at every round; seen running past its deadline and then stopped by its provider, ended when last seen running; followed again after its lease ran out, counting what it ran and not the time with no instance; an owed stop its provider refuses said by its code, looked for every five minutes; a provider that counts no instance read by its word, a server running past its lease overrun and stopped two minutes on; followed again, its stop refused, then found stopped after a restart, keeping the minutes it ran; a word its provider does not know, with no instance past the lease, owing the stop; followed again soon after an owed stop, asked again only five minutes after it; a person’s Stop beside the application’s own adding nothing, and on a stop owed asking now; held by a job past its lease, listed every five minutes; an owed stop looked for every five minutes while its provider’s list goes unanswered; past its lease with its provider turned off and then on again, the refusal said no more and its stop asked at once; an owed stop refused keeping the refusal on its row until its provider holds it stopped; a stop owed with its provider off refused when the person asks; a provider’s name kept in the journal across a restart; with its provider turned off, offered for no render and its row drawn again at every look; a server found at its provider past its lease stopped as well; discovery instant and cancellation forwarded unchanged; spent and precompleted-cancel scopes dispatching nothing; terminal scoped capabilities failure never asking for catalogue, ordinary unscoped fallback retained; held backend timeout/cancel and late outcomes preserving the first terminal code; model stacks: an answer without stacks reading none and one with them each, a row without its required members left out, `fits` by VRAM, both logged; a deployment with no choice sending the three arguments; the chosen engine and stack sent, kept through adoption, the journal and a restart, logged with the answer; a status naming no stack keeping the chosen one and one naming a stack winning; an unreadable capabilities answer and a deployment refused before the ask logged with their codes; a spent discovery’s and a kept read’s capabilities lines, a thrown quote’s and a journal’s refusal with the error’s words; past its deadline, unconfirmed — its provider off, its list unanswered, or stopping for ever with an instance counted — its phase kept and its minutes stopped at its deadline, or `askedAt` plus its idle minutes, said once; confirmed stopped three days on after a restart, or stopped or listed no more after an unanswered list in one process, or answered stopped by a list asked before its deadline or by a Stop pressed past it, ended at its deadline; a list’s values logged whole, and a list that throws logged with its stage and words, then thrown; one its provider still runs counted on, and stopped by the person ended then; Stop asked again past the deadline, and every stop’s ask, answer and refusal logged
`packages/filmopen_insertion/test/insertion_contract_test.dart`	target/place JSON round trips through `project` with the Dart `projectKey` and place identity preserved; canonical destination identity independent of insertion order; durable source descriptions keeping each input’s kind, extension, name and path or address in order, and no producer request; deep snapshots of producer requests; the binding’s captured context, its identity fingerprint changed by a different viewer and not by the locale
`packages/filmopen_insertion/test/insertion_submit_test.dart`	`submit` (§6.13): a submission answering its job’s id; a job that ends before `submit` returns still answering it; a refusal before binding thrown as `insert` throws it and logged with its code; `insert` logged as `submit` is, its refusal too, and telling its accepted id once; the default service refusing
`packages/filmopen_insertion/test/insertion_service_test.dart`	a session upload records its take and batch and attaches its reference; a film switch during a copy leaves output in the captured film; a completed durable job restores its existing job, batch, take and reference without a second put; unsupported input refuses before any job or write; jobs at the same clock instant reserve distinct names; the durable journal carrying each input’s name and address as they are, each checkpoint logged `insertion.journal.write` with its stage and the record; a job asked while the settings are read again refused `settingsLoading` at once, logged `insertion.bind.refused` with the target and the source, nothing submitted, and bound once asked again; measured MIME and image dimensions survive replay; `media.imported` naming the file, its source, bytes, SHA-256 and thumbnail, and `insertion.upload.imported` its items, neither repeated on attachment retry; stopped by the person or by the service closing, its log saying which by its id alone; binding and completion never repeat the callback, Stop through its callback id survives a held engine submission, and a throwing direct observer leaves one accepted upload, take, batch, attachment and patch completing normally; a sparse file of the web’s cap (64 MiB) and a byte ends its job `tooLarge` with the file’s name as its `displayName`, logged with its path, size, cap and stage and `insertion.upload.refused` with its code, name and message, nothing written; a producer’s output past the web’s cap ending its job the same way, and on the desktop one past the old 2 GiB not refused for its size; a link that sends no bytes ends `empty`, `media.importRefused` naming its address
`packages/filmopen_insertion/test/insertion_lookup_test.dart`	`jobView()` (§6.13): an unknown job no view; the default service knowing no job; each logged
`packages/filmopen_insertion/test/concurrent_production_test.dart`	held local A/B/C and independent D in one film, Stop B before execution, unrelated upload while A waits, eight-observer admission and FIFO ninth job, and a held allocation section while other observers and another film advance with prompt Stop acceptance; a replacement service waiting for the same film section after zero-grace close, with ended attempts fenced before writing or acknowledging; producer output held back when its session closes or is replaced while waiting behind another render’s mutation, then reused without another producer on reopening; a render’s output beside an upload’s allocation keeping its own batch; controlled allocation across equal/different bytes, targets and groups, partial records keeping each output’s place, never renumbered, refused-record own-job rollback preserving sibling media and document references, interleaved upload and disk refusal, captured viewer, duplicate completion and attachment retry without another producer; a gate waiter exposing waitingForFilm with Stop while an occupied mutation remains protected
`packages/filmopen_jobs/test/restore_binding_test.dart`	explicit restore during a published wait preserves the active binding, then refreshes it after execution-claim release before an accepted attachment retry
`packages/filmopen_insertion/test/producer_settlement_test.dart`	immutable pending source/target payloads and provenance, exact ordered queued/working/collecting pairs, verified attachment, failed acknowledgements and uncertainty without false markers, and media restarts before the settlement effect or after it but before its marker; a durable idempotent accepted-and-released result ledger proves one effective settlement; verified complete media attachment despite refused acknowledgement; historical attachment markers make restart Retry acknowledge alone without reapplying later person edits; today’s refused done repeat and a confirming idempotent ledger, Dismiss preserving every attached reference, partial ingest remaining unacknowledged, Stop ending cancelled with uncertainty and refreshing its kept batch into the captured film, and media restart after the patch before its marker; a restore that fails, one refused (`noJob`) and a producer missing after a restart each logging `insertion.acknowledgeUncertain` with its reason and, where there is one, the cause’s message
`packages/filmopen_insertion/test/insertion_publication_test.dart`	a directly submitted job’s queued row shown by `jobsFor` and published on `views` while the engine’s answer to its submission is held (§6.13)
`packages/filmopen_insertion/test/concurrent_restart_test.dart`	durable restart before admission, between start intent and recovery, during observation, after completion while awaiting another render’s mutation, and through lease takeover; recovered observers remain bounded and ended attempts cannot mutate. Observable polling has a 60-second deadline checked between ticks; each tick and the four completer waits have separate 60-second timeouts for serialised film mutations. The eight-observer restart test has a 120-second total runner budget.
`packages/filmopen_jobs/test/lane_capacity_test.dart`	longest-prefix capacity, exact override and unchanged default; a real-engine start-write failure after its queued put retaining the accepted job id and binding, then starting that job once on a later tick, even when the diagnostic observer throws
`packages/filmopen_insertion/test/insertion_attachment_test.dart`	completion only after an accepted re-read satisfies the reference postcondition; a writer success whose re-read loses the reference remains unfinished; stale attachment retry without another put; closed-film waiting and Attach again after the same film’s restore, in the session or after restart; partial producer results attach their successful subset and retain the missing-item outcome; wrong-shaped destinations and another author’s file are unchanged; captured viewer and guards still govern attachment; a job’s outputs landing as entries that name their record’s stem and item, the record naming their group; a job to no group recording none; each attachment run in the zone its job was submitted in, not where a tick found it, a person’s job behind an automatic one having none
`packages/filmopen_insertion/test/store_problem_test.dart`	a namespaced store failure survives availability and put through `StoreProblem`, with no insertion dependency on Drive and no media written
`packages/filmopen_insertion/test/adversarial_restore_test.dart`	reopening leaves a waiting attachment to the person, nothing acting on its own, and Attach again attaches it; the opening snapshot survives delayed initial restoration; a retained binder invoked on later takeover waits for a closed or different film, then reuses its original take and batch on Attach again after reopening; opaque place keys and unrelated kinds are ignored, including an unrelated job whose JSON place names the same film
`packages/filmopen_insertion/test/adversarial_cancel_test.dart`	a stop refused by the real journal neither cancels the producer nor ends observation; lease loss does not cancel external production or permit stale attachment; accepted stop acknowledges while producer cancellation is gated, then invokes fenced cleanup cancellation exactly once; a producer whose cancel answers that it still holds the work leaves the job waiting `stopUnconfirmed`, `insertion.cleanup.start` logged before the producer answers and `insertion.cleanup` with `stillHeld` after, and its Retry reuses the same run and places one item, acknowledged once; Dismiss removes it, nothing placed; a restart between Stop and Retry restores the same run from its recovery and places it once; a Stop after that Retry asks the producer again
`packages/filmopen_insertion/test/producer_codes_test.dart`	producer state/failure codes reach the view, a failure’s marked as the producer’s own (`producer.<code>`) whatever the code says, a charge kept apart, a stop staying the job’s `cancelled`, `producerFailed` a failure with no code, and the insertion’s own codes no producer’s
`packages/filmopen_insertion/test/replay_checkpoints_test.dart`	a producer’s outputs: every ingest journal boundary before/after commit replays the same takes and batch; source opening follows its write checkpoint; lost original metadata is not invented; partial replay preserves its settled subset; the record before the settlement — no checkpoint settled while the record is missing, its items numbered with the place’s group; a record that cannot be written rolling every output back as `recordNotWritten`; a restart between the files and the record writing it where the inputs are there and taking every output back where the original names are gone; a producer’s partial ingest whose record fails keeping nothing; a crash after the record never trying a failed item again; a stop before the record keeping a producer’s outputs recorded — its first alone as `partial` when stopped between them — or keeping nothing where the record cannot be written, and a stop asked while the record is written stopping the attachment only; a record not written logged `insertion.recordFailed` with its stage, the job’s checkpoint and the exception’s type and message
`packages/filmopen_insertion/test/direct_import_test.dart`	a person’s file by the direct road (§6.13): one checkpoint, `attaching`, between the submission and the end, its source opened once; Attach again after a refused attachment attaching from the checkpoint without importing again; two imports in flight together, the first’s write held, never taking one batch id; a clip measured for sound once after it is stored: `audio` true or false on its entry and its item, absent without a probe, on `unavailable` (`no_probe`) or on a failure (`failed:<code>`, `media.audio_probe.failed` at warning with the file, the code and the message, the clip imported), `media.imported` naming the result, its reason and its time
`packages/filmopen_insertion/test/import_cancel_test.dart`	a stop between the chunks of a file of eight read chunks on a temp folder keeps nothing of it — no take, no temporary — logged `media.importCancelled` and `folder.write.cancelled` at info, nothing in `written`; a stop in a later file of a batch takes back the files it finished and their thumbnails; a stop as the last put ends is taken back by the check after the put, file two never started and no batch; a stop mid-copy into a session copy publishes nothing at the path
`packages/filmopen_insertion/test/hash_worker_test.dart`	the worker’s digest equals SHA-256 over 3 MiB of chunks and the worker ends with it; a worker disposed mid-stream ends; an import of a file of three read chunks hashes every byte it stores once with one chunk in the hasher at a time, logging `media.hash.start` and `media.hash.done`; a stop mid-copy ends the file’s worker, logged `stopped`
`packages/filmopen_insertion/test/local_read_test.dart`	a local file is read in chunks of `localReadChunkBytes` (4 MiB): a file of two chunks and a byte in three chunks, every byte in order, `media.localRead.open` with its path, chunk size and reason and `media.localRead.end` `complete` with its chunks, bytes and ms; a reader that stops after the first chunk ends `cancelled` with one chunk; a missing file ends `failed` with its error, and the stream answers it
`packages/filmopen_insertion/test/import_responsiveness_test.dart`	64 MiB imported from a temp folder while a 10 ms timer ticks: more than one chunk, the stop read for every chunk, and the largest gap between ticks under 50 ms with the hash on the worker; the inline hash’s gap printed as the baseline, not asserted
`packages/filmopen_insertion/test/import_progress_test.dart`	two files of one selection give one rising fraction of the whole selection, never a reset, a tick in the second file, ticks at least a second apart, one `media.importProgress` per publication; a file copied under a second publishes exactly 0 and 1; an upload’s fraction reaches its job’s view; a fraction queued behind a Stop’s write (the Stop asked as a tick is logged) keeping the view on `stopping` with no Stop, the job ending cancelled, its `insertion.journal.write` saying `reason: stopping`
`packages/filmopen_insertion/test/film_closed_test.dart`	a film closed while its upload copies logs `insertion.filmClosed` naming the live upload, another film’s close names none, and the upload runs on to its end
`packages/filmopen_state/test/insertion_environment_test.dart`	synchronous binding refuses closed films and incomplete settings; the viewer captured and patch success returns the accepted re-read; film opening waits once for ready settings, refresh/construction do not restore, a closed pending opening is not restored, and a returning place subscription immediately includes existing work; the application service observing eight producers in one film with the ninth queued; the captured binding measures a clip’s sound with the timeline’s engine; closing the film tells the service which film closed, and an opening closes none
`packages/filmopen_state/test/media_provider_test.dart`	`mediaStoreProvider` supplies the project’s `MediaStore` directly even when an old manifest `data` field is present; no open project yields no store
`test/insertion_navigation_test.dart`	on a character whose Motion clips place the file holds: leaving with an unsaved edit during import preserves typing and attaches the result; return during import restores progress and disables the place’s own Upload; an attachment made stale by a change the app has not seen — made once the next page’s look, written by opening its preview, is in the re-read index — stays visible with Attach again; switching films keeps output for the original film’s Attach again on reopening; refused attachment never announces Added; an addition’s refused action said in an addition’s words, This addition could not finish., never the target’s, and cleared by a later accepted dismissal
`test/media_section_test.dart`	the media card on the whole app, through its places’ Upload: a picture fetched through the URL door against a `MockClient` becoming a tile in Reference images, an entry in the file, a thumbnail in the project folder and a batch record; a second upload going before the first, with a batch of its own, and the first still there; a clip going into a character’s Motion clips, always shown, wearing the stock picture, with nothing put in Reference images and no `preview` proposed; no add tile on somebody else’s version and none without a handle; a tile opening the picture at full resolution and closing; the media keys gone from Other attributes; the Takes tab listing the upload; Compare pairing the card and a `<` adding a reference without removing one; Browse adding two real files at once through the sheet’s own door with the picker injected, both reaching the file in one batch; a project source that cannot write hiding the add tile and showing the page’s read-only reason; a refusal staying inline under the place in the person’s words with nothing written; and no overflow at 700 and 532 px in dark
`packages/filmopen_media_ui/test/player_controls_test.dart`	the row a person presses, pumped without a decoder: one control named for what pressing it does next and calling back once; the time as where the file is over how long it is; a drag asking for no seek until the finger lifts and exactly one then; the thumb staying where it was let go until the player arrives, and given back after two seconds when it never does; a file of unknown length with the bar disabled, its reason in the tooltip and its clock still counting; the clock named `player.clock`, its label the time; and the row at 700 px in light and dark and at 1200 px in light and dark, on the app’s theme
`packages/filmopen_media_ui/test/player_rules_test.dart`	what the player draws, as arithmetic a check can reach without a decoder (`player_rules.dart`): the ratio a file that reports none is drawn at, whether there is anywhere to seek to, whether the file has run out — the last fifth of a second counting as the end — whether it is playing as the control shows it, a file that has run out never so, and the clock, `m:ss` under an hour and `h:mm:ss` from exactly one. The end and Play from the start are proven here alone: the acceptance walk never plays a sound to its end
`packages/filmopen_media_ui/test/provenance_test.dart`	the provenance strip’s words from the batch item alone: the model on its platform with the cost to the cent, a cost the record does not say left out, a model without a platform keeping its cost, a model alone, Imported for an import, nothing for an item that names no model or media no record names; another author’s record said on one line, without its controls or direction marks, and cut where no model’s name is that long; a model the bundled catalogue knows named as it names it, the platform and a model it does not know as written, and the id until the catalogue is read; the tooltip’s lines (§6.9): when it was rendered, each change with its time — the document, a block by its number, a source by its stem, the coverage with none — when it was kept, each time in the person’s own clock, each key the file and its record disagree on and none that agree, and nothing where nothing is known
`packages/filmopen_media_ui/test/provenance_test.dart` (the stage)	a render outdated by the stage said under when it was rendered, and nothing logged, since a tile asks on every build
`packages/filmopen_media_ui/test/media_tile_test.dart`	the one tile: as wide as a row narrower than one tile, so square in a Compare column, the narrow and the full edge elsewhere; its label the name, the kind, the marks, a note’s presence and the strip, a blank note being none, and a note’s mark; a job settling on it said with the tile’s words and drawn as a small spinner, its badge alone over the picture, no veil
`packages/filmopen_media_ui/test/file_kinds_test.dart`	the file dialog’s filter: a picture place’s extensions alone, `other` adding none; a clip place’s, a sound place’s, and all three for a place of every kind
`packages/filmopen_media_ui/test/viewer_test.dart`	the viewer saying the provenance strip’s words and the entry’s note under the picture (`player.note`) where a place gives them, and neither where none is given; the strip, its add tile and the old upload sheet gone from the package
`packages/filmopen_forms/test/media_card_test.dart`	keeping carries the preview batch’s model; the media card on a fixture film: a character’s five places in their order — Reference images, Character sheets, Voice samples, Inspirations, Motion clips — always, and no Add a place…; a location’s three, with its sheets and Inspirations and no voice; a group the type does not list kept in the file, not shown, and logged once as `media.places`; a `preview` no entry names as a tile of its own; copy-left’s one row over `media` and `preview`; the last look never written as the card is built, the marks staying until a medium is opened; opening a new medium writing it once, the marks then gone and a second open writing nothing; the tile menu’s Open writing it as the tile does, and a sample opened in the voice panel too, its decision logged; with no look yet nothing marked and the first open writing it; nothing new since the last look writing nothing, opened or not; never on a read-only project, and nothing marked there; a project with a cover and no look opening with nothing written, its cover opened writing the look; a character’s loose preview and an outfit’s picture, opened, each writing it; each open logged as `media.visit` with its cause, the medium opened, its places, its newest media, its decision and its reason; the delete flagging the entry through the draft with `preview` cleared, settling it, and only then deleting the viewer’s own take’s file, and stopped, the file kept, by a draft that cannot be saved and by a file that changed meanwhile without the flag, each said, and by the page gone while the flag is written, its trail ending refused as `page-gone` with its time; the card at 375, 560, 700 and 1200 px in dark, every place’s tiles and buttons measured inside the view; Retry after a draft that could not be saved and after a file that could not be removed, each finishing the delete once it can; the voice panel (§9.1): the previews waiting, an uploaded sample being none, Use this voice asking first, in words true of every platform — the keep may take a voice slot — logged as `voice.keep.wording`, and sending nothing on Cancel, then keeping the voice through the plug-in that designed it and writing the choice in one change, the other preview then first; a save acknowledged whose write fails keeping its id with Retry write, which sends nothing again and writes it; a save acknowledged after the page was left written into the file it was kept for and no other, and its refused write logged as one; the plug-in’s own words for a save it could not make, nothing written; a save whose answer was lost said to be of an unknown outcome and one refused before it went said not kept; a sample marked as in use but kept as another voice said so; a MiniMax design on fal’s one preview shown and kept as the voice its generated id already is, logged start, saved and kept; in view mode Use this voice disabled, saying why; Use this recording offered only where a stand-in design row declares `keeps_recording` on an enabled plug-in’s voice platform, and only on a live, unarchived upload with no binding, its offer logged once; its question naming the chosen model’s clone price, or that the price is not known where the row has none, with the model’s pull-down and the optional words, then keeping the recording through that model’s plug-in with the model, reference, name and description and writing it on that platform with its words, its trail logged; its failed write kept with Retry write, which sends nothing again; the question cancelled and dismissed each logging the name, words and model entered and its time, nothing sent or written; the recordings and the question at 375, 700 and 1200 px in light and dark, nothing overflowing, written as pictures where `FILMOPEN_CAPTURES` names a folder; at 360 px in light and in dark, nothing overflowing; a Prompt card under the title of each place with a prompt kind — a character’s pictures, sheets and voice samples, a location’s pictures and sheets — above its tiles, none above inspirations, motion clips or a project’s cover, and none in a comparison
`packages/filmopen_forms/test/analyze_action_test.dart`	Analyze on a media entry’s own menu (§9.3), with a harness whose write access is `PageAccess`‘s, ownership included, and a plug-in runtime whose catalogue, notification, readiness and answers the test sets: one registration per place while any card shows it, passed to the card that stays in either order and gone with the last, one working item throughout; a card that goes under an open review dropping its analysis quietly, and one that goes while another stays stopping its own call at once, the registration kept for the other, which starts its own; applying to a character’s pictures and recordings and a project’s or a folder’s pictures for their look (`describeStyle` with the project’s and the folder’s scope), never a sheet; each link of the chain a subtitle of its own at 1200 and 700 px, nothing asked and no check started; the reason said of the analyzer that takes the file; several analyzers a choice by name, the one chosen asked again at the choice; a draft dirty, failed or saving holding it, the click itself refused; in ordinary mode no menu on a read-only project or the library and the action refusing, in development mode the library’s menu holding it with Plug-ins cannot run on this version.; the entry clicked the one analyzed, named in the review and on the line while it works, at 1200 and 700 px; a recording asked as a recording; Cancel while it works asking the plug-in to stop and freeing the place, the review naming the analyzer and following the host’s progress, Close once nothing can be cancelled; an analysis dropped where the analyzer turns off, the entry or the version change while it works, and a proposal dropped where the analyzer, the draft or the file change while it is reviewed, nothing written; the catalogue’s notification dropping it only where the analyzer’s own description changed — gone, its version, asking for consent (built off, as the registry makes it), off, unable to run, its interfaces, its grants, a grant’s slot, its own keys, its hosts, the plug-ins it calls and what they spend, the AI — each with its own sentence on the review and the line, the call asked to stop; a notification changing nothing of the analyzer — the form’s autosave just before the click, its description’s words — keeping it, Update then writing it; the analyzer’s name in that sentence on one line and bounded; each failure from its code in a sentence of its own — `refused` for a grant, a key, the key store or the platform, `noProvider`, `badArgs`/`kind`, `notAvailable`, `notFound` told apart by the analyzer kept, `disabled`, `stale`, the media missing, too large, not what it says, changed or of a type not taken, a plug-in called on missing, off, unable to run or not offering what it was asked, the key changed under the call, and a reason this version does not know said in general words, a plug-in’s code, and one cleaned to failed, a key’s or an address’s shape among them — never the message on screen, while `analysis.failed` logs the code as it came, the reason, the message or the answer, and the sentence said — kept by the line and not overwritten by a later change; the proposal shown, each changed field named with its whole new value and what it held — a value of over four hundred characters read to its end at 1200 and 700 px — nothing written however long it is read, Cancel leaving file and draft as they were; Update this version writing once through the draft, nothing but the analyzed leaves changed, the write handed back and adopted; an answer naming the voice speech uses, the sample in use or a nested sample binding refused whole, the file’s bindings kept; a draft changed after the click refusing it, the typed change written as typed; a file changed on disk refused as stale, said in the review and on the held button, the save status able to re-read; a refused write kept for Retry after the review is gone, written once; another author’s version running the analysis, saying from the start that it is not the viewer’s to update, and offering only Update a new version, with the fork icon, at 1200 px light and 700 px dark, inside the view; edited by hand: the tree opening the changed leaves’ branches, a value changed there listed and written as edited, once; the text read at Update — a duplicate key, a key that names the file, a binding, a missing name and nothing changed each refused inside the review with both buttons held and the sentence as tooltip, nothing written —, at the switch back to the tree likewise, a text that reads listed there; Cancel or a step back after an edit asking first, kept or discarded, nothing written, the discarded text’s words logged as typed, an edit put back asking nothing; a prompt’s words, another field or a value applied in the tree logged with the leaf’s new value, a key holding a dot keeping its words in `analysis.edited` and `analysis.discarded`; nothing closing the review while it writes; a key a new version writes for itself holding the fork, said inline, Update this version free; a valid text written as typed at 1200 and 700 px, light and dark; as a new version: on Bob’s version one write of a version — Ann’s next, as edited, `forked_from` Bob’s, the bindings as held —, Bob’s file untouched, her pick, the page on it, the message naming the fields and the new version; on her own both buttons, her version and its draft untouched; a refused fork — an edit that does not hold, then Bob’s file changed since the click, stale — creating nothing, the commentary file and the selection unchanged, said in the review. An answer naming a leaf beside the projection’s refused at its path through the existing sentence, `analysis.failed` carrying the answer whole.
`packages/filmopen_forms/test/analysis_proposal_test.dart`	an analysis’s proposal edited by hand and checked again (`revalidateProposal`): its leaves in the analysis’s order; an edited value a changed leaf, one put back none, all put back nothing to update; a key removed and a value become an object; every key that names the file, `epoch` only where the filename carries one, a project’s `forked_from`; a binding changed, removed, or gone with the voice, the sample in use changed, one added on a leaf or as `null`, one changed in a list item, one moved under a key that spells the same dotted path — each refused, one left as it was passing; the format’s own refusals with the writer’s reason; a refused edit still naming what it would change
`packages/filmopen_forms/test/analysis_proposal_test.dart` (who wrote a prompt)	a describer’s prompt credited to it where its words changed and never stamped by the applier; `creditChangedPrompts` crediting words rewritten to their new writer, or clearing it for a person, the `writer` id removed either way and kept with unchanged words, each change answered with the pair it held; a prompt’s writer and time no field of the review
`packages/filmopen_forms/test/import_review_dialog_test.dart`	the review of an import on an in-memory film (§9.3): an update, a fork of another author’s version and of the library’s, a creation by its own name, landing unlisted, and a refused nameless one by its type and tag with (new), each in words, with Was:, a removal, the pick-changed, out-of-scope and conflict notes and the document’s notes folded, no code on screen, at 1200 px light and 700 px dark within the width, Apply 44 px; Apply writing through `applyImportProposal` and closing with how many changes were written, the proposal gone; the message naming the version the page moved to, and the count alone where it did not move; Discard writing nothing, answered as discarded; the title naming the plug-in by its tag’s catalogue name; an outside edit redrawing the review, nothing written over it, then written; a refused write keeping the review with each outcome and Apply again writing what is left; a file changed under the import’s own write said as the person’s edit; Apply held where nothing is left or nothing can be written, and while another review’s Apply runs, offered again when it ends; Discard and Later held while its own Apply runs; a draft’s refusal said inside the review without its text or path, pointing to Later, which closes with the proposal held and nothing written, the review reopened then applying; Later after a refused write keeping the proposal as the Apply left it, reopened with what is left; Escape as Later; a replacement redrawn; another username, another film and development mode each closing the review with its cause; every code and note kind with a sentence of its own, an unknown one a generic sentence; a creation the same import lists in a folder’s `children`, or the project’s, said filed where the proposal lists it, one no parent lists still unlisted; a new `children` entry naming neither a scene nor a folder named as written (a non-string one in JSON) in place of the shape sentence, and a `children` of another shape as a whole keeping the shape sentence; a project change declaring eras says each one declared, with its year or without, and one already declared left as it is, and a detail without a label reads as the general note. Relabel notes at 700 px in light and dark cover dated and undated new eras, the old year when present, and the localized old-label form without a year. A changed birth date draws Appearance · Age 42 and Was: 7 at 700 px dark. A scene’s three blocks each read as words with no brace and a document’s heading without its `#`, `import.review.shown` logged at opening and at a replacement with the raw values and the words; 45 long blocks at 375 px dark leave Apply on screen, nothing overflowing; a change only in Markdown marks (`Before` over `Before`, `## Act one` over `# Act one`) shows both values as stored, logged as `stored`.
`packages/filmopen_forms/test/import_review_text_test.dart`	a change’s value as words (§9.3): the exact lines of a nested value with labelled and unknown keys, an id and Markdown taken off, a snake_case word and an asterisk between spaces left as they are; a document’s headings, emphasis, lists, a table and a fence of another language as their plain text, the fence’s own lines dropped; a ```json fence whose body parses read through the same map and list lines, under no word json; a body that does not parse, a fence not closed and a brace in prose keeping their lines as any text’s; `null` empty, a number and a boolean as text, a list of texts one to a line, a multi-line text indented under its label; values equal in words but not as stored given as stored, a text as it is and a list of objects as its JSON, two fences differing only in their JSON’s spacing among them, and values whose words differ as words
`packages/filmopen_forms/test/dormant_field_test.dart`	a dormant box (§9.3), pumped on its own: no `EditableText` until a click, the chip by the shared helper, the caret beside a mention and inside wrapped text, Tab to the next box opening it at its end, leaving turning it back with the new text and chips, a locked box’s read-only editor, an agent’s semantics tap, as tall as its editor one line or several, wrapping and placing its chips as the editor does with mentions and a picture, its value naming the mentions, Escape after the field’s own menu, the window in the background keeping it open, a right-click, a box that cannot take the focus going back, a chip in a box narrower than its picture, not dormant it is the editor alone, a re-seeded box drawing its new text (a plain controller, dark)
`test/session_page_perf_test.dart`	what the chat page costs that does not depend on the machine (§9.3), every item opened by its arrow: the editors built on open (only the Other attributes’ selectable text), the forms built by one keystroke and one save publication (each item’s comparison sides and its media card’s); and through the real forms a name, a summary, a relationship, a treatment combo, a synopsis and an epoch’s year opening alike, the locked column read-only, Tab moving on, 700 px dark, and an entity page and an ordinary comparison still drawn live
`packages/filmopen_browser/test/browser_page_import_test.dart`	the browser’s import reviews under the rail’s own `IndexedStack` (§9.3): a proposal put aside not offered again on a change, a second offered meanwhile, a dismissed one offered again; a deferral ending with its proposal discarded during another review, with another document under its id, with another film and another username, and a close then reopening of the same film, development mode changed no longer counting it and its review letting it go, and a proposal gone before Later is answered never put aside, another document held under the id as Later closes the review offered as a new proposal, and a replacement the open review redrew put aside; a proposal not yet reviewed behind Settings ending with a change of username and with a close; the control at the bottom with its count, at 375 px with the tree in its drawer, Review’s tooltip, Review reopening in order, Later moving one last, the control gone with the last; a proposal dropped at read no longer counted once the browser shows again, nor reopened by Review, which logs why; the review the browser opens and closes logged with its values; at 700 px the control within the window, one compact row, the detail pane’s element kept, and at twice the text size wrapped; no review over Settings, the offer on the way back, and the rail switched away between the offer and its frame
`test/import_review_listener_test.dart`	the browser’s listener on the whole app (§9.3): a proposal for the film open and its viewer opening the review, one at a time, the next offered when it closes; another film’s, another viewer’s and the assistant’s opening nothing
`packages/filmopen_media_ui/test/viewer_test.dart`	the viewer saying the provenance strip’s words and the entry’s note under the picture (`player.note`) where a place gives them, and neither where none is given; autoplay: the viewer asking its player to play at once by default, to wait when opened with `autoplay: false`, and a place’s own player told the same; release on close, counted through a stand-in player’s life: Close letting it go, a second open after a settle and a second open during the first popup’s exit transition each letting every player go once, and a tap on the page under the open popup closing it rather than reaching the page; what does not play: an address shown with why it is not fetched and never handed to a player, and bytes in memory answered with Coming soon and no controls, no engine made; the strip, its add tile and the old upload sheet gone from the package
`packages/filmopen_media_ui/test/media_player_test.dart`	the engine’s player asked directly: a player handed out exactly where `mediaEngineFactory` is set; bytes in memory, an address and a picture make no player, asked to play or not; a clip or a sound on disk makes one where the engine is set and none where it is not (made, never pumped)
`packages/filmopen_media_ui/test/media_viewer_test.dart`	the pop-up player through the engine: on the real `LoggingEngine(FakeEngine())` the probe refused and Coming soon said by the player, `player.no_engine` logged with the path, kind, engine and code, the engine let go once and Show in folder kept; no engine set, Coming soon with no player made; a picture untouched; on a spying stand-in a clip probed, prepared on its one-file timeline with its own sound and played, its texture at the probe’s aspect, the controls fed by the clock, a seek through the engine, Play where the file has run out seeking to the start first, Play shown at the clip’s end while the engine still says playing, the engine released on Close with `player.released`; no texture → Coming soon, `player.no_texture`, nothing played; a probe refused `unsupported` → unplayable with its code and cause, never Coming soon; a refused play said in the row (`player.failure`) and not retried; closed while the probe runs → nothing prepared, one release; the dialog 24 px from each window edge at 375, 700 and 1200 px, light and dark, the picture inside, nothing overflowing, Escape closing it. A failure that stops playback said in the row with its words, code and cause, Play shown, `player.failed {stage: playback}` logged, an encoder’s failed event not shown, a play that succeeds clearing it.
`packages/filmopen_media_ui/test/fixtures_test.dart`	the real sound fixture `test/fixtures/tone_1s_8k.wav`, made by `scripts/make_media_fixtures.py` from the walk’s own tone (`--check` refusing a file that differs): a PCM wave file, mono, 8 kHz, 16-bit, one second, not silence, under 20 KB. No clip fixture yet: a generated one needs `ffmpeg`, and the walk borrows one of Windows’s own
`packages/filmopen_forms/test/media_card_test.dart`	keeping carries the preview batch’s model; the media card on a fixture film: a character’s five places in their order — Reference images, Character sheets, Voice samples, Inspirations, Motion clips — always, and no Add a place…; a location’s three, with its sheets and Inspirations and no voice; a group the type does not list kept in the file, not shown, and logged once as `media.places`; a `preview` no entry names as a tile of its own; copy-left’s one row over `media` and `preview`; the last look never written as the card is built, the marks staying until a medium is opened; opening a new medium writing it once, the marks then gone and a second open writing nothing; the tile menu’s Open writing it as the tile does, and a sample opened in the voice panel too, its decision logged; with no look yet nothing marked and the first open writing it; nothing new since the last look writing nothing, opened or not; never on a read-only project, and nothing marked there; a project with a cover and no look opening with nothing written, its cover opened writing the look; a character’s loose preview and an outfit’s picture, opened, each writing it; each open logged as `media.visit` with its cause, the medium opened, its places, its newest media, its decision and its reason; the delete flagging the entry through the draft with `preview` cleared, settling it, and only then deleting the viewer’s own take’s file, and stopped, the file kept, by a draft that cannot be saved and by a file that changed meanwhile without the flag, each said, and by the page gone while the flag is written, its trail ending refused as `page-gone` with its time; the card at 375, 560, 700 and 1200 px in dark, every place’s tiles and buttons measured inside the view; Retry after a draft that could not be saved and after a file that could not be removed, each finishing the delete once it can; the voice panel (§9.1): the previews waiting, an uploaded sample being none, Use this voice asking first, in words true of every platform — the keep may take a voice slot — logged as `voice.keep.wording`, and sending nothing on Cancel, then keeping the voice through the plug-in that designed it and writing the choice in one change, the other preview then first; a save acknowledged whose write fails keeping its id with Retry write, which sends nothing again and writes it; a save acknowledged after the page was left written into the file it was kept for and no other, and its refused write logged as one; the plug-in’s own words for a save it could not make, nothing written; a save whose answer was lost said to be of an unknown outcome and one refused before it went said not kept; a sample marked as in use but kept as another voice said so; a MiniMax design on fal’s one preview shown and kept as the voice its generated id already is, logged start, saved and kept; in view mode Use this voice disabled, saying why; Use this recording offered only where a stand-in design row declares `keeps_recording` on an enabled plug-in’s voice platform, and only on a live, unarchived upload with no binding, its offer logged once; its question naming the chosen model’s clone price, or that the price is not known where the row has none, with the model’s pull-down and the optional words, then keeping the recording through that model’s plug-in with the model, reference, name and description and writing it on that platform with its words, its trail logged; its failed write kept with Retry write, which sends nothing again; the question cancelled and dismissed each logging the name, words and model entered and its time, nothing sent or written; the recordings and the question at 375, 700 and 1200 px in light and dark, nothing overflowing, written as pictures where `FILMOPEN_CAPTURES` names a folder; at 360 px in light and in dark, nothing overflowing; Analyze under Reference images: the most recent upload chosen and shown, never a render’s take, and the appearance, the clothing as notes and the prompt filled in one change, nothing else touched, and the same description again said to change nothing; where no upload says when it came, the person choosing first; the plug-in’s words for a description it could not make, and its code where it gave none, a value no field takes and a field of another shape writing nothing; a description that comes back once its picture is gone, or once the form is closed, writing nothing and logged as dropped; several analysers offered by name, view mode saying why, no bar with none on; at 360 px in both themes, each part of the bar measured inside the view; Analyze under Voice samples: the most recent uploaded recording, never a designed preview, filling how the voice sounds with the voice speech uses, the sample in use and each binding as they were, a newer upload of a type the plug-in does not take passed over and said so, and with none it takes nothing chosen; words that are no JSON said in the plug-in’s words, a recording gone meanwhile or a form closed before the answer writing nothing; the recording bar and its help for a passed-over upload measured inside 360 px in dark; and a pitch of no vocabulary writing nothing
`test/project_menu_semantics_test.dart`	the project menu’s remembered rows through the semantics tree (§9.2): a row, its × and its trash three nodes, each with its own tap; the row’s tap opening the project and leaving it listed, the ×’s taking it off the list with the project open and its folder there, the trash’s asking first and No leaving the folder and the row; and a click on the row opening the project and leaving it listed
`packages/filmopen_ui/test/editable_combo_box_test.dart`	the editable combo box (§9.3): any words typed kept and said as typed, never made one of its words; its list in its order from the arrow, a word chosen filling the box through the same change, the caret after it, the list closed; the keyboard — Tab from the box to the arrow, Enter opening the list on the words the box holds, Escape closing it with nothing written and the focus back on the arrow, the arrows and Enter choosing; Other putting the caret after the box’s words and writing nothing, on every platform, a desktop’s selecting all on focus undone; Down and Alt+Down in the box opening the list on the words it holds, a click back in the box closing it; Tab going from the box past the caller’s own control to the arrow, named for its box and saying whether its list is open on the one node a screen reader focuses and taps; a box read only, and one with no word to offer, without an arrow; at 360 and 700 px, light and dark, the caller’s control and the arrow inside the box, the arrow after it, and the list as wide as the box, within the window
`packages/filmopen_ui/test/editable_combo_box_test.dart` (built field)	a built field given the box’s focus, decoration and arrow; Down opening the list past the field’s own text shortcuts unless the field takes it; a suggestion chosen through the same change
`packages/filmopen_ui/test/short_name_field_test.dart`	the short-name box at 700 px: a handle’s owner is a username — `ab`, `-abc`, a 33-character owner and `ab.ws` refused with the username’s rule, a 32-character owner accepted with a 53-character counter; a username box saying that rule as its helper and for a 33-character owner, `ab` and `-abc`, counting to 32; a 21-character workspace part refused with the 20-character message and a 32-character owner with a full 20-character workspace accepted; an initial 33-character segment refused with the 32-character message, 32 typed characters accepted with a 32-character counter, and the two-argument message API retaining the segment bound
`packages/filmopen_forms/test/style_card_test.dart`	a film’s visual treatment on the project’s and a folder’s form (§9.3, the Project Specification §8.7): Analyze on the project’s picture’s menu, asked with the project’s scope, its review showing what one picture cannot tell and writing nothing until Update this version, which fills the treatment in one change — the palette lowercased, a null leaving what the file says — and what one picture cannot tell written nowhere; a token of no vocabulary, nine colours, a colour that is no `#rrggbb` or a control character proposing nothing, what one picture cannot tell not shown for such an answer, and a description that tells nothing saying so in its review, with its limitations; a folder showing what it inherits, the value as the hint and where from as the help, a row of chips the value too; a leaf overridden, then Clear local overrides removing the profile, the pictures kept, the boxes emptied; what a folder inherits read as the viewer reads the script, a fork they picked passing on its own; a word a row does not know kept and said; a palette that is not one said under its box and never written, the last list kept; a folder’s first value of its own, typed into a draft already changed, dropping the box’s inherited help and offering Clear at once with one form build and none for the next letters, emptied inheriting again; a folder’s first treatment prompt, typed into a draft already changed, offering Clear before the save with no form build, emptied holding it again; an epoch’s label and year typed on the project’s form drawing the form once, at the first letter, and both written; a folder listed twice saying that no folder above it passes on its treatment; another author’s folder read, where from said under its boxes, Clear held saying why; a description that comes back once its picture is removed dropped in its review, Update this version held, nothing written; the card at 360 and 700 px, light and dark, with a palette that is not one and a word a row does not know, the message saying the leaves are under Advanced treatment on a folder and in Other on the project; the five primary leaves: the five with their labels and the owner’s words offered in their order, Other on the camera’s alone, folded with the detailed leaves in Other’s subsections on the project, the scale labelled Depth of field scale; a word chosen, words typed and a box emptied each writing its own leaf, the older leaves untouched, words of their own shown as they are after a re-read, an emptied box no leaf; Other putting the caret after the camera’s words, none selected, on Android and on Windows, and writing nothing; a folder inheriting each, its own words overriding, and its box emptied inheriting again with no key left; another author’s version locked with no arrow; a folder’s card’s line saying what the five are for and where the rest went; the camera’s row of its own; a number written by hand shown and said to be none of the treatment’s; at 360 and 700 px, light and dark, each box’s microphone and arrow inside it; the preset seeding no box, kept when another box is typed into and removed with a folder’s profile by Clear local overrides; the Style first on a folder’s card and above the treatment’s boxes on the project, picked on the project, inherited with its origin by a season and an episode, overridden on the season and given back by Clear local overrides, opening and closing its popup writing nothing, locked on another author’s version, and no setter for an agent; a folder’s inheritance derived once per project and viewer, however often its draft is rebuilt, on a 500-scene script, and anew for another viewer or a changed project, reading the film’s one walk of the script where the form shows the project loaded
`packages/filmopen_forms/test/style_card_test.dart` (prose leaves)	a treatment’s primary leaf drawn as prose inside its combo: a chip shown, Down going to the mention chooser while a mention is typed and its choice written as canonical source, Down going into a chip’s replacement chooser while it is open, and with no chooser open opening the suggestions
`packages/filmopen_browser/test/takes_tab_test.dart`	the takes tab through the one tile: each take a `MediaTile` (`take:<stem>`) wearing its own batch’s strip — Imported for an import — with its caption beneath, the picked chip and the batch chip (`take:<stem>.batch`); a tile opening the viewer, which says the strip’s words under the picture; nothing overflowing at 700 px; a take placed once in a block wearing that block’s placement, which the document’s own edit does not outdate; placed in the version and a block, or in two blocks, Placement status unavailable
`packages/filmopen_insertion_ui/test/file_drop_stub_test.dart`	the web’s half of the drop, in a file of its own: no drop, the target the child alone; a drag over the page answered with a success envelope holding nothing once `settleFileDrops` has run, and unanswered before
`packages/filmopen_insertion_ui/test/boundary_test.dart`	the element’s boundary (§4.1, §9.3): every package import read, a prefixed one and a package name with digits included; each a package it may use, through its barrel; of the jobs and the insertion only their contract with a page, by a show list; of the store only `AppLog` and `LogLevel`; no sync, drive or plug-in host in its pubspec; `BlockPlace` among the insertion’s names it may show
`packages/filmopen_insertion_ui/test/delete_fate_test.dart`	what Delete says goes (§9.0): the file of a take a plug-in rendered under the viewer’s workspace handle, and not another author’s workspace take, named by its whole handle
`packages/filmopen_insertion_ui/test/media_upload_sheet_test.dart`	the upload sheet’s Browse (§12.3, §4.3): a product host has no answer and the dialog opens, logged `media.browse.start {source: picker, kinds}` and `media.browse {paths, ms}`; the agent’s answer taken instead of the dialog, once, the next Browse opening the dialog; an empty answer a cancel, the sheet staying; a dialog that fails logged `media.browse.failed` and still failing, never read as a cancel
`packages/filmopen_insertion_ui/test/media_place_test.dart`	the media place on a fixture film: the add tile first with Upload and a registered stand-in in their order; an empty username’s buttons, `default`‘s, as any author’s and never asking for a username, and given no viewer disabled saying why; both buttons inside the tile by measurement, a word that fits drawn and one that does not dropped at the narrow edge, an action that may not run disabled with its reason, one that makes no kind the place takes not drawn, no add tile on a version that may not be written and its menus editing nothing, the buttons’ reason without a handle, an active upload disabling only its own place’s Upload; jobs newest first, keyed and unmoved across a rebuild, their actions sent, a done job said once and dismissed, that dismissal and a tile’s own action each logged as sent (`media.jobAction`, with its reason) and as ended (`media.jobActionDone`, a refusal a warning), a `recordNotWritten` job’s sentence with Dismiss; the provenance strip from the item an entry names, Imported, no cost, none without a record and none from the take’s own record where the entry names no batch, which is never new either; New after `newSince` and none from null; an archived new tile spoken as archived; archived entries behind Archived (n), a deleted one never drawn; an empty place that may not be written saying so in a line whose every word fits a 160-pixel place in the test font, which draws them more than twice as wide as the app’s and so asks more than a Compare column at 700 px does; every menu action one edit through `onDocument`; Delete asking once, flagging the entry with `preview` and `picks` cleared and calling `onDelete`, and saying why only the entry goes for a file no upload made, a take whose file is not in the folder and another author’s take; the file dialog asked for the place’s kinds and what it chose inserted there, an address of another kind and one that names no file refused in the sheet in a picture place and a clip place, a refused file — another kind, or no media kind at all — named under the tiles while the rest are inserted in order, and the line gone with the next submission, a producer’s included; a render’s job saying Rendering… while it runs and, ended by a plug-in’s own code, that code in a sentence with Dismiss, one whose code could not be kept said without it, while one whose take could not be written after the render keeps the job’s words; a paid render’s possibly-charged sentence kept whole in semantics and on hover while its visible text is bounded to eight lines; the drop through the drop package’s own channel — files let go on the place judged as an action’s are, those the place takes inserted as one selection in the order dropped and the rest named, a picture and a clip into a place that takes both in their order, the line gone with the next drop, the whole media area taking a drop — a tile, a failed job’s tile and the blank space after the last tile, at 1200 and 700 px — and the drop’s gate taking its whole box where its child draws nothing, and nothing outside it; files over the area saying the place takes them in the primary colour with nothing on the page moving, a busy place saying so in the error colour before they are let go, nothing said under a dialog, no drop on a version that may not be written; a folder taking today’s two answers; the file dialog and a drop one path for a picture, a sound and a clip in a writable, a read-only and a busy place at 1200 and 700 px; the place fixed at the drop or the pick — a late failure said on no other place and on its own when the page comes back, a job action’s refusal likewise, a pick arriving after the page moved discarded and one arriving after the place stopped taking anything not submitted, a drop of refused files replacing the last drop’s failure, busy each place’s own in both directions and counted where a pick and a drop overlap, a refusal line and the archived entries left with their place; a drop under a dialog, or where a place hidden in a stack would be, reaching nothing, a drop on a busy place refused whole with its reason said only while it is busy, the + saying it takes a drop; the keyboard tabbing to Upload and pressing it; three places on a page with every identifier unique at 1200 and 260 px; nothing overflowing at the narrow edge in dark; a refusal saying what the place takes; a link dropped on the add tile named by its last part, never its query, and pointed to Upload, a drive letter being a path; a disabled menu item saying why under its name; Upload disabled keeping its name, the reason its tooltip; a tile’s label with its kind; a disabled item disabled for a screen reader too; a `data:` address named by its scheme, not its payload; a preview in the take’s other spelling read as that entry’s; one tile per import — a job of one file at its attachment, whose output the document names, drawn on that entry’s tile until it ends, the tile saying the job’s words in its own semantics node and nowhere else, the same element after, and a job that waits, needs attention, names an output the document does not, or brings several files keeping its own tile and actions, as does one whose output is an entry not drawn there — deleted, archived behind the fold until it is shown, another group’s — and an output named by its file name drawn on the entry that names its stem; a job at another stage — run again with no count said, being stopped — keeping its own tile and Stop until its attachment; the injected actions — on another author’s version in a project the viewer writes, at 1200 and 700 px, Open and an injected action and none of the items that edit the version, Set as preview among them, the action told the entry whose menu was opened and the version’s access; no menu on a read-only project or a library file; on the viewer’s own version the injected item after Delete; an action that does not apply not drawn; each of the six local reasons and eleven provider refusals its own sentence under a disabled item that runs nothing; an action registered after the place was drawn offered and, taken back, not; chosen after it was taken back, after it stopped being available, after its entry left the version or after the page moved to another place, nothing run and why said; an action that fails said under the tiles by its name, never its text, reported as Flutter’s error with its own words, and gone with the next choice; an action that throws when asked whether it applies not drawn, and one that throws when asked whether it may run disabled in general words; a version the film no longer holds disabling every injected item before the choice and refusing it at the choice; Open saying why where the media folder cannot be reached; a move chosen after the document changed under the open menu moving nothing and throwing nothing; a place that has gone hearing no further registration; a block’s place (`BlockPlace`): its own entries under `media:<stem>:<block id>:<group>`, two blocks’ places of one group distinct, a tile outdated by its covered block, a favourite, a move, a note and Keep changing the block’s array alone, no Set as preview on a frame, a delete clearing the entity’s `preview` and `picks`; the extent chooser: a clip offering This block only — no `spans` — or Through block n over the blocks after its own by position, never one before it and never `until`, an id given twice offered once, through block 10 from block 8 handing `bl_8`, `bl_9`, `bl_10` to the action and the service alike, the last block asking nothing; music and sound effects offering Until the end of the scene (the default), Until block n and For n seconds, the seconds waiting for a number above zero with the reason in the tooltip; frames and voice lines asking nothing; a cancel running nothing; a drop asking too; an entry’s extent read in its tooltip, nothing where its block is gone; a header under the title and above the tiles where the place is given one, none otherwise; an action’s thrown failure said under the tiles as {action} did not work. and reported as Flutter’s error, nothing submitted, and the next action clearing it, one that hands on nothing too; two places of one document under two `IdentifierScope`s, a job’s Retry and Dismiss among them, every identifier their own
`packages/filmopen_insertion_ui/test/job_settlement_text_test.dart`	the real insertion tile says the whole attached-but-unsettled or film-wait sentence in English and Spanish, light and dark at 700 pixels; generic attention/import and lost-input text are absent, Try again/Dismiss or Stop fit and each offered action operates once; bindingChanged caption selection follows three exact action sets: Retry/Dismiss retains render recovery words, while Dismiss alone and Stop alone use neutral insertion words; English and frozen Spanish controls operate in light and dark, with the new English sentence checked in full; the render manager’s five refusal codes each its English sentence on the tile, light and dark; a failure’s `detail` read as its sentence, in the code’s sentence’s place, light and dark, and the code’s sentence where there is none; an upload refused `tooLarge` with a name reads {name} is too large to add here. at 700 pixels, light and dark; a working upload at 42 % shows its determinate bar and mark at 700 pixels, light and dark
`packages/filmopen_insertion_ui/test/place_kinds_test.dart`	what a place takes, in the word its refusals use: pictures for the types’ picture places, clips for Motion clips, sounds for Voice samples, and all three for a place of an author’s own
`packages/filmopen_render_ui/test/render_action_test.dart`	Render on a place’s add tile (§6.15): its id, its word and the three kinds it makes; the dialog opened with the place captured when it was pressed, and its version, kinds and purpose; the request handed to the place as a producer’s source of kind `render`, whose payload, the place’s own JSON in it, passes the jobs’ credential check and carries the place back; a request for another place refused, with nothing handed on; a render run’s saved JSON keeping its job’s id under `id`, where the insertion reads a render’s id; a closed dialog asking for nothing, and the availability the one it was given; Render on a character’s voice samples keeping no voice opening the dialog designing a voice and handing its request on, one keeping a voice opening the ordinary dialog, each logged `render.voice.mode` (`design`, `speech`), and a request for another place refused; on a dialogue block’s Speech, Render enabled where the speaker keeps a voice and disabled with This block has no speaker., The speaker is not a character this scene can see., The speaker has no voice… or This block has no dialogue., a build where renders do not run or could not start saying so first, and another group of the block not asked (`blockLineAt`); Add to batch’s answer adding the frozen request to the viewer’s pending render batch and inserting nothing, two adds two items `n` 1 and 2 of one `rd` record, each read back as the request and the place, logged `queue.add {stem, n, target, model, platform, ms}`, the message Added to the pending batch whose Open shows the batch’s Pending row; a record changed meanwhile refusing the add, nothing written, logged `queue.add.failed {stem, cause, ms}` and thrown for the tile
`packages/filmopen_render_ui/test/render_queue_test.dart`	the pending batch’s Render (§6.15) on a stand-in insertion whose calls are counted in every case: a double press submitting once, the second answered `busy`; a batch of 20 costing 42 record writes and 42 publications, each item marked just before its submission and the gate’s pass logged; the frozen request submitted for its place, the item `submitting` on disk at the call; a job and a refusal ending `submitted`; a failure after the submission began, and a record write lost after it (`queue.submit.unrecorded`), leaving the item unresolved and never resubmitted; items with a job, an error or unresolved skipped and named; an empty pass, a record not pending and a closed film writing nothing and submitting nothing; the plug-ins’ settings read again: the pass not started, nothing written, every item pending, `queue.pass.notReady`, and a second press submitting; a version the viewer may no longer write `not-editable` and a gone one `entity-unavailable`, nothing submitted; an unreadable item refused with its code; a pass of 20 cut short by Close project during its first submission, read in a new app from what the pass wrote: only the item in flight marked, finished, and the 19 not reached taken by the next pass, the one in flight never again; a pass interrupted after a lost job write and after every answer, read in a new app, finished and passed again with nothing resubmitted; finishing and Mark as not submitted refused while a pass holds the queue; marking clearing one unresolved item that the next pass takes; an answer that comes after another film opened written into neither, the copy unchanged, the original keeping its marker, answered `film-changed`; the gate changed while the marker is written, nothing submitted, the item `not-editable`, and with that refusal’s write lost the marker kept, counted unresolved; each action’s start line logged before its first write; queue-owned outcomes with no page, four same-event dismissals, completion before the job id is written, failed/cancelled outcomes, a lost write emitted with its phase and retried only at the next moment, one write in flight per item, producer orphans logged once and uploads excluded
`packages/filmopen_render_ui/test/render_queue_codec_test.dart`	the render queue’s item (§6.15): the place, the frozen request and when it was added to JSON and back, the request exactly as Render sends it; an item that is no object, a place it cannot read, a request `RenderRequest.fromJson` refuses, no time and a request for another place refused as `item`, `target`, `request`, `added` and `elsewhere`
`test/media_section_test.dart` (the location’s cases)	the same card on a location from one line: a picture of the café named `cs_lo_cafe_…` and becoming the preview, with its take in `media/` and its thumbnail in `thumbnails/`; the café’s three places — Reference images, Location sheets, Inspirations — in order, each taking pictures, and no Add a place…; Compare pairing the card and `<` adding without removing; and 700 px in dark; the card under General, and at 700 px scrolled into view before its tiles are measured
`test/media_section_test.dart` (the player’s own cases)	the viewer asking the platform for a player and drawing what it answers — a tile’s tap asking it to play at once, so `player.pause` beside `player.close` — and the file’s kind above them; and a platform that has none saying so, with no `player.reveal` for media that is on nobody’s disk; the dialog and its controls row fitting at 700 px, the seek bar taking what is left and the time beside it. The player itself is the platform’s, so a check stands in for it (`debugMediaPlayer`); the real one is exercised by `scripts/agent_walk.py` on Windows: a twenty-second sound opened from its tile is playing without a second tap (`player.pause` listed, `player.clock` past `0:00`), pauses, and logs `player.released` after Close; Windows’s own clip opens in the player and is released; and a file whose bytes are not a clip shows the error state with `player.unplayable` in the log. The walk sees the sound playing, not its start, since a tap answers only once its frames settle
`packages/filmopen_drive/test/drive_android_flow_test.dart`	the whole Android consent flow composed, driven without a browser, a device or a socket (§6.10, s M2): the consent page opened with the Android client and its redirect answered and exchanged; the verifier sent with the code being the one the challenge was made from; a browser that will not open being unavailable with nothing exchanged; a build given no link door saying so without sending the person to Google; a redirect for somebody else’s request refused with its code never exchanged; a refusal from Google kept as a code with none of its words; and a state and a verifier of their own for every sign-in
`packages/filmopen_drive/test/drive_android_client_test.dart`	Google Drive on Android (§6.10), read without a browser, a device or an account: which client each platform signs in with and that a build carrying one is unconfigured on the other platform; that an Android client sends no `client_secret` rather than an empty one; the redirect scheme as Google’s reversed client id, computed the same way `android/app/build.gradle.kts` computes the manifest’s placeholder, and an id of an unexpected shape yielding a scheme rather than a crash; the Android consent address carrying everything the desktop one does — the scope, `access_type=offline`, `prompt=select_account consent`, the S256 challenge, the state — with the custom scheme as its redirect and no secret anywhere; and the refresh request’s own body, where the wrong secret would not show until the access token ran out an hour later: the Android client and no `client_secret` key at all, the desktop client with its secret unchanged, an expiry kept, a refresh token not invented, and a refusal answered as the code `refused`; the code exchange’s own body, which is FilmOpen’s request and not the library’s, carrying no `client_secret` key on Android and the secret on a desktop, answering tokens from a stand-in, and turning a captive portal’s page into unavailable; the redirect waiter driven from a stream — our own scheme only, a wrong state refused before the code is used, an error carrying no code, a bounded wait, and the subscription given back however it ends; and the Kotlin read from `android/app/build.gradle.kts`, so the two computations of the scheme cannot drift apart unnoticed
`packages/filmopen_drive/test/drive_auth_test.dart`	forced refresh of a still-fresh token, refusal, ownership and cancellation preventing late credential writes; a cancel arriving while the write runs keeping what was written, with each attempt’s `drive.signIn.*` line; the log of each operation — a store that will not take the tokens ending a sign-in or a refresh as a store failure with its code, type and words, never as `superseded`; a refresh Google turns down ending the client at its `refresh` stage; a client’s start, why it refreshed (`forced`, `stale`) and its timed end; a sign-out’s start, its timed end and a clear that fails with its words; a refresh with no network keeps the stored tokens, nothing written or cleared
`packages/filmopen_drive/test/drive_client_test.dart`	byte request shapes, MD5 metadata, resumable session requests/status, document replacement and bounded responses; a 403 read by its reason — a full Drive, a rate limit, anything else a refusal — never by its message and never sent again, and a 403 whose body never ends `unavailable` within the bound; downloads requesting `alt=media`, preserving binary bytes, adding Range only for a positive offset, accepting a matching 206 or a whole 200 from zero, and receiving an empty file from zero; ranges at or beyond the file’s end unavailable, missing or trashed files not found, native files refused and negative offsets rejected before HTTP; malformed, missing or mismatched Content-Range and unexpected successful statuses cancelling the body, with a valid unknown total accepted; rejected-body cancellation remaining bounded and code-only even when cleanup throws or stalls; download transport errors and gaps between chunks becoming code-only unavailable failures
`packages/filmopen_drive/test/drive_sync_target_test.dart`	the next chunk read while one is sent and the last read to EOF before it is sent, the upload’s `drive.uploaded` with its MB/s; a receiving stream’s failure logged with the transport’s own text; `forgetLookups` making the next operation ask for the film’s folder afresh, another `DriveAuth`‘s lookup standing; a listing answered “not found” by `find`, `inventory` or `put` forgetting the folders’ lookup, the film’s folder asked for again and a `data` gone made anew; inventories, document/media publication, chunk resume and dropped sessions, checkpoints holding the upload id in hexadecimal — an id holding an address and a key reaching the sync as neither — and malformed ones refused, original stream errors, forced refresh/replay, and stalled initial/401 refresh ending at 30 seconds with its client closed; the film’s folder asked for once per lookup and never while the ids are held, and the folders made once however many operations start together, on one target or on a target each, as the application makes them, while another `DriveAuth` looks them up for itself; a listing Drive answers “not found” `unavailable`; the film’s folder gone `folderGone` for good, a deleted `data` or `media` finding nothing and `folderGone` tried again, then made again; against a Drive held in memory: a 403 by its reason, a full Drive `driveFull` and a rate limit `busy` with no refresh, a permission a sign-in with no refresh, and a 403 to a request a 401 replayed read the same way; a session let go of mid-send tried again and reopened from byte 0; a document deleted between its lookup and its replacement `unavailable`, then uploaded anew; a stray file, a file without a size and a second file of one name left out of the inventory; and a film sent through `SyncService` to the Drive, a session among it, under an upload id that reads as an address and a key. Receiving covers exact manifest/document bytes and MD5, media ranges with whole-file metadata, and ignored ranges answering from zero; absent, trashed, native, folder and unsized entries refused without a download, invalid offsets refused and unsafe paths rejected before authentication; a download’s 401 replaying the same range once, a second 401 requiring sign-in, and a file removed after lookup or a 416 becoming unavailable; fetches reusing the inventory’s folder lookup across target instances; controlled streams retaining their client until completion, cancellation or error, cancelling the body and closing once, with both an unlistened response and a stalled chunk bounded by the existing timeout; throwing and stalled upstream cancellation contained and bounded after both client layers close once, for abandonment and explicit consumer cancellation; the committed probe’s `drive.committed` and the operation’s end, and a receiving stream’s `drive.fetch.ended` as `cancelled`, `error` and `abandoned`, with the bytes delivered and the milliseconds
`packages/filmopen_drive/test/support/drive_stand_in.dart`	a socket-free Drive with files, paginated listings, metadata, folder creation, document replacement and resumable upload sessions, retaining request shapes for assertions; media GETs serving full binary bytes or a ranged suffix with Content-Range, optionally ignoring Range, returning 416 for an invalid start, 404 for missing or trashed files and a fileNotDownloadable 403 for native files or folders
`packages/filmopen_drive/test/support/streaming_stand_in.dart`	ordinary Drive metadata routes with independently controlled media status, headers, declared length, chunks, errors and completion; a streaming MockClient recording request shapes and honoring injected responses, with listener, pause, resume and cancellation counters and an optional throwing or stalled cleanup hook for lifetime and timeout assertions
`packages/filmopen_drive/test/drive_sign_in_test.dart`	loopback/link cancellation, late answers not stored, bounded desktop exchange and close-once ownership
`packages/filmopen_drive/test/drive_token_log_test.dart`	a token request’s lines: a refresh’s `drive.token.request` and `done`, a refusal’s status and Google’s body, a transport failure’s type and words, an exchange answering a page `notJson` with its size; inside a sync operation each request, end, refusal and failure line and the credential store’s failures (read, parse, write, clear) carrying its `op_id`, none outside one; no line holding the secret, the refresh token or the tokens of a 200; the tokens through the one credential door
`packages/filmopen_drive/test/drive_token_timeout_test.dart`	direct exchange deadline and client closure on success, refusal and transport failure
`packages/filmopen_drive/test/drive_trail_test.dart`	Drive’s trail on the in-memory Drive: an inventory, a ranged fetch read to its end, a whole put, a resumable put of two chunks and the committed probe each log `drive.request` and `drive.answered` under one `op_id`, the operation’s end, the fetch’s `drive.fetch.opened` and `drive.fetch.ended {eof}` with the bytes delivered, the probe’s `drive.committed` with and without its session; a 403 logged as `drive.refused` with its code, status and Google’s words; a transport failure as `drive.unreachable {stage: send}` with its type and text; a new file’s whole put as op `put`, another client called from its progress callback logging nothing; an invalid path refused at once, a bad checkpoint and a failing first source read, each as `drive.failed` with its stage and the same error; a fetch’s path as it is; the opening request’s method, URI and control body, no body on a chunk, and the final chunk’s receipt with its id and MD5 in `drive.body`; no line holding a token or a header
`scripts/tests/test_rewrite_sample_media.py`	the sample’s rewrite into the media container (§9.0): a character’s `refs` groups and its `voice.refs` becoming entries of the vocabulary’s groups, a take’s with the `batch` and `item` of the record item that made it and a hand-placed file’s with its reference alone, a plain array becoming `reference_images`, the rest of `voice` and `preview` kept; each record item a group took naming that `group`; `--check` writing nothing; a second run changing nothing; the committed sample already rewritten
`scripts/tests/test_replay_pages.py`	a tape’s navigation to any rail page — Watch, the project page, Activity, Share, GPU, Settings — tapping that page’s own rail door, and nothing where the page is on screen already; a tape started on any page but the project’s opening it first, one started on the project page tapping nothing
`scripts/tests/test_check_document_keys.py`	the documents’ keys and tokens in snake_case (the Project Specification §1.4): a key or a one-word value where a lowercase letter meets a capital refused, a hook’s name and a schema’s words excused, a name’s value, `params`, `x`, `plugins` and `metadata` (at the top and in a block) recorded as they came; a treatment’s primary leaves free text at `visual_style.<leaf>` alone (`iPhone`, `50mmPrime`), the same words elsewhere refused; the retired spellings over the repository with their excuses, a milestone’s probe transcripts (another service’s output, verbatim) not read, while its plans are — their quotations of another service’s or a log’s fields excused by file and count, a FilmOpen spelling beside them refused, as in a neighbouring folder
`scripts/tests/test_plan100.py`	the counts read in the singular too, and a count in the singular not taken for dismissed; at least two sends on Activity’s screen each answering `find "Sent."` in a node that holds its row alone — rows below the fold, listed as hidden, left out; a list read as one node, two rows in one node, or a single send on screen failing; exact-byte delivery waits, including document replacement and partial files; complete target snapshots with unfamiliar files and empty directories; completed counts covering the latest send; dismissal removes the count only on a reachable shared card; card reachability retries only transient disabled controls, with a deadline and immediate failure for other errors; Stop sharing preservation checks the full observation window
`test_plans/140_script.md`, `test_plans/run_mcp.py --plan 140`	a scene’s blocks through MCP on the folder plan 070 leaves: Add block under the next number, the speaker set and a line, a direction, an action and a duration typed and read back from disk under the block’s id with its own `updated` and no `kind` or `text`, and the rest of the scene unchanged, a second block and Move down, the condensed line, the Script tab without ids, a block added and deleted in the target so that its next number stands above its highest, Move to scene… writing the target under that number with every field and the source settled without the block, Delete block keeping the number, `set_field` on every key of a block and `not_found` for a block nobody has; expectations worked out from the files as found, so a second run at `--size 700x800` passes on the same folder
`scripts/tests/test_plan140.py`	plan 140’s wiring without an app: among `--plan`’s choices, needing `--project`, launched on its project, run after 070 and before 080; the runner’s `next_block_number` against the format’s rule, a `next_block` of `7.0` read as 7 as the app reads it
`test_plans/170_outfits-props.md`, `test_plans/run_mcp.py --plan 170`	outfits and props through MCP on the folder plan 020 leaves: the character as a whole with New outfit on its epoch’s card; a name the dialog’s only box, the outfit opening under an allocated `kira.<owner>-<n>` at that epoch and the tree reading character → epoch → outfit with no Outfits row; era, palette, condition and prompt, and a garment typed box by box, read back from disk and removed; Outfit sheets refusing a sound in the sentence it says and taking two pictures from a loopback server, `picks.sheet` a reference for one and a list in the place’s order for two; Add prop offering the ten kinds and no epoch with one, the prop opening on its form with a reference image, a sheet and that sheet chosen; the bundled sample’s `main-hero.oilskin` and `main-hero.suit` flagged as named by hand in the tree’s tooltip and drawn as any outfit. A drop from Explorer, a paid render and New outfit disabled on an undeclared epoch are by hand. The General name fields are reached before being read; each named-by-hand warning remains a separate assertion.
`test_plans/180_cloud.md`, `test_plans/run_mcp.py --plan 180`; `scripts/agent_walk.py`’s cloud step	FilmOpen Cloud signed out, on a build without keys, through MCP at 1200×800 and 375×800: the new-project dialog’s `new-project.cloud` and its four radios read before the box is unticked, each disabled, FilmOpen Cloud’s and Google Drive’s reasons, `new-project.director` prefilled with the username in effect, Create waiting with FilmOpen Cloud’s reason while the box is ticked; a local project created once it is unticked, its director on disk and `project.create.start {cloud: none, signedIn: false}` then `project.create.done` in the log; the open-project dialog’s `open.recent:<path>` for that project, its local heading, the signed-out sentence with `open.login`, `open.invited` and `open.online` disabled and Coming soon; Settings’ `sharing.filmopen` and `sharing.record` disabled, each saying to sign in; `ab` refused in `settings.handle` with the username’s rule and the username in effect kept, 32 characters taken. The walk reads the cloud box, its radios and FilmOpen Cloud held, and the open dialog’s local section and two held rows, cancelling both; every local create of the walk and the numbered plans unticks the box first
`scripts/tests/test_microphone_one_place.py`	a microphone is placed, never configured (§9.6), read from the application’s code with its comments and strings blanked: every `DictateButton` given only what to fill and whether its box can be typed into, and never wrapped directly in a widget that changes how it looks or takes the focus; icon constraints set only in the theme and in a pull-down’s own decoration theme, never beside a suffix, through `copyWith` or by a builder; the dictation card placed only in Settings; each way back caught and each right form let through
`scripts/tests/test_rewrite_blocks.py`	the sample’s rewrite into one block shape: the reading rule for every kind, `offscreen`, `voiceover`, `dual` and a title’s `duration_ms`; a block of the new shape left as it was; what the Dart reader would not read stopping the run, a null as absent, a boolean never a number; every other byte of a file kept and a second run changing nothing; `--check` writing nothing; the committed sample already in the new shape
`test_plans/100_sharing.md`, `test_plans/run_mcp.py --plan 100`	desktop folder sharing through MCP: a fresh film sends its manifest and two documents, a loopback picture and import document arrive without thumbnails, an edited character replaces target bytes and adds a completed send, Activity finishes and Dismiss finished clears its lists and Sharing count, and Stop sharing removes local `sync` while preserving every target file and directory; Sharing and Activity captures in light and dark at 700×800, with separate visual inspection; real Drive remains the owner’s manual section
`scripts/tests/test_plan110.py`	receive counts read in the singular and plural, with missing, stale, pending or attention summaries unable to prove completion; both directions checked together and a required send minimum enforced; exact manifest, document replacement and complete media bytes, with empty or missing expectations refused; received rows as separate visible nodes and a named row matched exactly; conflict actions correlated from a numeric find leaf through fresh semantics to the nearest owning identifier, rejecting stale, hidden, disabled, untappable, ambiguous or wrong-row actions while distinguishing another row’s Dismiss; all three decisions belonging to one job; complete target snapshots including unfamiliar files, empty directories and links, observed before, during and after receiving, with transient changes and worker errors retained as failures; post-stop preservation covering the full interval and its final observation, with absent or unreadable baselines unable to pass; explicit scoped scrolling reveals the folder field without activation, and a missing field stops before any card read; the quiet wait passes after five unchanged seconds of both count sentences and the target snapshot, restarts on a change and fails at its limit
`test_plans/110_receiving.md`, `test_plans/run_mcp.py --plan 110`	desktop folder receiving through MCP: a manifest-only second film receives every document and media byte without thumbnails, preserving its manifest and the complete target snapshot throughout the initial receive; a target document changed before a local scene edit arrives at that edit’s reconcile; another target change followed by a local character edit produces a named conflict and one attention count; six Sharing and unresolved-conflict Activity captures in light and dark at 700×800 require separate visual inspection; Take theirs receives the exact target bytes and clears attention, and Stop sharing preserves every target entry for five seconds; each target rewrite waits first for five quiet seconds of unchanged counts and target snapshot, so a reconcile pass an earlier change left pending has run; no sign-in or public service
`test_plans/160_synopsis-assistant.md`, `test_plans/run_mcp.py --plan 160`; `scripts/tests/test_plan160.py`	the scene synopsis’s field action through the dock on the agent build’s assistant fixture (§4.3), on Opus, whose fixture provider declares tools: the chip opening its chat with no Apply; a replacement written at once by `update-entity` into the person’s draft (`command.update` `mode: fork`, `sc_1_john123_v2` read back, john123’s own version untouched); the page showing the version written and the chat going on; a follow-up in the same chat changing the draft in place (`mode: inplace`, one version of the scene more); another person’s change forking into her own draft; the conversation’s voice dialog inert on that draft, Start never pressed; the Windows home in the checkout’s `build/sandbox-home/`; the runner’s Windows homes, without an app: plan 160’s (and the shared app’s) in the checkout’s `build/sandbox-home/`, never the temporary folder; a launched app’s log read under its home — a Windows app’s `logs`, a Linux app’s XDG state; the developer log plan 090 reads, the app’s own under its Windows home
`test_plans/165_assistant-panel.md`, `test_plans/run_mcp.py --plan 165`; `scripts/tests/test_plan165.py`	the assistant in the dock end to end on the fixture, at 1200×800 then 532×800, with pictures: the fixture’s attachment stages in order, read from the launch’s log file, then ready; the dock on every rail section; the groups at the project’s synopsis in order; the action’s chat on its own model (`write-claude-opus-5` on OpenRouter through the fixture provider, `because: setting`) with the context object’s film and the pattern; the typed replacement written at once through `update-entity` into the person’s draft — `mode: fork`, unlike the synopsis the file held, the draft read back, john123’s own version untouched, the first change opening the chat’s record by itself (`session.moved`, `moved: true`, the selection on it) and the chat kept —; a typed render (of Tomas, john123’s own, since a render attaches to the working version, §9.3) and open through `builtin/render-image` and `builtin/navigate` correlated by `ref` (`caller: text`), the fixture’s image route accepting the job; the navigation ending no chat (no `session.ended`), the polish chat held since shown again from the switcher (`chat.current`, `cause: switcher`) and continued in place on its draft (`mode: inplace`) with the page staying, and a version page’s teardown to its overview and category, each told apart by the place logged and the field’s heading gone, without an exception; Activity’s chat; the switch by portrait; the conversation present, unpressed; the dock’s session end to end — a chat’s prop written through `create-entity` onto the chat’s own live record, its first change opening that record by itself (`session.moved`) and its row showing the chat, the create’s Pick on its left alone, Pick all picking with the chat kept and its record open, no close and no model call, then Discard all on that live record moving onto it and ending its own chat (`session.closing`, `session.ended` `closing`, the chat gone), the item discarded; the polish’s record, a fork of the project with its base, picked by Pick all, then on the right, then on the left, the commentary’s pick and the version in use following each, the item open, no close and no model call —; the narrow window’s slide-out, opened by the portrait, keeping the same session across its close — no open or end between, its correlation and turns carried on, its messages shown again by place and speaker. The runner’s test: a phone skips it; a command is the chat’s start, lookup and end under one `ref`, after a mark by time; and the teardown, the slide-out’s session and the fixture’s trail each refuse the reader’s counterexamples (a field kept; a fresh chat; stages out of order).
`scripts/tests/test_package_digest.py`	a part file’s uses kept on Windows too, the part walk keyed with `/`; generated public members after positional, named, nested and generic record returns; top-level getters and setters as declarations with their summaries, a getter’s body never read as a function; a top-level function or variable whose type is a nested record kept with its kind and signature, a private one not published, a record type ending at its own closing parenthesis; private methods/constructors omitted
`scripts/tests/test_walk_staging.py`	the walk stages the stock plug-ins where `plugins/stock.json` is absent, from `FILMOPEN_PLUGINS_REF` or `origin/dev`, and stages nothing where it is present; a failed staging is said with its exit code and ends the walk, on Linux and on Android, before any server starts
`scripts/tests/test_walk_import.py`	an import through the place’s own Upload, shown first; only settings-loading refusals retry once per second up to twenty seconds; accepted imports and other refusals are not resubmitted, and old events do not prove a new import, nor does a burst of 60 later events hide one; each wait prints its start and a refused log read’s code and detail; the clip’s player waits see their events past such a burst and print their time on completion and on refusal; a named wait prints its start, its outcome and its time; only a VM service URL’s auth code is masked, every other URL printed whole; only a tile’s identifier is a tile — never a place’s job, its button, a menu, Archived (n) or Add a place… — and a tile is waited for past a job that carries the file’s name
`scripts/tests/test_walk_none_logged.py`	the walk’s absence check (`none_logged_since`), with `log_tail` stood in: a `flutter.error` after the mark followed by 49 events, 50 lines back, found through the app’s whole ring (500 lines) and refusing the pass, its READ line naming the mark, the window, the count and the event whole, as received — its message, data and stack; nothing after the mark passing; no mark never a pass
`scripts/tests/test_plan040.py`	plan 040’s predicates on a document’s `media` container: a group’s objects in file order, nothing for an absent or odd group or container, and the live references of every group, an archived entry among them and a deleted one not, the retired `refs` never read; and every name a card gives naming its place — a place’s buttons, tiles, menus, Archived (n) and jobs, and Add a place…, a shot’s dotted stem among them — and the card’s stage, `media:<stem>.stage` and its three segments, while `media.add`, a stage of another segment, a tile numbered without its group and a group that is no lowercase word do not
`packages/filmopen_drive/test/drive_consent_test.dart`	what FilmOpen asks Google for, read without a browser or an account (§6.10): Google’s own endpoint and the loopback redirect; `access_type=offline` and `prompt`’s `consent`, without which no refresh token is ever issued and the application stops working an hour after every sign-in; `prompt`’s `select_account` beside it, the two words in one parameter (`prompt=select_account+consent`), so a browser holding one Google session still offers the others; the one scope; PKCE’s S256 challenge against RFC 7636’s own test vector; a verifier and a state that are long, unreserved and never the same twice; and no client secret anywhere in the address
`packages/filmopen_cloud/test/cloud_sync_target_test.dart`	identity and layout bounds; bearer-only encoded routes and exact range/length/MD5/replacement requests; layout-first stray inventory filtering and strict admitted/find/receipt shapes; full, ranged, EOF and empty-file fetches; all Cloud refusal codes/verdicts with 401 never replayed; malformed reasons; empty/reset checkpoints; whole-media bound; concurrency refusals; thrown token errors and timeouts retry without a request; original source errors pass unchanged with safe read-stage failure logs; stream EOF/error/cancellation/abandonment; correlation, decision reasons and log privacy. A missing file through the modelled route is retryable notFound; named whole-file refusals retain their verdicts and log the validated server code or unknown with the server’s own explanation; no token is the code `noToken` with the verdict `signIn`, before any request; a send’s trail and a fetch’s name the file by its project-relative path as it is
`packages/filmopen_cloud/test/cloud_parts_test.dart`	Ordered four-part uploads with a short final part, checkpoints after open and every acknowledgement, four parts in flight answering out of order with a failed part keeping the contiguous prefix, its refusal naming its part, each answer its own time, and the resume finishing in order, the checkpoint’s own shape read and committed counts, resume from the next part, forgotten part and completion reset, completion-only retry after balance refusal, opaque encoded upload ids, reply bounds, exact source length and EOF failures, request, refusal and transport trails. Every named upload refusal retains its agreed code and verdict; safe server codes distinguish shared mappings; parts-incomplete resets before a byte-zero retry; a checkpoint not of its shape names `shape` and its keys, and a parts checkpoint on a whole transfer `whole`; the token never enters a line of any trail; the trail carries the path as it is; each request’s method, URI and control body logged before its bearer, an acknowledgement’s etag and a refused part’s own explanation (`says`) in its `cloud.body`
`packages/filmopen_cloud/test/cloud_sync_test.dart`	Cloud sends, agreement and other-device fetches through the real service; balance refusal on the retry ladder; source errors needing attention; an actual seven-part temporary media file interrupted with part 3 held, a two-part durable journal checkpoint and a new engine restoring the same job to send parts 3 to 7 plus completion; every checkpoint’s credential-shaped opaque upload id admitted through the real validator; Stop with part 2 held, cancellation trace, read-stage failure with two acknowledgements, no completion and no published file.
`test/drive_boundary_test.dart`	the application reaches Drive through `filmopen_sharing`: the root has no direct `filmopen_drive` dependency, and no Dart import or export under `lib/` reaches that package; workspace membership remains allowed
`test/render_boundary_test.dart`	who may reach the render packages (§4.1): no package but the application depends on or imports the render dialog, not even for a test; neither the format, the jobs, the insertion, the media, the state nor a page reaches the render queue through any package between, the pubspecs read past blank lines; and the walk followed to its end
`test/sample_media_test.dart`	the bundled sample as a session copy: extracted, every bundled file is on disk with no root, a write lands in its folder, and the next extraction starts from the bundle and removes the earlier folder; every take of the extracted sample is a file in its folder, which Add to comp takes, where the web’s overlay has none; on the web’s side the whole project is an overlay that reads the bundle and writes to memory, a second copy starts from the bundle again, the bundled folder itself refuses a write and answers a length, and a take written into a session copy’s `media/` is loaded as a take of the project
`packages/filmopen_state/test/localization_test.dart`	messages, field labels, diagnostics and tree text, and a dotted leaf path read as words; English the one language shown while FilmOpen is in development — `shownLocales`, a stored or system language naming another resolving to English, `keepsLanguage` telling a frozen language from one the app lacks
`packages/filmopen_format/test/flat_json_test.dart`	the flattening both Compare and the generic View read (§13.3): dotted paths, a list kept whole, a top-level-only skip, an empty object contributing no path; `mergeOrder` keeping an equal order, a right-only key beside its siblings or first, a left-only key in place, disjoint and empty sides, and its scan never going back over what it placed, each right entry read at most twice; and that what a value row never shows is the header keys less `name` plus `blocks`
`test/responsive_test.dart` (a 360 dp phone and the Galaxy’s 411 × 891 among the overflow widths, Settings’ theme segments keep every label on one line at 360, 375, 411, 532 and 1200 px, with the icons kept at 1200; a window too short for the rail, 1200 × 300 in both themes, scrolling it so that the account’s profile and Help are reached and the profile opens its popup, the rail no wider; a resize across 700 px while Settings or Activity is shown, and while Settings is hidden behind the project page, failing no assertion of the framework’s with the semantics on, each page taking the window’s layout as it is shown)	the two layouts (§9.1): the tree back on the page at 700 px and above, the remembered sidebar width seeding a fresh split after a trip to the drawer, one field to a row below 560 px of pane — checked at a 559 px window, the page then the whole window, where the fields would otherwise have shared one, since below about 344 px they would not have fitted anyway — and several to a row at 1600 px beside the docked assistant, a comparison that keeps two columns, a 28 px gutter and rows with height at 375, 532, 700 and 1200 px without ever scrolling sideways, nothing overflowing at any of twelve widths from 180 to 1200 px in dark, the tree’s header keeping a readable project name at the sidebar’s own minimum with the handle moved under it, a label going above its chips where beside would crush them, a comparison’s headings travelling with its rows where the page is short, and the header above the tabs never taking the height the tabs keep, with the bar that says it was cut
`test/covered_resize_test.dart`	the window crossing the breakpoints under a slide-out or a route (§9.1), with the semantics on: 375 → 1200 px with the AI assistant’s slide-out open, the docked panel taking its place; the slide-out closing as the window crosses; a dialog open across the crossing — no assertion fails, and the page takes the window’s layout once it is uncovered; the dock’s chat open in the slide-out across 375 → 1200 and 999 → 1000 px, the docked panel showing it with its unsent text, and the slide-out showing it again on the way back
`test/settings_layout_test.dart`	Settings → General below `assistantDocked` (§9.1, §9.4): at 700 and 999 px of window, General’s first row clear of the assistant’s floating portrait, at least 8 px between them
`test/main_jobs_folder_test.dart`	the start (§6.11): `main.dart` looks the jobs folder up once, before the renders, the servers and the insertion, and gives each that folder, so one `app.folder jobs` line per start; read from the source, since a unit runner’s start stops at the preferences
`test/frame_test.dart`	the window’s frame (§9.1): `assistantDocked` never below the narrowest uncrushed frame; the start inset below 700 px and the end inset below 1000 at six widths; `layout.frame` once at start and at each change — of a breakpoint, of the page’s floor, of a section — with the widths where the floor bites; at 360, 375, 411 and 532 px one drawer holding the rail and, on Project, the tree, a hand’s width of the page left, the menu button a back arrow while it is open, a section chosen keeping it open and Watch without a tree, a row chosen, the back arrow, the system’s back and the scrim each closing it, each logged with its cause and, at a close, its time; at 700 and 1200 px no menu button and the rail in view; the drawer open across 700 px closing, the detail pane’s element kept both ways; the page’s first row clearing the menu button; at 1200 px the docked panel full height at the right with nothing above the page; at 375, 532 and 700 px the portrait at the upper right sliding the assistant in from the right, a hand’s width left, and its close; remembered 560 and 540 at 1200, 1000 and 1600 px, the assistant giving way first, then the tree, the page keeping its 360 and the widths coming back; nothing overflowing at 700 px on any section or in the slide-out, light and dark
`packages/filmopen_format/test/entity_fields_test.dart`	the field table the assistant writes to (§5, §6.11a): for the character, location, outfit and prop, every path of its form’s map in its shape (text, number, list of strings), prompts and creator notes left out, `name` first; each field with a widget of its own and each vocabulary (a character’s kind, aliases, summary, age, gender (one of `male
`packages/filmopen_format/test/field_maps_test.dart`	the records (§5): the fifteen types a command writes and no other, each holding the Project Specification’s keys — the common header and content, a library entity’s epoch, media, preview, picks and render stage, a scene’s epoch, its own — closed, its header and name required, a library entity’s epoch and a plug-in’s `api` with them; the block’s keys, `metadata` among them, none required; the nested records closed and the main ones pinned key by key, a prompt’s `positive` required, `metadata` and `x` open, a media entry open with its `reference` required; each dynamic map with its key in its description and its value; a scene prop a tag or `{prop, epoch}`, a shot’s and a cue’s blocks ids; the four box maps read from the records, a path they lack refused; lines for a scene, folder, project, style, misc and document, `name` first and `metadata` named, a scene’s blocks without what the writer keeps, a project’s `lang` a BCP 47 code and its nested example
`packages/filmopen_format/test/content_check_test.dart`	new content held to its type’s records (§5, Project Specification §18.3): a block of `type` and `text` refused key by key with a block’s keys; a location given as a stem accepted (the reference check’s); a nested typo refused at its path with its record’s keys, the same under `metadata`, at the top and in a block, accepted; a value of another shape, a dynamic map’s value, a missing cast character refused; a media entry’s own keys kept, its reference required; `x` and plug-in settings open; a folder’s, project’s, shot’s, cue’s and plug-in’s `epoch` refused and an old one’s deletion accepted; a plug-in’s header alone refused for its `api`, a complete manifest accepted, its key slot’s, offer’s, action’s and setting’s required members missing reported, a sharing operation in a list that replaces whole missing its three, a partial change of an offer or a setting accepted; a CDL triple of one, none or four numbers refused; as a change: create’s `{}` for every type and a synopsis alone, a `null` deleting at every merge boundary an old unknown key included, an unknown key with a value refused, a `null` in a list that replaces whole refused, insertions, a deletion and a cleared key accepted, a block’s unknown key, a `null` inside its replaced object and `blocks: null` refused; as a whole document: every type’s header and name required, a misspelt key refused, the specification’s scene accepted; a type no command writes an argument error. `contentKeysSchema` every type’s top-level keys, self-contained, an unknown key only as a deletion, the fifteen under 16 KB; `contentGuide` naming the nested shapes from the records.; the tools’ guide holds every writable type’s `fieldShapes` lines (a character’s `appearance.face`, `voice.lang`’s BCP 47 rule, `default_outfit` a tag); each written type’s line names its change view’s top-level keys (`notes`, `creator_notes`, `media`, `prompts` among them)
`packages/filmopen_l10n/test/labels_record_test.dart`	An import change its type’s record refuses said in one sentence naming each path once (§6.18).
`packages/filmopen_format/test/field_paths_test.dart`	a form’s box on a nested key: the text it starts with (a string, a number’s digits, a list one per line), creating the objects on the way and leaving siblings alone, an emptied box removing its key and every object left empty, clearing what is not there changing nothing, lines and numbers (text that is not one writing nothing), never writing into the document it was copied from, and a value of another shape — an object on the way that is not one, an object where a word goes, a list holding an object — left alone; `canSetPathText` answering what `setPathText` would write — a list or a string on the way none — writing nothing
`test/character_location_form_test.dart`	the forms: the listed A.1 and A.3 editable keys, including `birth_date`, owned by a field (collected over the whole scrolled page), each section with its icon — General first —, each prompt a Prompt card with its title on its one header, inside the media card, and Creator notes a section of its own, a box named without its object, the media keys gone from Other, opened, and a file’s `arc` shown there as an unknown key, with no box; typing a nested key writes it beside its siblings and emptying the last key of an object removes the object; a draft observer (the recorder’s seam) hearing a chip’s token, a box’s trimmed text and a relationship row’s list; the voice chips choosing, a second tap removing, a second choice before the save — a tap’s or an agent’s — shown at once, an agent typing a token through `FieldRegistry`; relationships added (one untyped row at a time) and removed with the row below moving up; a value of another shape locked with the reason, written over by nothing and shown in Other, opened; the location’s kind, time of day and lines written; Located within listing the other locations by name and not itself, writing the tag, an agent’s tag that is no other location writing nothing, None removing it, and a tag no location has kept and said; another author’s version with every field and no chips or row controls; Compare pairing the new sections and copying a nested key left without removing a sibling; nothing overflowing at 532 and 700 px in dark, scrolled to the foot of both forms; what a voice’s previews say (`voice.audition_text`) one box, on the voice’s Prompt card above Voice samples, not in the Voice section
`test/character_location_form_test.dart` (prompts)	a prompt’s words typed are the person’s: its `plugin` gone, its sibling’s kept, the writer stamping it; the sheet prompt’s and the voice prompt’s boxes writing `prompts.sheet` and `prompts.voice`, never a legacy key
`test/character_location_form_test.dart` (gender)	Gender is one chip row in General, none in Body: Male, Female and N/A write `male`, `female` and `nonbinary` (at 1600×1000 the three sit on one line), each save’s `draft.save.done` naming the value; a file’s own word (`woman`) is a chosen chip of its own and survives an unrelated edit; the chosen chip tapped again removes the key
`test/plugin_sections_test.dart`	a plug-in’s card on a character (§9.4): a text box, a pull-down and a switch typed through `FieldRegistry` and autosaved under `plugins.<tag>.<key>` of the version being edited, another plug-in’s data kept, a token the pull-down does not offer and a switch that is not true or false writing nothing, an emptied box removing its key; the card locked and legible on another author’s version; Compare pairing the card and copying a value left; 700 px
`test/plugin_hook_test.dart`	Plugins… on a page (§9.3): a scene’s file menu running the template’s rewrite on the version shown, its progress and Stop, Written: … and a 44 px Open it showing the new version; Stop, and closing the dialog, cancelling the run; the item absent on a type no plug-in rewrites; an empty username, `default`, offered the item as any other author is; a refusal said in words at 700 px; Plug-ins asked while the draft is written and film B (holding the same stem) opened meanwhile, opening nothing, the draft written in A
`test/outfit_prop_media_test.dart`	an outfit’s and a prop’s media places (§9.0, §9.3): Reference images, Outfit sheets or Prop sheets, then Inspirations, by their titles, never the raw key, no other type’s sheets and no Add a place…; through the file dialog, pictures alone offered, a sound and a clip named as refused, a picture placed in that group with its file and its thumbnail; a drop on the place refusing and naming a sound and a clip and placing a picture there, not in Reference images; a prop’s Reference images taking a picture by drop and by the file dialog; a prop’s sheet taking a render through the add tile’s Render, the render dialog a stand-in, the request handed to the insertion as a render producer’s source for that place, picture-only, nothing run
`test/completions_bound_test.dart`	the file menu’s Edit JSON… asked for while A’s draft is written and B opened meanwhile (§7): the draft written in A, the editor not opened over B, no uncaught error
`test/open_drafts_first_test.dart`	opening another film writes the open drafts first (§7): a draft typed inside the autosave’s delay lands in film A before B is read; a write held in flight and a later text typed behind it both land, the last after the first, before B is read; a draft refused as stale — the file changed on disk — refuses the open from the project menu, A staying open with its form’s Discard my changes and re-read, the change on disk not overwritten, and the page saying the other was not opened; a re-read of the same film is no open, its draft written as ever
`test/outfit_prop_form_test.dart`	an outfit’s form (Project Specification A.2) and a prop’s (A.3): every key owned by a field, collected over the scrolled page, on Edit for the viewer’s own version, General first and the media card below it; an outfit’s description after the name, seeded, typed, saved and read back; a garment’s prose seeded and its unknown key kept; a garment added, typed, emptied while retyped (kept on screen, not written) and removed; a garment value of another shape locked and kept while its neighbour is typed, Add garment disabled with its reason while an empty garment is on screen; Compare pairing the garments and `<` taking the other’s into the left editor and the file; an outfit’s condition as A.2’s chips, a token written and the same chip removing it; a palette of hex and names one per line; a prop’s kind as A.3’s ten chips in order, one chosen and written, Hero prop a switch writing `false`, its condition a prose box; another author’s outfit and prop locked — boxes read-only, no Add garment, no remove, the switch shown as Yes — with nothing written; the library’s prop locked; a `hero` that is no boolean shown locked; the chosen sheet — one a reference, two a list, none no key, a reference the place no longer holds kept locked, through the agent’s field setter as through the chips, on both forms, another shape left to Other attributes, and the empty state; both forms at 1200 and 700 px without overflow
`test/generic_view_test.dart`	View for a type with no form (a style when a location got a form; a shot and a style since a prop got one, values rendered on a style of a tiny fixture): a scene’s story epoch as a value row and a location’s filename epoch not, every leaf path the Overview tab reached is still reachable over the whole sample (walked independently of the code under test), a scene’s blocks as rows against a cue’s `blocks` as a value, values rendered rather than printed as JSON, the header-disagreement card and, in a scene’s Other opened, File and an empty object surviving in Other attributes, the file menu’s editor and clipboard, the pending draft written before the editor opens, and no overflow at 532 and 700 px (a width `pumpApp` now honours — it used to fix 1600×1000 over whatever the caller had set, so both of this table’s width claims were made at 1600 until); a scene whose `blocks` holds ids keeping them as a value, and an empty script drawn as the editor
`test/json_editor_prompt_test.dart`	a person’s save through Edit JSON… is a hand edit (§9): a prompt whose words it changes loses its `plugin` and is stamped, one whose words it keeps stays its writer’s, its stamp carried where it was current; `json.saved` counting the prompts cleared, and their words in the log; a text that is no document refused in the dialog, its `json.save.start` with the text before the timed `json.saved` with the parser’s error
`packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_dialog_test.dart` (the place’s prompt)	`renderPromptAt` by place — a sheet’s, a reference’s, a frame’s block’s, a block’s clip its own `prompts.clip`, never the scene’s, a prop’s sheets its sheet prompt —; the dialog’s card target and prompt path for every row of the places’ prompt kinds, none at inspirations, motion clips, voice samples or a cover; the outfit’s sheet over the character’s reference; a prop’s sheet render opening on its sheet words
`test/compare_test.dart`	two-column Compare (§13.3): the viewer’s latest on the left and the selected version on the right with their rows level, a key only one version has blank on the other side, its row in place, no File card, Show changes only on at first with a scene differing only in its weather showing that row alone, every label above its box and no hint in an empty one in a comparison while View/Edit keeps its own, no Select Style, no token pull-down’s None (its label above, a filled one keeping its choice, the menu’s None chosen leaving it empty), no scene’s empty blocks (empty), no empty sheet’s sentence, no generic or residue row’s dash, no empty relationship, cast or garment list’s words, no scene picker’s placeholder there, and the Add epoch dialog opened from a column keeping its hint and its label, the reasons the tab refuses to open (none of them a missing username: one never chosen is `default`, who is asked to fork as anyone without a version), the question a reader with no version of their own is asked and both its answers — No writing nothing and Yes forking the version on screen without moving the page — and that nothing compares across epochs
`test/compare_embedded_test.dart`	Compare embedded (§9.3), several on one page: no vertical `Expanded` and no vertical scroll view of its own; a create with no right column — one `FormSide`, an absent cell beside each row, no copy control; a `before` column locked, taking no `>` while its `<` stands; every identifier unique on a review page, a patch’s two columns of one stem included, every field and copy control under `compare[<n>]`; two items of one stem as the ledger makes them — the project file’s listing patched twice — and a patch with relationships and a cast, every identifier on the page its own; no column bordered for being picked; a create’s right column blank beside each row
`test/session_page_test.dart`	an assistant session’s review (§9.3): the line above the headings, Edit character: Kira through the record’s own assistant’s catalog and the entity’s name, the ids where the catalog or the entity is gone, none on an old record, the origin logged on `session.review.open`; the record’s page is the review, with its header, Your current picks, the summary drawn from the items (a create’s listing patch left out, the record’s own words not shown; six entities in one sentence by verb and type, plural where several), one Show changes only and an embedded comparison per item; the sides per kind — a fork beside its recorded base, copy both ways on her own version, a create beside a blank column with no heading, a patch’s empty old value beside the new one with its `<` drawn disabled, saying why; each item’s title staying under the header while its form scrolls, pushed off by the next, a field revealed below it, an editable box’s typed text, selection and focus kept across a scroll and across the 240 px line, each pinned title opaque; an item’s name opening its page, logged, a patch beside its Before this session never written into; a fork beside its base for a viewer whose version in use is the fork; no item saying it changed since the session, no hash kept; `session.review.open` with every item’s columns, reasons and outcomes, no hash; 375 px light and dark with twelve items, nothing overflowing; the Picks, at 1200 and 700 px: a Pick over each column of a fork, the check left of the word, grey, and green with white text where its version is in use, back and forth, Pick all green once every left is; a create’s and a patch’s left alone; Discard’s tooltip that it ends the chat; a legacy `accepted` item’s Picks and Discard pressable; the actions: Pick through the review, the commentary picking the version, the item still open, nothing closed, said on its row, still pressable; Discard writing the left draft first, the review then setting aside the file as written, `session.review.settle` logged; a draft that cannot be written stopping Discard before the review, Your edits could not be saved first on the row, the item open; a create discarded, set aside and said, its heading its name and not its tag, its listing following, its Pick then Already decided., and a later Pick all keeping that answer; a later patch’s item picked, its fork’s item discarded, and Pick all‘s skip of it then saying This version is discarded already., not the earlier Picked; Working… on the item’s and the all buttons while a write is held; a `stale` answer offering Re-read files, which reads the folder again and clears the answer; a listing patch’s Discard recording it with nothing written (`follows-children`); Discard all newest first, each item’s answer on its row, the listing following and a character’s patch no longer the round’s draft refused `in-use`; with the chat still live, on the open session’s page: Pick all picking with the chat kept, its record open, nothing moved and no model asked; Discard all with a call in flight moving the page onto the record before the close, the same page’s state kept, its buttons Working… until the call lands and the record closes, then every final item discarded and the move and the close logged; Discard all with the answer on its row; a move elsewhere during the close still reviewing, the outcomes landing on the closed record; a move elsewhere while a draft is written before Discard closing the session without bringing the page back (`moved: false, reason: page left`); Discard all on a live session with a listener on the location as the dock’s: no model asked, the record’s summary the items’ words, the page starting the one close and the dock’s joining it, the location woken on a record’s values with that close already begun; a create under Show changes only: its rows with a value, no empty card, what it hid in `compare.filter` (`created: true`); no conversation on the page, its words and tool calls not shown, `messages` still logged on open; an epoch the chat declared inside the Project item’s comparison, in its Epochs card after the Synopsis‘s and below the item’s fold, Epoch: …, its line, a Discard and no Pick, left out of the summary, `project {item, epochs}` logged; the Project item closed, its fold and no epoch row, opened, the epoch and its Discard; scenes inside their episodes, at 1200 and 532 px: two episodes and three scenes created at the top by the live chat’s commands and moved into them by `move-entity` (the lists the chat’s drafts), each scene under its episode in the episode’s order and stood in, Mia outside the script in her place, the items’ numbers as created, `session.items.placed` with each depth and nothing unplaced; a scene the chat edited in an episode it never touched, under that episode’s heading `session.heading.fo_ep9` with no Pick or Discard, logged in `headings`; a chat that only declared an epoch, under a Project heading with no Pick or Discard of its own, closed until `session.project.fold` opens it and closing again, `session.fold.open` and `session.fold.close` logged with the epochs; at 375 and 700 px, light and dark, a long epoch label fitting; the folded item, at 700 and 1200 px, light and dark: closed, the media card in View, the first row after the name fading out with the arrow at its right, an item with no other words its arrow alone, no comparison, no dormant box, no field in the fade; opened, its comparison alone built, without the media card, `session.fold.open` logged; Tab reaching the arrow, the title, Pick and Discard and never a closed item; closing writing the edits first, then reopened from the file as written, a clean close logged `clean`; closing while a write is held waiting for it, the arrow Working…; a refused write keeping the item open with Retry, `session.fold.refused` logged; both columns writable, an edit typed into the left while the right’s write is held keeping the item open (`editedMeanwhile`), the right written, the left then written by its own autosave and the next press folding it; a reference written while the page is open showing at its item’s top, the item still closed; the clipboard asks (§4.2), as the agent build installs them, over a clipboard holding text: a session that created 20 places building every item’s form, on screen or off, more than 40 fields, their asks at most two native ones, typing’s rebuilds at most one a frame, and a `clipboard.hasStrings.done` naming more than 40 callers
`test/clipboard_binding_test.dart`	the product’s binding (§4.2): `main` makes `FilmOpenBinding` once, before `runFilmOpen`, which keeps whatever binding exists through `ensureInitialized` (read from the source); the binding made in the test’s own isolate, its messenger a `ClipboardAsksMessenger` and `ensureInitialized` answering it
`packages/filmopen_forms/test/write_actions_run_test.dart`, `write_actions_view_test.dart`	`WriteActions.run` answering a write that landed unpublished with its sentence and Re-read files, which re-reads (§7.5); the version label written over the person’s own save while its publication still lists, through the real controller, never refused stale; the JSON editor’s Save after a change of the app’s own landed while it stayed open refused as stale against the document it opened on, the change kept, and after Re-read files written over the file as it is now
`packages/filmopen_forms/test/draft_saver_test.dart`	the autosave on its own (§9.3): nothing written until the draft has been still for the 700 ms the form uses, one write at a time with a keystroke during a write keeping the draft dirty and Saving… observable while a deliberately slow write is in flight, a change typed during a write whose form is then disposed written once against the text the writer handed back, and, when that write fails, logged with what the draft held and not tried again, `settle` waiting for the write in flight and writing what came after, `settleOpen` answering false while one draft is refused, forgetting a disposed saver and waiting for the write it left behind, `adopt` taking the writer’s hand-back as the base whatever the writer settled in it, another file’s never, a re-read during the write ignored and the next keystroke written against the hand-back, a re-read while dirty ignored even where it holds the draft’s own write, while clean its times taken or the boxes re-seeded, a fork another file written first, a nested change never reaching the file’s JSON, a change that changes nothing writing nothing — after the delay, and on leaving the form or moving to another file before it —, an outside change refused while the draft is dirty and the same re-read adopted when it is clean, and a pending draft written when the form moves to another file or is disposed; the draft observer (the issue recorder’s seam) hearing the trimmed text, a chip’s token, a relationship list, a removed key as null, a copy-left’s several keys with no value, and every change as it is made, whether or not it changed the file; and, a change from below the forms (`OpenDraft.apply`, §7.1): the registry finding the saver by the file it is on and following it to another file, the last registered of two answering and a disposed one no longer, the change written now with what was typed and not yet saved, a write in flight waited for with what was typed during it going out too and no third write, a refused write as the answer with the draft keeping the change, an older failure not making a later success a refusal, and the observers hearing the key; `snapshot` includes an in-flight document and later typing without exposing its nested maps or changing `pending`; the saver’s `refusal` — none while it waits and once written, the stale error once refused — and `OpenDrafts.settleOrRefusal` answering it; a plug-in’s setting the app does not know written as it was by an autosave, and the file the writer hands back the base of the next write; a change of username with a real saver typed into during its own write, the typing written in a second pass as the old username before the new one is taken; a write a form began on its own during a pass waited for before the username changes — landed, the change taken after it; failed, the change refused in its own words; each draft line naming its file as `{type, stem}`, the stem as it is, each write naming the fields changed with their values and count, and its end — written with the hand-back’s values — a script block’s stamped time included, typing during the write not — and whether the writer handed the file back, the `updated` it stamped, or unchanged with no `handedBack`, the write of a file left by a move `handedBack: false` — — a change that names no key by the top-level keys it changed, its values there when the write is refused, a field discarded with its refused draft not named by the next — and nothing logged per keystroke; a change from below the form writes what was typed first, as its own write, then the change (§7.4); a write that landed but was not published: the re-read showing it leaves the draft clean with nothing written again, typing after it stays to be written against the file read back, the stamped prompt time taken, and the status offers Re-read files, never Retry; leaving the page while a stale refusal stands: the detached write’s `draft.save.start {reason: leave}` ended by `entity.saveFailed {detached, stage: write}` with the refusal’s error
`packages/filmopen_forms/test/draft_saver_test.dart` (the writer’s times)	the draft takes the file’s and each block’s `updated` the writer stamped, and keeps what was typed during the write (Project Specification §7, §10.3); a re-read showing a write whose publication failed gives the draft the prompt’s `created` the writer stamped, so the next write carries none older
`packages/filmopen_forms/test/draft_attribution_test.dart`	the saver and the attribution (§7.4), through the real saver and controller: a dirty form flushed inside a chat’s write is unattributed; typing between a create’s two settlements is one unattributed write, then exactly one attributed listing whose `before` holds it; typing while that settle is being written settled again, as the person’s, before the listing; an autosave already in flight when the listing arrives waited for, the typing during it settled, the listing’s `before` holding every word; a patch waiting behind the person’s save B, with C typed and the form left, written against C — the detached write of C adopted as the draft’s own — the file holding C and the patch; a conflict refusal logging both identities compared, its mutation never run
`packages/filmopen_forms/test/prompt_adoption_test.dart`	the draft takes a prompt’s `created` from its own write: a save during typing adopted, the next write neither stamping again nor stale; settle, then a prompt applied without `created`, with the same words and with others, ending current; a refused settle applying nothing. A carried neighbour’s `created` is adopted too: the second save stamps nothing and is not refused.
`packages/filmopen_forms/test/prompt_card_generate_test.dart`	Generate through the form’s own autosave: a write in flight when Generate is pressed is settled before the words are applied, so a writer answering the same words ends current, `created` equal to the holder’s `updated` (an apply before the settle fails it); no outdated shown or logged while the words wait for their stamp; the saver is the card’s `EditableDraft`
`packages/filmopen_forms/test/prompt_mentions_test.dart`	`@` in a prompt (§9.8): a character’s sheet prompt offers its inspirations and references and no character, its reference prompt its inspirations, a choice a chip named after the picture and the file holding the token; the voice and the treatment offer no chooser; a frame’s `@` offers the film’s pictures by name, a mouse choice keeping the block open and saved through the block; a frame token naming nothing the unresolved chip, repaired and removed, each logged with the token it replaced or removed and the target chosen; the chooser’s opening logged with the targets it offers; a scene’s frames taking the form’s one source of their kind, made once, and a frame’s chip following another viewer’s sheet; a block’s action still offering entities; a prompt source following the viewer; the candidates reading the saver’s draft before it is written — a box already drawn refreshed, one drawn after made from it
`packages/filmopen_prompt_ui/test/prompt_mentions_test.dart`	`@`’s line where nothing matches (§9.8): a sheet’s, a frame’s and a clip’s prompt offering retained unreviewed pictures just like kept ones, with an unmatched query saying No picture to name, as does a reference prompt with no inspirations; the voice and the treatment none; `mention.empty {kind, query, reason: none}` once per answer; the film’s candidates listed once a binding and looked up in that list, another viewer listing them again (`mention.candidates`); a prompt’s file read again with the same pictures keeping its list, unlogged, and a picture added changing it (`prompt.mentions {reason: changed}`, with per-target reference and flags); a draft typed beside the same media resolving no picture, the same groups in another order building again; a prompt’s media looked up by target, not by walking its list per chip
`packages/filmopen_text_ui/test/prose_owner_report_test.dart` (the chooser’s reports)	one listing a build serving the menu, the open decision and `prose.mention.opened`; each chooser action logging the values it acted on: the query or the token replaced, the target chosen and its name, the token removed, a refusal’s reason (`stale`, `field_refused`), the opening’s milliseconds; each naming its box, a chosen one its place in the source and the source it left, a removal the source it left
`packages/filmopen_text_ui/test/prose_editor_clipboard_test.dart` (the clipboard’s reports)	a cut and a paste whose platform clipboard throws each reported `prose.clipboard` `failed` with the box, the selection, the cut’s text, the platform’s message and the milliseconds, the cut removing nothing; a paste into a read-only box `refused`, `read_only`, before the clipboard is asked
`packages/filmopen_text_ui/test/prose_editor_test.dart` (the empty line)	a query matching nothing keeping the chooser open on the source’s one disabled line, asked once per opening and again at the next, inserting nothing, a match showing the candidates alone, at 700 px light and 375 px dark; a source with no line keeping the chooser shut, the default null
`packages/filmopen_forms/test/prompt_sections_test.dart`	the Prompt card on every editor (§9.3): a current prompt one line under one header, the card the section and not inside one, its boxes drawn when opened; the character’s voice card after Voice with its negative, then reference and sheet, Creator notes a section of its own after them; the location’s, outfit’s and prop’s cards and notes; the treatment’s card its own, not folded; a typed word taking a writer away; a scene’s blocks with two frame cards each, with no media, empty or saved, typed words written to the block through `withBlockPrompt`, Generate on a block given the block’s id; Generate handing the writer the tokens the chips name — a character’s sheet its live inspirations then its references, its reference prompt its inspirations, its voice none, a frame the film’s by holder — logged in `prompt.generate.tokens` as they were handed, their count beside them; another author’s version read-only with its reason and no Generate; the page left while the writer answers, the answer dropped, nothing written then or later, `pageLeft` logged; nothing overflowing at 375, 700 and 1200 px; the cards in the media card above their places — a character’s reference, sheet and voice in that order, before Features —, a prop’s sheet prompt among them
`packages/filmopen_prompt_ui/test/prompt_words_test.dart`	the hand-edit rule (§9.0), `withPromptWordChanged`: a changed word, positive or negative, takes the prompt’s `plugin` and `writer` away and answers the pair it cleared; an unchanged one keeps it and changes nothing; an emptied side removed; a block’s frame prompt addressed by its block, made where there was none and removed whole when emptied
`packages/filmopen_prompt_ui/test/prompt_card_test.dart`	the Prompt card alone, on a stand-in draft and stand-in writers: empty, current and outdated with their borders (prototype, final, draft dashed, red), one line when current, turning outdated opening it, `prompt.state` once per change; the ages; written by a writer and the author; the writer Render would ask chosen first, Smart with a model and Basic without, the first offered where neither is, logged `prompt.writer.default`, Basic chosen over Smart surviving a change of model; two writers of one plug-in chosen, asked, saved and named by their pair; no writer said and Generate held with that reason; an LLM writer’s model and rate under the pull-down, rate unknown, Text model unknown, nothing for a template writer, logged `prompt.card.llm`; the host’s change listing the writers again, the line following, the person’s writer kept or replaced (`prompt.card.relisted`), the listener gone with the card; a writer refused for want of a key said in a sentence, a chosen model gone keeping its code; Generate writing the words, the negative and the writer’s pair without `created`, removing an old negative, given the unsaved draft, settling first, a refused save dropping the answer, `no-prompt` and a failure said, one at a time; read-only with no binding; a `created` of another shape read as no time, never a broken card; the draft let go while it settles, the answer dropped, `pageLeft` at `settle`; open, the header’s whole attribution; no overflow at 375 and 1200 px, light and dark; Generate telling its owner as it starts and as it ends, written or failed; the owner’s `tokens` asked once as Generate starts, never to draw the card, handed to the writer and logged in `prompt.generate.tokens` as they are with their count, and none with no owner’s `tokens`; an owner’s `tokens` that throw logged start, then `failed` at `tokens` with the error’s type and message, then `refused`, the writer never asked; a model given by the caller asked with the writers and Generate, with the covered blocks, and none without one, the lines carrying the model as it is, the stem as it is and the block’s id; Generate’s lines the writer’s pair and name, `.settled`, `.done` and `.refused` the words; a change of model reading the writers again and keeping the person’s writer; a Generate for A with B chosen while the writer answers, its start, tokens, settled and done lines all naming A; nothing overflowing at 375, 700 and 1200 px, light and dark, with an LLM writer’s line. Outside a selection a card has no Generate box.
`packages/filmopen_prompt_ui/test/prompt_generate_test.dart`	What the card and the tab’s Render share: what a Generate box reads, a prompt’s place and writer target per kind, the holder’s time, `withWords` in place, `askWriter`’s answers and what it hands on, and the sentence of an answer without words.
`packages/filmopen_forms/test/prompt_mentions_test.dart` (the negative boxes)	a negative box offers no chooser of either kind (§9.8): an entity’s sheet and reference negatives plain boxes, not prose falling to the film’s entities, and a block’s first-frame negative a literal prose box, its words written as typed; the chip removal’s `prose.mention.removed` carrying its `ms`
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the dialog’s `@`)	the render dialog’s prompt a `ProseEditor` (§9.3, §9.8): at a sheet’s card `@` offers its inspiration and reference alone, a choice a chip named reference 1 writing `@reference-1` to the page’s draft, typing beside the chip keeping the caret (the draft’s words compared as written), `render.prompt.bound` saying `mentions`; a voice designed offering nothing and the treatment no prose box; the negative box a plain one offering nothing
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the cards and the tokens)	voice design’s card on the character’s `prompts.voice`, typed into the page’s draft, its Generate asking the writers’ `voice` with no token, the audition its own box, and with no voice prompt no description sent in its place; the card’s Generate handing the writer the place’s tokens of the draft as it stands, a reference added on the page included, named as their chips are
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the kind following the words)	a token typed into a token-free sheet prompt, or taken away, turning the kind `t2i` ↔ `i2i`: Render held while the picker is asked for the new kind, the offers read again and its answer landing, `render.kind.start` and `render.kind.done {outcome: landed}`; Generate writing a token turning it through the draft’s notification, a model chosen by hand under the old kind replaced; a change replaced before it lands `superseded`; a reading that fails `failed`, Render held with the stage’s no-recommendation reason; a new kind with no model ready leaving the card as it was — the same state, open, its words and its focus — and no refusal logged against the model being replaced; while the kind turns `i2i` → `t2i`, another edit model chosen from the offers still shown keeping Render held until the new kind lands and its model is sent with no picture; a model that needs a picture chosen with words naming none held with `references-needed`; a picture added to the draft under the dialog offered by the chooser, handed to the writer and sent for the `@reference-1` Generate wrote
`packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_commands_test.dart` (writing first)	the commands’ automatic writing before the model is chosen: the writer asked with no model and the place’s tokens, `render.prepare.prompt {writer: before-model, tokens}` before the picker is asked; at a character’s reference images a written … inspired by @inspiration-1 rendered as an edit given that picture; the helper at a character’s sheets with no words written `@reference-1` and prepared as an edit sent the reference
`test_plans/210_tokens-dialog.md`, `test_plans/run_mcp.py --plan 210`; `scripts/tests/test_run_mcp_selection.py`	a prompt’s `@` pictures from the form to the render dialog on an app of its own and a fixture of its own, no key and nothing paid: the form’s and the dialog’s chooser, Generate handing two tokens and writing `@reference-1`, the kind turning `t2i` → `i2i` and back as the chip comes and goes, a missing picture’s sentence, voice design’s card, the stage, Recommend, Images and the price, a frame’s `@ch_main-hero:character_sheet-1` on disk and its render opening on edits, the frame’s negative offering nothing; the runner’s selection taking 210 alone, after the other plans with an app of their own
`packages/filmopen_forms/test/concurrent_attachment_test.dart`	two cases through the real controller and DraftSaver: two producer completions preserve typed name and summary, unknown nested data and the draft snapshot, create two distinct references and two batch files, and acknowledge both original runs; with the first attachment refused, attachAgain keeps typing added before the retry and the same media bytes, finishing with two producer starts and no duplicate reference.
`packages/filmopen_state/test/plugin_roles_test.dart`	the seam by role (§7.1): the runtime in use is every role and the base they share; a class that implements `PluginInvocation` alone is not a catalogue, a settings control or a bench, and still calls; the members of each role, read out of the interfaces themselves, so a member that moves between roles — or down to the base, where every caller would inherit it — fails here, and the union declares nothing of its own but `attach`; each package names only the roles it uses, read from its own sources outside its comments, so a call site that reaches for `PluginRuntime` again fails here; and the no-op runtime answers every role without a plug-in — the app’s own key owner and nobody else’s; `callServer`, `promptWriters`, `buildPrompt`, `decideStep` and `runOffer` members of `PluginInvocation`; `scriptWriters` belongs to `PluginCatalogueView`, and the no-op workflow calls return empty/null/notAvailable
`packages/filmopen_state/test/shared_offer_test.dart`	`SharedOffer` (§6.11, Lending): written as the person reads it and read back the same, the server left out for this computer; an entry not of the shape — the id not a UUID, an empty string, a price with a third fractional digit or a trailing zero, a server without its two strings, params not a map — left out of a list and the rest kept, a list that is not one empty, the accepted prices; the inert client refusing a declaration’s version and a publication `lending-unavailable`; whole cents kept as the design spells them (`usdOfCents`: 2 → `0.02`, 20 → `0.2`, 100 → `1`) and read back (`centsOfUsd`)
`packages/filmopen_state/test/plugin_roles_test.dart` (the summary’s dependencies)	`PluginSummary.dependencies` (§9.4): none by default, the tags given kept in order
`packages/filmopen_state/test/project_provider_test.dart`	the controller’s re-read: opening another folder drops a re-read of the previous one still in flight; `openSample` in both modes extracting the sample into a new folder of its own, a writable session copy that is never remembered, every earlier folder removed; an `openSample` a draft refuses extracting nothing and leaving the sample open, and the next one keeping the folder still in use; closing writing the open drafts and the next open ending the closed state; Copy to a folder on a temp folder — every listed file copied into a folder named after the project and the complete project opened there — a folder that already holds files refused, with nothing written and the session copy still open, a copy failing part-way taking its folder back with nothing escaping it, a target that is a link refused, with a sentence of its own and nothing written through it, and a project named after a Windows device name copied into `project`; New project’s folder written that will not list not opened — `ProjectNotOpenedException` naming the folder and the read’s error, the project on screen kept, no loading state, nothing remembered, the files written; and `projectSourceKeyProvider` being the format’s `projectKeyOf` and nothing of its own (§5.15) — no project answering none, two session copies of one label being two films, and a re-read of one source keeping the key
`packages/filmopen_state/test/project_provider_test.dart` (cast versions)	`createCastVersions` (§7.3): two missing versions, ambiguous source with continuation, sole non-default source, occupied target skipped, null viewer, no pick, cast epoch override, overlapping helpers making one version and refusing one targetExists, unexpected write failures answered without an asynchronous error; no draft settling or block-only speaker creation
`packages/filmopen_forms/test/scene_cast_versions_test.dart`	scene autosave companions (§9.3), light and dark at 700×900: creation and message; refusal preserving the save; disposal without another scene write; unchanged content skipped; unlabelled era token shown; an unrelated tracked write and a held companion proving the save completes independently without settling drafts; creation-only messages staying four seconds and any refusal ten, including a creation before a refusal; PNGs written only to the nonempty `FILMOPEN_CAPTURES` folder, assertions still run when unset
`packages/filmopen_state/test/new_project_parent_test.dart`	where New project proposes a project (§9.2): `parentFolderOf` cutting at either separator, naming no POSIX root and keeping a drive’s root as `C:\`; the documents folder with nothing known, the parent of the last project opened, the folder the last project was made in whatever was opened since, a saved one since deleted giving way to the documents folder and never to the opened project’s, and with none saved the opened project’s folder since deleted giving way to it too; a documents folder the system will not name an error, a known folder proposed without asking for it; nothing proposed on a phone; the documents folder none on a phone
`packages/filmopen_store/test/copy_left_test.dart`	— and the media card’s own copy: what the left lacks added per group, whole with its keys, and nothing removed; an entry with flags copied into the same group as it is; an entry both hold taking the right’s set flags and note and losing none of its own; a deleted entry never copied, nor its flag; a reference the left holds in another group left there and not added twice; `preview` copied as any other word and only where it differs; nothing offered when the left already holds everything; the keys named for the message and the log; a `media` or a group of another shape left alone and announced nowhere; no container the left shares with the index written into
`test/compare_copy_test.dart`	copy-left on screen: a block’s line ending with its beats’ count and seconds, then its subtitles’; a row copy writing one key and leaving identity, the dates and unknown keys alone with the version copied from untouched, a section — on a project General‘s title, then Synopsis’ logline, then Release‘s rating — and copy-all as one write each (counted in the log; copy-all’s keys in the cards’ order) that never carry a key copy-left will not move, the rows that offer no `<` proved beside one that does, an epoch in use refusing both a row copy and copy-all with the file unchanged and a sentence naming the way round it, a copy the writer would refuse refused first in its words with an empty name never offered, a scene’s story epoch copying, a project’s contributors shown and copied neither by row nor by copy-all, a rebuild in the other theme — its controls taking the new colours — asking no row again while a copy does (a right-hand value counting its encodings), a scene’s blocks replaced, inserted and deleted by id with copy-all deleting none, a scene whose blocks are ids compared as a value on both sides, the §13.2 banner over an official left column and its Fork, which forks the left version after writing a copy still pending, the message naming the row it copied, the icons on the split at the size the gutter allows, every control disabled with its reason on a read-only project, and the sample’s own scene and location — in a writable copy, so `assets/sample/` is never edited; a scene’s block rows labelled by place, a delete’s message naming `#2` and a copy’s the place in the version it came from (`Copied: #1`); the scene’s `next_block` offered no copy on either side, a side with no block left included, and copy-all leaving the left’s count as it was, never lower and never the right’s; copy-all from a version with no `blocks` key leaving the left’s `next_block` where it was, no row offering it; the `compare.copied` line’s `keys` naming a block whose id is an address by that id, and `compare.diff` carrying it as the row’s `right_id`, and the blocks whole; Compare’s door (`BrowserController.openCompare`) refusing another author’s left, the same version twice, two entities and a missing version, and opening a valid pair whose left is the viewer’s own; a prop’s sheet prompt paired as rows with no Prompt card in the comparison, its `<` copying the words; a scene’s script as a block diff — a moved block two rows, out on the right and in on the left, each cell from its own side and the blank side empty, a moved and edited block, an insert and a removal where the diff puts them, a repeated id beside a move keeping its row and no copy; a row’s `<` inserting after the nearest left block above it where `mergeOrder` would not, and after it still where Show changes only hides it, a moved-in row’s replacing in place, an added row’s deleting, moved-out and same rows offering none; `compare.diff` with every row’s blocks, `compare.copy.start` with the inputs and `compare.copied` with the values, and `compare.copy.refused` for an epoch in use; Show changes only hiding an equal block and counting 1 unchanged without the `next_block` row, hiding an unchanged section whole, keeping a changed repeat and a changed block with no id, kept in the settings, and `compare.filter` with every hidden row’s two values; a rebuild in the other theme deriving and logging neither the diff, nor the filter, nor the columns again, a copy deriving both afresh — the block now equal and hidden — and its autosave once more, the written block’s stamped time showing it changed, the re-read keeping `compare.columns` unlogged; three edits of a 200-block scene’s name and their autosave deriving the unchanged block diff once; a plug-in turned off in Settings while Show changes only is on, its still-different data shown under Other attributes on the return; a new value beside an empty old one with its `<` drawn disabled, saying why, writing and logging nothing, its `>` offered; both ways: an edit in either column keeping both arrows current and a copy each way, logged with its `direction` and `values: {into_before, from}`; the residue described by the column copied from (`{custom: {x: 1}}` against `{custom: {}}` offers `>` and not `<`); a nested `null` never copied and a list copied, both ways; the script mirrored — a `>` insert after the right’s block above it, a moved-out row replacing the right’s block in place, a row only the right has deleted by its own `>`; no `>` and a 28 px gutter on another’s official version, the right column locked and logged `not_yours`, and on the library’s version, the viewer’s own, logged `library`; `CompareTab.rightAccess` without a handle; a stale right write’s way out under the right heading, `right:draft.discard`; the official banner over an official right column, with no Fork; `discarded` never copied; the gutter two 28 px boxes, 56 px, where the right may be written, `<` and `>` and `>>>` each on its side of the split, and one box, `<` and `<<<` on the split, where it may not
`test/widget_test.dart`	the app: project version and tree, the tab set (no Overview, no JSON) and every entity tab laying out without overflow, the commentary feed ordered by instant across offsets (§1.4), tree highlight when choosing a version, navigation from the detail pane reveals the row, a parent menu after touch redirects to its author, loading versus missing-project log reasons and supplied-node movement, missing-project chrome clearance, the unpinned project chooser
`test/folders_tree_test.dart`	the Script branch on folders in the running app (§8.2): the sample’s seasons, episodes and sequence as folder rows with the folder icon and their kind in words, every row name first, the episode’s cue under its folder and no Not in the script; a scene row opening its page on the row of the version in use, one of its two authors’ rows, and a row’s stem as its tooltip (§8.3); on `foldersFixtureFiles` each report as a flagged row with its sentence and a scene no file has left out with no row, a kind the vocabulary lacks as written, a folder without a kind without a detail, and Not in the script with its count; a row four folders deep drawn inside the pane with no overflow at 700 px beside the page and at 375 px in the drawer, light and dark; and an entry that spells another row’s id (`fo_f1/sc:1`) naming no folder, so left out with no row and no id, every id in the model naming one row
`test/folders_add_remove_test.dart`	the row menu and the dialog in the running app (§9.2): Add folder… by a right click on Script — the name above the short name, `f3` proposed, the kind with None, no epoch, the first-file note, the file and the pick written, the entry at the end of the project file’s list, the folder’s page opened, the message; Add scene… from the ⋯ of a selected folder — the ⋯ on no unselected row, the next number, no kind, an unnamed scene named Scene 2, one parent written; the ⋯ under the pointer, and a taken short name refused in the dialog with nothing written; on another author’s folder, as `default` and as another author on the Script row the items disabled with their reasons and none asking for a username; with a form open, Add scene… written as the username in effect — a change of it while the dialog is open said with nothing written, and `bob` then refused on ann’s script — and a draft refused before the add said in the save’s own words, Remove still offered where the list is the viewer’s; Remove from the script moving the row to Not in the script, deleting nothing, and offering no Remove there; the project file’s page open with its logline half typed — a change of the script writing both, the box not reset (its trailing space kept), and the next keystroke saved and not refused as stale with the old list not written back; the menu and the dialog at 700 px and in the 375 px drawer, light and dark; a short name a list names proposed past and refused as taken while the file lists it, the list written as shown when the next add writes it, a typed short name kept whole in an unnamed folder’s and scene’s name; the highlight following a removed row to Not in the script; and the dialog’s longest sentence read in full at 375 px; a folder page’s Contents Add scene… writing the list it shows — the assistant’s draft of the official version, the viewer’s draft beside a collaborator’s official folder (the button enabled), and a folder pinned at its version in use, its pinned list and not the hidden draft — the scene still in the script
`test/script_page_test.dart`	the Script page and a folder’s page (§9.3): choosing Script — the selection and the row’s id, the Contents card with its two buttons, every row in the tree’s words (a folder its kind, a scene its short name, a bare tag its reason), Not in the script as a second card whose rows have no menu, a row opening its page; an empty script saying what would fill it, and the card’s Add scene… opening the same dialog, writing the same files and opening the new page; a row’s menu on the card removing the entry with nothing deleted and Add not in it; a folder’s page — the card above the form, Name, Kind, Synopsis and Notes by their identifiers, no Other attributes and no second Notes card, the vocabulary as chips, a typed synopsis and a chosen chip autosaved with the list untouched; another author’s version — its kind as written, its own list, the buttons disabled with Fork this folder first… and a tap doing nothing; Compare with `children` as one row and without the card; a plug-in’s card on a folder and its field’s identifier; the agent’s `{"kind": "script"}` opening the page and `state.selection` answering it; the agent’s `set_tab contents` and `script` on the Script page, `state.tab` and the assistant told each; a card in the whole film’s grid opening its scene, `script.card.open` logged with where it was chosen; a folder’s Script tab reading the version on screen; both pages at 700 px and 375 px, light and dark, the buttons and the rows inside the window and a button’s label on one line; the unfiled card’s rows flagged and the script’s own not; the disabled buttons’ reason on the node that carries their identifier; an add into a version of one’s own that is not in use — the entry in that version’s list, the version in use untouched, and the message saying where the scene went; the chips’ line saying that a folder’s kind decides nothing; the list called Script in a removal’s message; a row’s identifier as its entry, the second of two equal ones with `#2`, and an entry that writes `#`, `%` or `/` with their codes, each found once
`test/workflow_tab_test.dart`	the Workflow tab (§9.3) with a runtime of two scriptwriting plug-ins, one with a refused workflow: the Script page’s third tab, its Create Script card listing both, the choice and the ceiling kept as preferences, an empty ceiling no limit; with no writer, none chosen, a chosen one missing (the pull-down keeping its tag), a refused workflow and a failed read, the tab saying what would fill it, read again when the host’s plug-ins change; a ceiling of 0, -1, words or `2,50` said under the box and not kept; an amount typed and left by touching the tree, with no Enter, kept; `set_tab workflow` through the data channel opening it; the project’s tab walking the script in order — the project’s section, each episode with every folder’s section and its kind’s, an arc with only every folder’s, each scene with the scene’s —, the plug-in’s words and a section’s help shown; a row lit, unlit, or with no mark without done; the chip naming the decided model and its rate, its rate unknown, set in Settings, or no model with the reason in its tooltip, and no chip on a step that declares no model; a folder’s tab naming the plug-in and showing its steps from there down, a scene’s its own, and none chosen pointing at the project’s tab; a deleted folder’s scene in its place, a cycle and a second listing not shown; `decideStep` asked once per step; `workflow.shown` once per open, again for the plug-in’s change and the host’s, and never for a draw or a scroll; at 375, 532, 700, 1200 and 1600 px, light and dark, nothing overflowing, the chip under the label below 560 px of pane and beside it at 560 and wider; every `workflow` identifier unique on the project’s tab and a folder’s
`test/workflow_run_test.dart`	a step’s Run (§9.3) with a stand-in runtime of two scriptwriting plug-ins: the dialog titled with the step, a field of every kind, the quote, the rate alone without an estimate, no model reachable, No model call for `llms: []` with no ceiling, the ceiling or none; a required field and a number that is not one said inline and refused, then checked as typed; what is sent, a choice and a flag included; Cancel and Escape run nothing and the dialog opens empty; the run’s arguments (the action’s, the fields, the row’s focus — a folder’s under its heading), progress, the time, Stop, the spend, the model and the text; every other step of the plug-in disabled with its tooltip and another plug-in’s not; Stopped; a failure in the plug-in’s words — Script Aid Lite’s whole sentence among them —, the ceiling’s sentence and a throw, until the next run; a refused answer’s words beside its spend, with no Show the script; the ceiling’s sentence per reason — the worst case before any spend where it alone passes the ceiling, the reached sentence where it does not, after some spend or with the spend unknown, no known price, no output limit; the run surviving a change of page; no proposal touched; and the owner’s case — a scene’s Write then Change the scene, each proposal reviewed, applied and shown on the Script tab — with every log line asserted
`test/script_view_test.dart`	the Script tab read (§9.3): a scene’s page — a mention by name with the sentence’s full stop, a media reference and a mention of nobody left whole, a direction bracketed once and an extension on the cue’s line, a transition at the right; the open and every mention logged once per open, a redraw logging nothing, each speaker resolved and logged once however often the page is drawn; the whole film — a root scene after a folder ruled apart from it on the page and in its own run of cards, two sibling folders of one name two sections, the recycle bin not read and a deleted folder’s live scene in its place, a scene listed twice read once and counted; a folder from its own version; a block’s words read, its subtitles not shown, the file untouched by reading and its beats and subtitles kept through a save; the mode and the grid logged with matching section counts; the stripe — `INT/EXT` an exterior, a missing time or place neutral; 375, 700 and 1200 px, light and dark, as a page and a grid; the mode kept from the film to a folder and reset by another film; the timeline — an unknown length at the median width, marked and said, and its geometry logged, a redraw logging none and laying nothing out, a resize logging one line once it settles with no layout, and a filter laying the strip out again without what it hides, `INT/EXT` an exterior and a missing fact neutral and said unknown, the location named in the tooltip and a chip already chosen changing nothing, the state’s colourings named as the timeline’s, a filter leaving none the empty state and its layout logged with no scene and the rule `empty`, the compact switch’s Timeline and Scene grid chosen by label through the semantics, a location named as its scene references it — at the scene’s epoch, and official for an official scene whoever reads it, its tag and the decision logged where the epoch it asks for has no version —, a block opening its scene by a click and through its semantics, the sample’s equal widths and their label, two characters named Alex two lanes told apart by their tags, the colouring chosen, kept from the film to a folder and reset by another film, at 375, 700 and 1200 px, light and dark; the filters — a scene opened by itself shown whole without them and its film keeping them, a section starting against the scene shown before it on the page and in the grid (a folder’s and the root’s), a tag the film no longer has shown by its tag, a prop as a map found and props of another shape readable, the bar at 375, 700 and 1200 px, light and dark; the search — a character’s name finding the scene that mentions them and the one where they speak, a direction’s words, Clear emptying the box and the state, `r` … `rain` then a pause logging `rain` once, a settled search emptied by the person logging the empty query, each scene’s searched words logged when the search settles and none while typing, typing walking the film once and logging no row, mention, filter decision or picker list per keystroke while the settled search names the stems it left and each one hidden with its filter, the words logged once per open or re-read, Clear before the pause logging the query first and nothing after, a pending query logged on a navigation with where it was typed and on another film; the settled search logging the timeline it left, and the strip a switch to the timeline lays out after it; Clear after a settled search logging its narrowing; a search kept across a re-read, and into a tab mounted afresh, logging that reading’s words and what it found once drawn; the first keystroke on the timeline resolving its speakers unlogged, the settle logging them in the search’s line, and likewise a cast-only lane’s name, and a grid card’s cast, in a scene a keystroke newly shows and the location of a scene a widened search shows for the first time; the log one line per act — no per-scene line, the walk’s rows, mentions and speakers, the narrowing’s scenes and sections, the first search’s words and a second search without them, a kept search’s speakers once, the timeline’s scenes in its layout, a speaker drawn its own line once; the census of two hundred scenes — the open the acts’ lines only, a search one line, every value still in a list
`packages/filmopen_state/test/script_view_test.dart`	the reading state (§7, §9.3): every filter set must hold and one not set asks nothing; the where-and-when pairs; the search in the words given; a resource as a tag or a map naming it, a list of another shape naming nothing; the failure naming the first filter and its values, the search’s words as compared; each setter’s `script.view` with the mode and the filters, the timeline’s colouring logged with its time, kept by Clear and a re-read and reset by another film, the search’s keystrokes unlogged and its words never in the setters’ lines; film A’s filter gone in film B, a re-read keeping filters and mode
`packages/filmopen_format/test/scene_card_test.dart`	a scene card’s facts (§9.3): inside, outside, both or neither from the slug line’s head; the number, time, cast, elements, first action and eighths as the file gives them, a value of another type read as none; a length finite or none
`packages/filmopen_ui/test/resolve_mentions_test.dart`	`resolveMentions` through the reference codec: a full stop after a mention kept, a media reference one token, every token offered and a null or empty answer leaving it as written
`test/scene_form_test.dart`	the scene’s form (§9.3): a scene opening on Edit with Name, Synopsis, Location, Epoch, Characters and Notes in that order, the Dialog and actions card — the editor, after the scene’s own cards and before Other, whose Other attributes holds the rest once opened, no id on the page —, no generic Attributes card; a location and an epoch chosen and written, Clear removing the key and nothing else of the file changing; a character removed and added — the menu offering only those not in the scene, the entry that stays keeping its `epoch` and `outfit`, the last one out removing the key; a character’s own epoch where the project declares two, an epoch the project relabels relabelled on the row, As the scene removing the entry’s `epoch` with the outfit kept, and no such pull-down in a project with one epoch, where an entry’s epoch is kept; a location, an epoch and a character the project does not have shown as written and said, on the viewer’s own version and locked on another’s; a `cast` of bare names drawn as it is and never written; an agent typing into every field, `cast` one short name per line with the entries that stay intact, a name nothing has refusing the text, nothing removing the key; Compare pairing level the five rows both versions fill and the blocks by their ids, and no Notes row, the list at its end, where neither has notes with their copy controls; a plug-in’s card and field on a scene; 700 px and 375 px, light and dark, every control inside the window and none crushed; a cast row’s epoch labelled Character’s epoch; a scene without a block saying on its Script tab where its words are written today; Compare drawing no placeholder for the viewer’s scene with no block, and writing nothing; a project that cannot be written saying so on the empty card and the Script tab, offering no fork; the direction’s example wrapping rather than cut; a character’s Outfit only where it has two or more at the entry’s epoch, else the scene’s, Default outfit writing no key and removing one, a choice keeping the entry’s `epoch` and `notes`, each use logged — opened by a press, by the keyboard and by a screen reader’s expand —, an outfit deleted at that epoch though live at another left out and each named as it is there, the row fitting at 700 and 375 px
`test/scene_creation_test.dart`	making characters and locations (§9.3): New character opening on The filename is permanent…, Filename with `main-hero` as an example that fills nothing, Role, and no username box, kind helper or first-version line, written as the username in effect — `default` where none is chosen — and New location without a kind; a username changed while a dialog is open said, what was typed kept, the next Create writing as the new one; on a scene, Add character opening New character at once where the project has none, the character joining the cast with the scene still on screen; every character listed leaving New character… alone in the menu, an unlisted one offered before it and added as before; a character made at another epoch joining with its `epoch`, one made at the scene’s without, every other entry’s `epoch`, `outfit` and `notes` kept; Cancel making and changing nothing; a username changed while the dialog was open leaving the scene as it was and saying so; a save of the attachment that fails, the character kept and Retry putting it in the scene without making it again; Location making one at once where the project has none, `location_epoch` where its epoch is not the scene’s and none where it is, listing the locations and New location… last where there are some, and Clear location removing the key alone, an unresolved one too; Epoch saying Default, its menu the declared epochs alone with a shared name’s token, Delete on the focused control and Clear returning it to Default; Create pressed twice asking for one character, once; an empty filename’s reason naming the filename; another project opened while the dialog is open making nothing in either; a username changed while New location is open, the location made as the new one and the scene, read-only to it, left as it was and saying so; another location chosen clearing `location_epoch`, the same one writing nothing; a long location name keeping the box one line high at 700 px; Delete after a press on the Location box leaving the Epoch; Compare’s column saying why its Location does nothing; what one scene’s boxes said, and the focus, not carried to another scene; the focus back on the Location box when its dialog closes, never on the Epoch focused before; Add character’s menu opening under its button at 700 px, not beside it over the tree; Escape while Create writes dismissing nothing, Cancel and Create saying why they wait, the dialog closing by its answer and the scene taking the character; another scene opened while the dialog is open, the character made, neither scene taking it, and a message saying so; a cast of another shape by the answer taking nothing, said; a scene whose epoch the project does not declare, the character joining with its epoch written out; an agent’s `set_field` on Location clearing `location_epoch` for another location and writing nothing for the same one; the keyboard opening the Location and Epoch menus on their first entry, an arrow moving, Enter choosing, the focus back on the box; a draft that cannot be written first stopping the creation, said until the draft is the file’s again; the sentence for a location made and not taken gone once the Location changes; a `+` where a press makes a location, the arrow where it opens a menu; an Epoch with no epoch to choose saying why; the filename’s tooltip above its box; another project opened while the dialog is open said at once, as a live region, Create disabled; a block read by another in a film with no character naming no Add character for its speaker; a Location of another shape by the answer never written over, said; a route pushed over the dialog while it writes, the dialog still closing with its answer and the scene taking the character; a character and a location made at an epoch the project no longer declares when the scene takes them joining with no epoch of their own on the entry and no `location_epoch`; Add character‘s items 56 px tall by the character’s picture, its name and short name, the icon where it has none, New character… last, each use logged; a block’s speaker pull-down on the scene’s form by the characters’ pictures
`test/project_layout_test.dart`	the project page’s layout (§9.3) on a fixture film: General at 1600 px — the title on its row, Type of project narrowed with Aspect ratio and Resolution beside it, the Style under the type with the genre beside it; Synopsis its own card between General and Epochs, the logline and the synopsis on their ids; the aspect ratio’s five entries in the owner’s order, each with an icon, writing the ratio and keeping the rest of `format`; the resolution’s five; None taking out `format` it leaves empty; a value the list does not have shown and kept; an agent’s listed ratio written and a word that is none writing nothing; Other closed on entry, Details, Visual treatment and Advanced treatment gone, and opened holding every leaf they held once, each under its subsection in order — Release, Camera, Look, Light and composition, Grading — the list checked against every leaf of the treatment but the style and the prompt’s words; one field to a row and no overflow at 375 and 700 px
`test/form_cards_test.dart`	the forms’ cards (§9.3) on a fixture film, at 1600 px and at 375, 532 and 700: the project’s General — the title, Type of project, the genre — then Synopsis with the logline and the synopsis, Epochs with its line, the media and Other last, its Release holding the year and the rating, and View in the same order; Other closed on entering a version, opened by a press and by Enter and closed by Space, its expanded state said to the semantics, holding Other attributes and File, kept open through an edit and its save, a change of theme and a resize, its title row the same height open or closed, and closed on entering another version and on coming back, a navigation made while the page is behind another of the rail’s included; a version whose every key has a field showing File alone in it; a refused save and a header its filename disagrees with in sight while it is closed; a scene, a character and a location opening on General and ending with Other, a folder keeping Details and File; the project’s one place, Cover image, beside a character’s Reference images, neither with Add a place…; Compare’s General and Release, a `<<` each, nothing folded; the overview naming the kind Type of project; the project’s `next_epoch` drawn in no Other on Edit or View and in no comparison, and kept by a save
`test/new_project_test.dart`	a new project (§9.2): the dialog asking the title first, with the focus, then Folder for the project: a little below it, the parent folder with Browse, then Folder — and no kind, no paragraph about folders, no helper and no preview of the files (the local-create set-ups uncheck Sync this project to the cloud…?, the dialog’s cloud and director being `new_project_cloud_test.dart`’s and the sharing package’s); a title typed first filling the folder name with its nearest segment, cut to its length; a name typed after it, and one emptied, no longer followed by the title; a name typed first left alone; the disabled Create’s reason naming its box — the parent folder, the folder’s name — and a followed name cleared with its title saying it is missing; Create on a real temp folder — the manifest, a project file without a `kind` whose `children` is `["sc_1"]`, `sc_1_<creator>_v1.json` named Scene 1, the app on the project’s own version on Edit, its row found — on Edit too from a page left on Compare in development mode — the scene still in the script and nothing unfiled; a project made as the username in effect, `default` where none is chosen; a filter typed before cleared, so the new row is drawn; the folder proposed — the documents folder with nothing known, then the parent of the last project opened, then the folder the last project was made in, each folder since deleted giving way to the next; a folder found late never writing over a box typed in, typed in and emptied, or browsed into; a documents folder the system will not name said under the box, which stays editable with Browse, and a project made after typing a folder; the folder remembered once a project was made there and not for a refusal; a folder written that will not list not opened, said in the dialog, the project on screen, its page and its username kept, nothing remembered and the files left written; nothing dismissing the dialog while it creates — neither Escape nor a tap outside, Cancel disabled — and Escape closing it once the read has answered; at 700, 532 and 375 px the dialog inside the window, Browse… centred on the parent box and inside the dialog — its icon alone, its name the tooltip, below 400 px of window — the box keeping room for a path, and the landing closing the narrow drawer; a folder that will not list after Close project saying nothing of a project still open, the closed page kept, and the sentence going once a box is changed; a folder the preferences could not keep said at the top of Settings → General and written by Try again; the project’s page setting the kind, clearing it with None and leaving `children` alone, an agent typing a kind, a word that is none and nothing; a kind this app does not know staying as written; a legacy spelling typed by an agent written as the kind it means, a legacy spelling in the file shown as that kind and kept when the same entry is chosen again, and a `kind` that is a number drawn locked with nothing writing over it; an empty `kind` reading as None with no blank entry and removed by None; a legacy spelling overwritten by the kind’s own name once the kind is really changed; Create activated twice in one frame making one project, the dialog held until that one ends; a saved parent since deleted giving way to Documents, not to the opened project’s folder, and with none saved an opened project’s folder since deleted likewise; no folder name saying anything of its length, the one the title proposes or one typed of 10, 11 or 32 characters
`test/folders_move_test.dart`	moving (§9.2): the cycle guard reading the view — a folder moved out of another, its lists landed and its publication held, the reverse move then no cycle; a drop before a row and Move up queued behind a move landed and not yet published taking their place from the view’s list, not the drawn index; the move dialog offering a destination such a move made; a destination gone from the film while the dialog was open said, nothing written, `tree.move.refused` logged with `childrenChanged`; the opening row gone while it was open, nothing written, `tree.move.refused` logged with `openerGone`; a wholly discarded scene having no row beside the script, a retained one beside it still moving; Move up and Move down reordering the tree with one write of the list and nothing else changed, disabled at the ends with the reason; Move to… listing Script and the viewer’s own folders indented as the tree, without somebody else’s folder and with the line that counts it, Move waiting for a choice, a pinned entry put, still pinned, at the end of the folder chosen, and the message naming it; a folder’s own branch absent from its own dialog, Cancel moving nothing, a folder moved into another; a scene beside the script filed by Move to…, its only item, from the tree and from the Script page’s second card; a move whose second write fails saying the row is listed twice, both lists holding it and the second flagged; a Contents card’s row menu with the same four items doing the same; every item disabled with fork as the reason in a list that is somebody else’s; a viewer with one folder of their own offered that one, a viewer with none told what would give somewhere; the dialog at 375 px, light and dark; Script left out by name with its author and the folders counted apart from it; with no username chosen Move to… on a row beside the script what it is for another author, never asking for a username
`test/folders_drag_test.dart`	drag and drop in the tree (§8.3, §9.2), a refused drop logged once at the release with its decisions (`tree.drop.refused`, a gone row’s reason the code `childrenChanged`), a hover logging none, with a mouse unless said: a wholly discarded scene having no row to pick up, a retained one beside it still moving; a scene dragged onto a folder its last child, the message naming the folder, nothing deleted; dropped on a row’s upper or lower edge before or after that row — within one list downwards and upwards, into another list, and on a folder’s own edges in its parent’s list; a drop writing what the same move by menu writes, file for file; the folder under the drag highlighted, an edge showing one line, somebody else’s folder showing nothing and a drop there saying to fork and moving nothing; a folder into itself or beneath itself and a row dropped on Characters moving nothing and saying why, a row on itself saying nothing; a closed folder opening after 700 ms under a resting drag and not before, then taking the drop among what it holds; the list scrolling near its bottom, stopping away from the edge, and scrolling back near its top; a finger’s long press starting the drag, a chevron still toggling and a tap still selecting, at 700 px in the pane and at 375 px in the drawer; what is somebody else’s not picked up however far the press goes, and a row beside the script filed by a drop; the list scrolling under a pointer that slides along the edge as under one that holds still; a drag that scrolled its own row out of being still writing its drop and letting the list go — without the fix the list is pulled back 16 ms after it is put anywhere; a closed folder not opening under a drag that keeps moving over it for 1.5 s; a finger reaching a folder’s upper third; a row the project took away under the drag said, nothing written and its refusal logged at the release; a row dropped back where it already is writing nothing and saying nothing; the rest and the edge scroll logging one line where each starts and one where it ends — a rest swept across and left, `left` with its restarts; one rested on, `opened` —, a turn to the other edge logged, sliding along an edge logging nothing, and the scroll’s end `away_from_edge` or `pointer_up`
`test/folders_marks_test.dart`	marking and moving marked rows (§8.1, §8.3, §9.2, §9.3), at 700 px unless said: a range from Script to a row of somebody else’s folder marking neither, the reasons logged (`script`, `locked`), at 700 and 1200 px; marked scenes from two lists dragged into a folder — three writes, one `project.published`, the tree’s order, the marks cleared; Move to… on a marked row titled with the count, no marked folder’s branch offered, its cancel logging the entries; a marked row gone in the view but still drawn (a landed write, its publication held) skipped and counted, the survivor through `moveChildren`, its failed publication answered with what landed; a survivor listed twice refused with its sentence, the marks kept; a half-done move naming the list that kept its rows and counting only theirs; a newer marking kept when a slow move settles; a drop on a marked row and into a marked folder’s branch refused and logged with what decided it; a drop of marks into a locked folder logging every marked entry by its list (`byOrigin`); a drag counting the marks that resolve; on the Script page’s Contents a mouse click marking and staying, a slow second click marking, a double-click opening, a touch opening, a range across both cards, control-click, Move to… of two marked rows
`packages/filmopen_tree/test/tree_marks_test.dart`	the tree’s marking (§8.3) at 700 and 1200 px: a plain click opening and marking alone, shift marking the drawn range either way and opening nothing, control and command toggling; every marked row tinted in light and dark, down to one, more lightly than the open row; a drag of a marked row saying N items, of an unmarked one its name
`packages/filmopen_state/test/tree_marks_test.dart`	the marks (§8.1): only a movable row marked on every path, the anchor apart; toggling down to one keeping it; another source resetting them, a re-read keeping them; every change logged with its surface, requests and reasons
`packages/filmopen_state/test/tree_builder_test.dart`	`scriptRowIds` naming the rows as the tree does — a pinned row, a repeated entry — and `nodesInOrder` answering the marked nodes in the tree’s order, a gone id left out
`packages/filmopen_state/test/working_outline_test.dart`	the script as the viewer works on it (§5.12, §8): with the assistant’s unpicked drafts of the project file and a folder, the drafts’ lists are the script, its rows the versions in use, and `tree.outline.done` names the root, the bases, each folder’s list and children, once per change: a rebuild of the same outline logs nothing, a change logs it whole; an Add on the Script row and on a folder writes the draft and is seen, the version in use unwritten; with no draft, the versions in use as before; a discarded scene leaving the draft that alone lists it
`test/folders_review_test.dart`	what an adversarial review found on the screen, each as the test that would have caught it (§9.2, §9.3): the move dialog offering no folder the move would refuse — a folder the moved one holds whose first listing the tree draws outside its branch, and a destination that names the row already said, in a message that is still there after six seconds and gone after eleven (`kLongMessage`); in development mode a change of somebody else’s list from the tree said in the confirmation’s own message, and nothing added on a list of one’s own; a locked, empty Contents card saying why as text under its sentence; and New project refused on a folder that holds files — real I/O in a temp folder — with no username asked, the project still open and its username as they were, the folder as it was
`packages/filmopen_store/test/project_writer_test.dart` (a plug-in run)	a returned entity written as `<viewer>.<tag>`’s v1 with `by`, `forked_from`, no label and its plugin batch, the person’s version untouched, a second run v2; an entity matching no source, content the format refuses and no viewer writing nothing; a run whose second write, or whose batch, is refused leaving nothing of it; a plugin batch under the viewer’s derived handle for that plug-in accepted, an import under it, a plugin batch under another person’s and one under a workspace that is not the plug-in’s refused; and a render’s request recorded in each take’s item beside what the file measured, with nothing of it at the batch’s top
`packages/filmopen_store/test/layout_copy_test.dart`	copying a session overlay preserves documents, binary media and thumbnails; copying a directory source does not traverse a link to a file outside the source
`packages/filmopen_media/test/local_media_store_test.dart`	reads, writes and deletes only direct files in `media/`; create refuses existing media; listing strips the prefix and excludes nested files; disk playback resolves the media path; operations refuse names containing path separators or other non-file-name forms; a listed literal-backslash name is excluded rather than appearing as a second copy of an existing valid file with the same suffix
`packages/filmopen_media/test/media_status_test.dart`	whether a render is outdated (§6.9), from timestamps alone: an entity’s entry outdated by its document edited after the render and by a source its request named, current for an unchanged fork, an unrelated document, a source the project no longer holds and an edit in the same second, a revert still outdated, a zoneless time absent; unknown with no record or a render record without a request or a zoned `asked_at`, current for an import or a manual record; the owner’s block sequence — a render on one block and one covering five: an edit to the block outdating both, to a block before neither, to a covered block the coverage alone, an insertion, a deletion or a reorder inside the coverage alone, an insertion before or after and a block’s media written neither — music to the end of the scene outdated by its source alone, and a clip whose `spans` its group does not allow covering its owning block
`packages/filmopen_media/test/media_stage_test.dart`	a render outdated by the stage (§6.9): a prototype render under a draft holder and a draft one under a final holder outdated, with both stages; one at the holder’s stage or above, under a holder moved down or of an unknown stage, and an upload, not
`packages/filmopen_media/test/media_provenance_test.dart`	the descriptor (§6.9): the media the caller passes described, never read again; when the render was asked, nothing changed and not kept for a current one; the document, a covered block by its position among the blocks and never its id, and a source by its stem, each with its time; when it was kept, a zoneless time absent; the record’s length and size drawn beside the entry’s with the keys that disagree, and the entry’s alone where no record names the media
`packages/filmopen_media/test/epoch_picture_test.dart`	the picture of an entity at an epoch (§9.0): the preview, then the sheets picked, then the first image take there; a preview named by its file located in the media folder; never a reference the version holds deleted, nor the take it names; a picker’s picture at the epoch asked, else where the name is read
`packages/filmopen_media/test/prompt_inputs_test.dart`	what a prompt may name (§5): a reference prompt its inspirations, a sheet its inspirations then its references, the voice and the treatment nothing, a frame — and a clip, alike — every character’s, location’s, outfit’s and prop’s reference images and sheets, each as it resolves for the viewer — two viewers on different versions see their own — and none of an entity in the recycle bin; every scene block’s speakers, cast, location and mentions offered at the shared context’s epochs before remaining film entities, a cast member’s outfit sheet and a block’s prop sheet among them at the resolved versions and named by `promptInputsOf`, none missing; `n` counting entries neither deleted nor archived, so an unreviewed entry before a kept entry becomes `reference-1`; `promptInputsOf` in first-appearance order, once each, with the tokens naming nothing
`packages/filmopen_media/test/prompt_inputs_test.dart` (the substitution)	`substitutePromptTokens` writing each token in the model’s words (`@Image{n}`, `image {n}`, `<Image_{n}>`) numbered by first appearance, a repeated token the same number, a token naming none of the inputs and every other character unchanged; `@reference-1` and `@reference-10` kept apart; a frame’s scoped tokens
`packages/filmopen_media/test/project_media_test.dart`	take and filename references resolve through the project source, with batch metadata and thumbnails where available; external URLs stay external; unavailable locations are contained; thumbnail-only valid take stems still display their thumbnails; malformed references and batch outputs cannot resolve a real lookalike file or borrow its thumbnail, including a take name containing a literal backslash beside a valid suffix file and neighboring take; the record an entry names — its `batch` and `item` read directly, an item whose output is another file not taken for it, a batch no file holds leaving the take’s own, a take found by name recorded through the output match with its batch, a hand-placed file recorded only where its entry names an item; `liveMediaOf` listing a document’s live entries in order, an archived one among them, then a `preview` no entry names, and nothing for a preview whose entry is deleted; another author’s `original_name` said as one plain line; a reference no record names called by its last part, an address without its query, said plain
`packages/filmopen_browser/test/assistant_panel_test.dart`	the page owns no assistant (§9.3): at 1200 and 532 px the browser page alone holds no assistant card, toggle, button, sheet, model or dock and no AI assistant text, the detail pane drawn, and, where narrow, neither `nav.tree` nor a `TreePane`, the tree being in the dashboard’s drawer; the assistant is the dashboard’s dock, proved in `test/assistant_presence_test.dart`
`packages/filmopen_forms/test/plugin_sections_test.dart`	the plug-ins’ cards as a page draws them (§9.3): no server field, fo-assist’s `textModel` drawn as any plug-in’s, no card left with nothing; the project’s specification keeping out the owner’s allocation floor alone (`keptOut`) and hiding nothing else; a scene’s plug-in field drawn after the form was seeded, a reload’s late card, seeded from the file (empty on a scene without a value) with no assertion, the synopsis typed before it kept
`test/assistant_presence_test.dart`	the assistant’s dock in the application (§9.3): over every page of the tree — the overview, the script, a category, a version, a batch and the other files — standing beside a version’s row and covering none of it; in every section of the rail, Settings included, full height at the window’s right, the rail at its left; still there with the project closed; in a short window (1200 × 360) full height, the page beside it overflowing nothing; at 532 and 375 px the portrait at the upper right clearing the menu button, a tap on it sliding the dock’s body in; the synopsis with no assistant stars of its own; fo-assist’s text model an ordinary setting on the project’s page, drawn on its card beside another plug-in’s field, the stored model kept through a save, the assistant’s picker opened and closed there asking no model and writing nothing, and Compare on the project’s page comparing it as another plug-in’s row
`test/assistant_out_of_box_test.dart`	the real stock host at 1200 px, signed in with balance and device, no key or model choice: the catalog’s preferred model is ready on credit without a request, no text-picker default is asked or shown, an option opens on that decision and its first turn asks the in-process funding stand-in for its credential; no live provider request
`packages/filmopen_browser/test/project_overview_test.dart`	the project page’s warnings (§9.3): long valid names — tags of 11, 16 and 32 characters, an author of 11 — drawing no warning and no advice row, the card counting the one fault, a file that is no JSON object, on its line; a film with long names and no fault reading Warnings 0 and Nothing to report; at 311 px light and dark and 360 px dark, the card within the page
`packages/filmopen_browser/test/epoch_overview_cards_test.dart`	the overview’s cards (§8.2, §9.1): one for every declared epoch, in the project’s order, named by label, else year, no token shown; a missing card’s Based on listing the epochs that resolve, the first chosen, and Create copying the version in use as the viewer’s picked v1 with `forked_from`, the card filling and the message naming the label; nothing in use at any epoch → the sentence and no copy; a read-only project → Create disabled with the reason, the help offering no copy; a location’s missing card copied as a character’s is; another film open and drawn by the time the copy is written, nothing said over it; refused in its own film, the message said and its Re-read files reading without a fault, before and after another film is drawn; a prop listing only the epochs it has; a hand-written token that is no filename segment given no card; an epoch allocated under a 32-character username given its card, Create copying into it; one card to a row at 600 px of pane and two side by side at 800
`packages/filmopen_browser/test/outfit_list_test.dart`	a character’s outfits on its overview (§8.2, §9.3; Project Specification §9.2): each card listing the outfits at its epoch only, a missing card’s beneath its controls, a tap opening one at exactly that epoch; an empty list saying what fills it; New outfit asking a name only, Create disabled with the reason until one is typed, making the writer’s allocated `kira.bob-1`, opening it at that epoch with a message, and two epochs’ outfits never crossing; the dialog’s title naming the character and the epoch, and the heading saying where outfits are; the dialog’s Create at least 44 px; a dialog asked in one film refusing in another before anything is allocated; an outfit with nothing in use at an epoch named there by its id; an id taken twice said in the dialog as that, never as a changed file, nothing opened; a disk’s own error said in the dialog’s sentence, never its text, and cleared by retyping; an epoch taken away while the dialog was open said as undeclared, nothing made; an epoch the project does not declare listing its outfit, which opens, its line saying why in place of the missing line, with Based on (its tooltip the reason too), Create and New outfit disabled and the reason as their tooltip, while a declared epoch with or without the character’s version keeps them; a project declaring no epochs keeping New outfit and disabling Based on and Create with their reason, which the controller would refuse; a read-only project’s New outfit disabled saying why; at 700 px no overflow, a long name cut short; New outfit disabled, with the discarded sentence, on a character whose every version is discarded
`packages/filmopen_forms/test/epochs_editor_test.dart`	the epochs editor (§8.2): no token on the rows and the year optional; a label cleared to blank refused in place with the old label kept, cleared in one step or letter by letter, and an unlabelled epoch typed into and cleared left unlabelled; a label removed in the file, and a label typed and then re-read as another and back, reaching the box; a burst of changes sent before one rebuild, the same label twice, carried back whole; Add epoch disabled with its reason where no write is given; the dialog asking for a label, required, and a year, optional, with no token box, declaring through the write; a refusal shown in the dialog, which stays busy and undismissable until the write answers, and can be closed after a write that throws, `epoch.add` logging it `failed` with the label and the error’s message; a disabled Add saying why
`test/epochs_add_test.dart`	Add epoch on the whole app: on the viewer’s own version in use written into that file and adopted by the form, the token never shown; disabled with the reason on a version that is not in use; on another author’s version in use the dialog saying it makes the viewer’s own, the fork made, picked and opened, and the page saying so; a fork whose pick failed opened and said, never declared twice; another handle while the drafts are written refusing it in the dialog, its refusal logged with the viewer, film and version in use taken at the click beside those current; another film asked while the write is on the disk, declared or its pick failed — the open waiting, the declaration landing in its own film, then the other film opening, with no developer’s text and nothing of the first open over it; a reorder through the draft writing `order` alone and making the first epoch the default; another handle refused by the controller with the reason `viewerChanged`, logged `write.epochBinding.refused` with the handle bound and the one now
`packages/filmopen_browser/test/epoch_overview_test.dart`	the picture an epoch’s card may draw: the version’s `preview`, then its `picks.sheet`, in order, and never a reference the version holds deleted, whatever named it; a candidate in the take’s other spelling as well; and the fallback, the first image take at the epoch, passing over one the version in use holds deleted (`filmopen_media`’s rule, which the cards draw)
`packages/filmopen_browser/test/check_pick_test.dart`	the check and the box at it (§9.3, §13.4): at 375, 700 and 1200 px the check on the version in use that nothing chose writing the viewer’s own pick, then a second press saying it is in use and writing nothing; official in use with the star alone picked as the version itself; a pick that follows official already explicit; a stale write logged at `stage: write` and said; another version’s check an ordinary pick; Use this version at a version not in use, inside the view, gone once picked, none on the version in use, a tap outside dismissing it; the box pointing at the check from below wherever the check stands, and going on the check, a tap outside, its link, a scroll and a move, back only at the next showing; the draft’s box staying through a tap outside and a scroll, following the check as the header scrolls, at the pane’s top edge with no arrow once the check is out of sight, and left in place by a scroll of the body; each step’s `version.pick` and `assistant.page` events
`packages/filmopen_state/test/pick_from_check_test.dart`	the check’s decision on the version’s stem in the commentary queue (§9.3, §13.4): two presses queued at once on official in use answering `picked` then `already`, the explicit pick kept; over a pick a workspace inherits, a press where the viewer’s own pick is ignored (it names a discarded version) writing the viewer’s pick of the version in use
`packages/filmopen_store/test/manifest_test.dart`	the manifest template round-trips without `data`; layout routing indexes only flat `data/` documents and flat `media/` takes, reports misplaced and nested files, and ignores derived thumbnails; old `data` values are preserved silently without selecting another source; a missing manifest still opens with a warning; an old flat project is reported without migration; manifest tag mismatch and missing required fields; the manifest is neither an entity nor an other file; a real Linux take with a literal backslash retains its exact name and naming warning when its source refuses the location, remains indexed with null media and `couldNotRead`, and leaves a valid neighbor usable and every disk byte unchanged; a source throwing while locating an otherwise valid take is contained in the same way, with only the file name in the warning argument
`packages/filmopen_store/test/library_test.dart`	the shared library (§14.5): entries marked by origin, separate counts, a group wholly discarded left out on either side, project stem shadows the library’s with a warning and none of the replaced file’s warnings survive, a fork beside library versions, a project official pointer overriding silently, an unreadable library folder as a warning rather than a failure
`packages/filmopen_format/test/short_name_test.dart`	the segment rule in one place: the 32-character segment, one-character segments and tags kept, the username (3 to 32, never dash-led, `official` reserved, `default` valid) as a handle’s owner and the 20-character workspace bound, an allocated id under a 32-character username a tag or epoch segment and a 44-character plain one not, a derived handle’s workspace part, Windows device names, normalisation, a valid segment of 10, 11 or 32 characters drawing no warning as a tag, an author or a project’s tag, one of 33 outside the grammar, and allocated ids exempt from the grammar in tag and epoch positions alone: a 32-character username’s 34-character epoch and outfit id silent, the same id as an author, a take’s author or a batch outside the grammar, equal spellings in author and epoch positions not exempting the author
`packages/filmopen_format/test/allocated_id_test.dart`	the owner before the last hyphen, a hyphenated owner and an owner ending in digits, canonical positive decimal suffixes, the 32-character owner and ten-digit suffix limits, an owner that is no username refused by `AllocatedId.of`, and ordinary tokens that are not allocated ids
`packages/filmopen_format/test/reference_codec_test.dart`	every media token form parsed as one token and encoded back, `@ch_kira:character_sheet-1` one token while `@ch_kira`, `@ch_kira: …`, `@ep_now:reference-1` and shorthand keep their parse, an outfit’s `@of_kira.coat:outfit_sheet-1` and `:reference-1` and a prop’s `@pr_car.wheel:prop_sheet-2` one token each while `@of_kira` alone is none and `@pr_chart` the prop’s mention, a word under another type’s stem one token naming nothing, a leading zero, a zero, an unknown word or a stray number no media token and the token ending with its number, the six words’ groups; all four canonical kinds and dotted entity ids, ordinary and allocated epoch tokens separate from filename types, shorthand after canonical syntax, terminal separators and invalid starts, per-segment bounds, UTF-16 source ranges and repeated adjacent mentions, unknown targets retained with optional annotations, immutable tokens, exact canonical encoding with its terminal-hyphen boundary, and an allocated epoch and outfit id under a 32-character username encoded and read whole past 32, a terminal hyphen left as source and an owner of 33 bounded
`packages/filmopen_format/test/allocation_test.dart`	owner-scoped epoch and per-character outfit allocation; all project versions and owner floors; filename, content, take, pointer and commentary-only epochs; deleted outfits and library-origin groups; immutable snapshots and last-dot containment; whole-number counters, never-lowered encoding, restart, exhaustion and project counter copy-left exclusion; 13 isolated epoch sources reloaded through copied memory sources, five isolated outfit sources, and caller-owned collection copies with non-reserving proposals; an outfit file the loader set aside holding its id by its filename, a warning about any other file holding none
`packages/filmopen_format/test/discarded_test.dart`	a version set aside (§5, A version set aside; Project Specification §6.1, §7, §13.1): the retained, the discarded and every version, the retained read-only; the key present whatever its value; an official pointer naming a discarded version naming none, `isOfficial` exact; the tracking value and an own pick falling through; the own highest not discarded; an exact pin still found; every version discarded resolving for nobody; the next allocation after a discarded highest and after every own version discarded; a removed key bringing the version back; the short names and the allocation inventory counting a discarded project file; `groupCounts` leaving out a group wholly discarded, one with a version kept still counting; `retainedGroupsOf` and `hasRetained` leaving it out, `groupsOf` keeping it, and the script’s unfiled rows leaving out a scene wholly discarded; `epochsOf` reading the filename, the content’s `epoch`, `location_epoch`, cast and props; the header, value and copy-left key lists
`packages/filmopen_store/test/discarded_readers_test.dart`	the writer’s and the loader’s readers of a discarded version (Project Specification §6.1, §7, §13.1): a fork and a plug-in run numbered past a discarded highest, a fork of a discarded version not discarded, an epoch whose every version is discarded refusing a copy into it, a pointer naming a discarded project file counting as none, every project file discarded answering `noProjectFile`
`packages/filmopen_store/test/discarded_reports_test.dart`	the loader’s two reports (§13.4, §18.2): a pointer naming a discarded version (`officialDiscarded`) and another author’s pick naming one (`pickDiscarded`), each a warning with the stem and the file and an info line `project.discardedTarget` with its values; nothing on a retained version
`packages/filmopen_store/test/set_discarded_writer_test.dart`	`ProjectWriter.setDiscarded` (§7): the key set as an RFC 3339 UTC instant and nothing else changed, removed again; a version already as asked writing nothing; another author’s file, a changed file, a version official names, no viewer and the library’s file refused; the sole author’s highest project file discarded where another of theirs remains, the record falling to it and `version.discard.record` logged; the last live project file and one an official pointer names refused, `after: null` in the refusal’s line, another project file discarded
`packages/filmopen_store/test/write_set_test.dart`	`ProjectWriter.writeSet` (§12.7): a new record created in the format’s key order, unknown members kept, the header the filename’s; a record written over its file against its text, a stale one refused; another author’s record and no viewer refused, nothing written
`packages/filmopen_state/test/set_discarded_test.dart`	`ProjectController.setDiscarded`, and `setPick`’s queue arguments (§7, §13.4): the pick on the discarded version landing on its base; an official base, a discarded base and a base at another epoch returning the viewer to official; a workspace returning by the tracking value, not its owner’s pick; a pick elsewhere untouched; discard the highest or every own version, then fork; a pick that cannot follow answered with the flag written; with `viewer`, `setPick` and `setDiscarded` refusing a viewer who is another `ViewerChangedException`, nothing written; `setPick`’s `unlessExplicitInUse` writing nothing where the viewer’s pick names the version in use and picking another; a username changed during the flag’s write leaving that handle’s pick untouched, the asked viewer’s moved; `setPick`’s `unlessExplicitInUse` writing nothing on a version discarded meanwhile; `setDiscarded`‘s `stillWanted` asked in the queue, a false answer refused `NoLongerWantedException` with nothing written; the refusals’ reasons and every line’s values
`packages/filmopen_state/test/discard_parent_test.dart`	the discard’s parent (§7, Project Specification §8.5): a scene discarded leaving its folder’s list and one at the top level the project file’s, no fork; a version discarded while another remains leaving the short stem listed, `parentReason: kept-other-version`; a full reference leaving with exactly the version it pins; a character, with no parent, writing nothing but its own file; a list naming it twice losing both listings, `parentFollowed: true`; another author’s list in the viewer’s script left unwritten, `parentReason: not-yours`; a list under Not in the script following too, an exact pin with another version left and a last version; a failed parent write keeping the flag, `parentFollowed: false`, `version.discard.parentFailed`
`packages/filmopen_state/test/dangling_children_test.dart`	dangling children (§5.11, §5.12, Project Specification §8.5): a missing scene and a discarded one not drawn and raising no warning, untyped and repeated entries still reported, places counted in the list as the reader shows it, a read logging no line; a save of the folder, its name alone edited, leaving its list as it is; an add, a removal and a move starting from the list as shown, each logging `children.dangling` once per entry it leaves out, with the list; a move within the list not taken for a list changed meanwhile; a discard landed and not yet published counting for a list write made while it waits; a removal that lands and whose publication fails logging what it left out, once, and one refused as stale logging nothing; Move down on the first drawn row moving it past the next drawn row, never past a hidden entry
`packages/filmopen_state/test/pending_sets_test.dart`	`PendingSets` and the set providers (§12.7): add to none creating the pending record, add to one appending; a session’s and a queue’s words; a new record’s id clashing with none of the viewer’s records of the type nor, for a queue, their render batches; remove by `n` keeping the high-water mark; commit taking only the type’s own members; commit moving the record to the history; a record changed outside the app refused as stale, never retried; each change’s lines and the record as written; `update` changing a record no longer pending by its stem, refusing another author’s, a stale one and one asked for another film, logged, and writing nothing where the change answers null or no record has the stem
`packages/filmopen_state/test/assistant_session_review_test.dart`	the review’s Pick and Discard (§7.4): a fork picked left, right and left again, the pick moving each time and the item still open, `session.pick.press` with the side, the version picked and the version in use before and after; official on the right with no explicit pick followed, the viewer’s pick removed, a second press writing nothing (`explicit-in-use`); a create picked, so the next chat forks a new draft instead of writing it in place, its right side `not-found` (`no-side`); a patch of the version official names writing nothing; a patch of an unpicked draft picked, its `before` no Pick; an official version under a pick of another brought into use; a live session picked in with its chat running, its Discard refused `session-running`, the ledger kept; another author’s record refused `not-yours`; Pick all every left in order of `n`, again on a second pass with nothing written, a discarded item skipped `decided` and refused alone; a legacy `accepted` item read as open, picked back and forth, never rewritten, then discarded; a version no longer found `not-found`, an empty record’s pass said; an unexpected failure logged with its stage and side and rethrown; a fork discarded, its pick moved to the base; a create discarded while the parent names it, the listing following; a file changed since set aside all the same, no hash compared; a later chat’s patch of the round’s draft discarded by flagging the draft, and one of a draft picked meanwhile refused `in-use`, nothing written; an official version `official-first`; a pick that could not follow `pick-not-moved`, a parent that could not `parent-not-updated`; Discard all in reverse `n`, the listing patch recorded with nothing written (`follows-children`, with the decision’s inputs), the create flagged; inside a chat’s command refused `in-command`, no session started; a hand-edited item naming another author’s version refused `not-yours`, the pass going on, its old `result.sha256` read as it is; after a Discard whose outcome went unrecorded, Pick refused `discarded` and Discard recording it with nothing written; writes crossing: a pick queued before Pick not bypassed, its decision taken in the queue; a username changed while Pick’s or Discard’s write waited refused `viewer-changed`, nothing written as the new name; a Pick pressed behind a Discard of the same item waiting its turn, refused `decided`, no pick written; a decision recorded elsewhere while Discard’s write waits in its queue refusing the write there, `decided` with the outcome found, the version kept; Pick then Discard pressed at once, picked then set aside, the pick moved to the base; an entity a write before Pick took away `not-found`; a file changed on disk refused `stale` and the pass going on; every operation’s start logged before its guards and each skipped item’s line with its reason and the version its side names; the review’s close by id and the dock’s close in either order one close of one record (`session.close.again`), the first reason standing, and Discard all after it written on the closed record, not refused `session-running`; an id with no chat noted `session.close.noChat` and answered at once; the owner’s case — a chat’s fork of the person’s project file discarded by Discard all, the person’s own version the project file of record again; Discard all of five items publishing the film once, at its end, every flag and outcome held (`project.publish.held`, `project.hold.end`); a chat that declared three periods — one relabelling the untouched default, two appended, a fourth already declared and no item — leaving after Discard all the epochs as before, the periods last and logged `session.discard.epoch` with `removed` and `restored`; a period at which the chat made a character removed with it, one the person’s own character is at kept, refused `epoch-in-use` with its users; with the round’s draft of the project: a period discarded and the draft then picked keeps it out of the timeline, the draft picked and a relabel then discarded gives the earlier name back in the draft in use, Discard all sets the draft aside and leaves the version in use as it was, a draft set aside is left unwritten, and a draft changed on disk refuses `stale` with the version in use as it was and the item open
`packages/filmopen_state/test/assistant_session_ledger_test.dart`	the Assistant Session’s ledger and its `as` record (§7.4): the first content item recorded telling the dock once, a pin alone or a failed record write telling nothing; the live chats published at each open and end, a close whose record failed included; the record’s `action` and `entity` from the chat’s own request, a form section’s chat whose first write is another entity’s, a page’s action with no `entity`, a chat not opened here with neither; a create’s writes one `create` item, its content moving the result (`{updated}`, no hash), and the listing a `patch` item with its `before`; a second write of a stem moving the result, kind and base kept; another chat on the same draft a `patch` item with its own `before`; a pin then a refused fork a pick and no item; a refused command’s partial writes kept; a chat that wrote nothing no record of a person’s writes; the history from the opening: the record written at the opening, open, no item, no word, then rewritten with the person’s words before the model is told them and at the turn’s end with the exchange and the reply, `session.recorded`‘s kind, messages, last and bytes, the record closed with them; an opening that cannot be written letting the chat go, a send that cannot be sending nothing (`unsent`, no message, no turn), the failed opening’s notice not shown; the close’s write held past the close still writing the history; a failed record write logged `session.unrecorded` and written with the next event; two writes of one chat at once one record; a person’s save between two of the chat’s writes closing the item, the next write a new `patch` item whose `before` holds the person’s edit; each result’s SHA-256 that of the file on disk; a refused record write the open chat’s notice (`unrecorded`), the next write recording every kept item, the next turn clearing it, a closing chat not told; the close (§7.4): `ended`, `status: closed` and the items’ `summary` words each once in order, the ledger let go; a chat that wrote nothing closing its record from the opening, with no item; the first and a later write held across a close recorded before it; the record’s last write held past the deadline ending the close at it, `recorded: false`, `outcome: timeout`, the record still open, then closed in its film once released, `session.close.late` saying so; opening another film while that write is held bounded by the leaving’s budget, nothing written in the new film; a write outliving the close’s bound `session.late` and not recorded; two requests one close; opening another film and Close project closing the record in the first film, a later write of that chat late and a new chat’s a new record in the second; a close asks no model: the backend sent nothing, the record’s summary the items’ words in order, `session.summary {session, reason, words, summary, ms}`; items that carry no words no summary; a turn running at the close cancelled; that turn and tool work that never settles each ending the record’s slice before the deadline, the record closed within it, `recorded: true`, `outcome: recorded`, no `session.close.late`; a new close telling `onCloseBegun` once, already kept, a joining close not; the quit’s cause the summary’s reason; a film change while a person’s close waits on a tool call held to the film change’s deadline, the tool call given none of a deadline no longer than the record’s slice and the record closed within it; Close project while a person’s close waits on a tool call closing the record in the film before it closes; a write crossing the quit’s close in its closed record; a refused open closing nothing, the chat’s next write recorded
`packages/filmopen_browser/test/discarded_pages_test.dart`	the pages that read a discarded version (§6.1, §7): an epoch whose every version is discarded opening a page of one of them; a pointer naming a discarded version showing no official set; the category page leaving out an entity wholly discarded, row and number, a category wholly discarded its empty state
`packages/filmopen_state/test/sets_tree_test.dart`	the tree’s Chats and Render batches (§8.2): Chats under the project, before Script, every chat record newest first — the viewer’s newest open one too — by its local minute, archived first in the detail of a record whose chat is not live here, another author’s named, none without a chat record; Pending and Comps before the plain render batches, no session group there, then complete queue history with stable row ids and selections, an empty or partially settled record incomplete and an all-error record complete, the count still plain render batches; two pending comps, the newest pending and first, the older in the history; another author’s record named; no sets, the empty Pending row and no Chats; a tree build logging no line; `PendingSelection`’s JSON and match key; a chat’s row named by its action and entity (build-film · Grail Check with no catalog), the minute in its detail; a record with no action keeps the minute
`packages/filmopen_state/test/tree_cues_test.dart`	the tree’s Cues rows (§9.2, §5.12) on a 500-scene film: each cue resolved a few times per build, never once per scene, for two viewers; a cue whose versions in use name different scenes under each viewer’s; a scene’s explicit empty `cues` holding none
`packages/filmopen_state/test/discarded_tree_test.dart`	one author without child rows; several handles, including discarded-only authors, alphabetical and flat, discarded-only rows labelled; an older pick checked on its latest author row; an entity wholly discarded having no row, whatever its authors, in the library, the pipeline, the Areas, a scene’s implicit Shots and Not in the script, and left out of every count; a live area of a wholly discarded location at the top level, flagged; `retainedGroupsOf` leaving it out and `groupsOf` keeping it; ignored discarded picks and pointers unmarked; `groupName` and `groupVersionCount`
`packages/filmopen_browser/test/set_list_page_test.dart`	the one set page (§9): each type’s header, chips and rows; a posted comp without ×, and a session’s record opening its review page; two pending comps, the older’s page without ×, the newer’s × removing from itself through `PendingSets.remove` with `next_item` kept and its log lines; another author’s pending comp without ×, and an older one’s fields read-only, without its choice; the empty pages saying what fills them; 375, 532, 700 and 1200 px
`packages/filmopen_browser/test/queue_page_test.dart`	the pending batch’s page (§6.15, §9) on a scripted runner: the rendered/failed header at 375 px light and dark logged once on completion, every row state, the × only on never-submitted rows of the current pending record, 1200/700/375 px light and dark; Render pinned at 44 px, a press running one pass on the record’s own page, disabled while it runs and for another’s or a submitted record with its reason, a refusal said; Finish and Mark through the runner, done, nothing changed or failed said; the heard outcome drawn without a page-owned write — the phase logged once per change, Stop sent, the take visible before its record write, Outcome not recorded and Open the place, a recorded failed or cancelled job offering Add again with nothing resubmitted, all three terminal phases saying the queue’s failed write in the right sentence, a failed job and a refused action in words, no Dismiss; Add again — a new item, the refused one untouched, refused while still not editable, one append for two presses, a new pending record during a pass and both reachable, two pending records with overlapping `n` independent
`packages/filmopen_browser/test/comp_action_test.dart`	Add to comp (§9.3): one item written with its reference, batch, item, the take’s source and purpose, and the record made, its log lines in order, the message’s Open to the pending comp; a picture placed by hand on a character a `sheet`; a second add of the same reference refused with nothing written, also while the first add’s publication still lists — decided from the view, one item, the refusal logged with the pending comp; GIF, BMP, MOV and FLAC refused, a take’s by its file; an address, bytes held only in memory and a file not in the folder refused as having no file; disabled on a read-only project, and not gated by the version’s access; disabled while this app posts a comp, its reason said and logged, available again as the post ends; registered while its host is mounted, taken back as it goes
`packages/filmopen_browser/test/comp_page_test.dart`	the comp’s page (§9.3): the title written once, 700 ms after the last change, each changed field logged with its value; the description and the public choice written on leaving the page; Close project and a change of username within the delay writing what was typed first, as the one who typed it, a save in flight waited for, and never into the next viewer’s comp; a comp that becomes the viewer’s own on a change of username an open draft from then on; a refused write said and answered unclean to the next settle only; a record no longer the pending comp refused with nothing written; a read-only film’s pending comp locked; × removing a row; POST disabled, 44 px, its tooltip the first reason that holds — empty, no title (a blank one included), not signed in — on its own node, and enabled once none holds; POST on a scripted poster writing what was typed, then `posting` before `prepare`, the page following the record, locked with Posting…, a receipt `posted` with its URL, revision and time, a refusal `pending` with its `error` said inline and POST offered again, the next post beginning without it, `account-mismatch` in its own words, a refused prepare publishing nothing, a second press doing nothing, POST drawn disabled with Posting… while it runs, a refused field write posting nothing and said, inline after the message has gone and never on another comp turned to, which shows its own error, the post outliving its page left and come back to, a refused post left and come back to the current pending comp, editable, with POST; at 1200, 700 and 375 px, light and dark, posting locked with its progress, then refused and said, then posted with its URL, nothing overflowing; a record left `posting` with no post of this app running `pending` again on open with its sentence, one whose post runs left alone, another author’s not changed; a posted comp with nothing editable, Open in browser handing the launcher its URL, a refusal and a throw said and logged, an address that is not the web’s never handed on, Share putting it on the clipboard and a failure said and logged; a 2,000-character description at 700 and 375 px overflowing nothing, the rows still reachable
`packages/filmopen_browser/test/discarded_on_screen_test.dart`	a discarded version on screen (§9.3, §7): the banner, the star unlit and no official-edit banner where a pointer names it, no action on the banner; another author’s page the same; the pull-down’s divider and discarded entry; an author with no retained version, no divider first; the overview’s card naming the discarded versions with no action and no Create, the missing card’s nothing to copy sentence, New outfit’s reason and the category list leaving the entity out; the banner and the card at 375 and 700 px; the sentences of `official-first` and `noFile`
`packages/filmopen_format/test/next_epoch_encoding_test.dart`	`next_epoch` is encoded as a whole number where it fits an allocated id (`4.0` becomes `4`), counting own ids and removed declarations, never lowered, and an oversized floor is kept as it is.
`packages/filmopen_store/test/app_log_test.dart`	JSON-line shape, thresholds, verbose and the environment pin, a recording forcing verbose in memory and its end giving the setting back, a failing sink, unencodable data, `timed`, the file sink, its 1 GiB default and its rotation, `log.rotated` the fresh file’s first line with its source, destination, bytes, time and mode, an error quoting a text box’s value keeping it as it is; a URL’s user, password and query reaching every sink as given — the data at any depth, the error and the stack, every value whole, and a sink holding entries seeing the map it was given
`packages/filmopen_forms/test/page_access_test.dart`	what a page may do and which red lines it shows (§9.5), without a widget: enforcing — the viewer’s own file, the star for directors, the library locked, no line; development mode — another author’s version editable with its line, the star for everyone with the directors’ line, a library file editable where the library can be written and, where it cannot, not editable with its own line, no handle writing nothing and saying so, a folder the system refuses; `directorHandles`, and the directors’ sentence naming them or saying the project names none
`test/development_mode_test.dart`	development mode on screen (§9.5): another author’s version opening in Edit with its red line and what is typed written under its author; the star pressed by someone who is not a director, writing the pointer and saying the directors’ sentence again; a label written on another author’s version under its author, the message repeating the line; Compare opening on the viewer’s own latest with its reason as a red line; an empty username being `default`, the line naming it as the author editing another’s version and no line asking for a handle; a session copy’s line offering Copy to a folder…; and, enforcing, no red line, View, and the star disabled
`packages/filmopen_store/test/guards_test.dart`	development mode on an in-memory project (§9.5), one group per row of the plan’s table, each enforced and in development mode: another author’s version (refused; written under its own author with the override logged at warning level, with its data), official without being a director (refused; set and cleared, two overrides), no handle (refused in both), a read-only folder (refused in both), the shared library (refused; written into the library and not into the project, and both overrides logged for another author’s library file; a read-only library and a library file without a handle refusing with no override logged) — and the rules that protect files refusing in development mode too, with no override logged: a changed identity, missing content, a project file’s `forked_from`, a stale file; `guard.overridden` with the stem and the author as they are; under `Guards.enforce` each rule’s refusal logged once as `guard.refused` with its rule, viewer, file and reason, and none in development mode
`packages/filmopen_state/test/settings_test.dart`	the docked assistant’s width (§9.1) kept across a start and its save logged as an operation, a store that throws or no store a failure logged by its code, the width kept for the session; recent projects (tolerant parsing, order, no duplicates, cap), library path and verbose defaults, and the viewer being the username when it is a handle — anything else, `official` included, is `default`; the username (§9.4): a fresh installation `default`, kept in the store and logged by its code; a stored blank, invalid (`ab`, `-abc` among them), reserved or non-text value `default`, said by its code and the value, and written back; a valid one restored as it was and a chosen one across a restart; an emptied box `default`, a text that is not a handle changing nothing; a store that cannot write keeping it for the session, in `unsaved`, until Try again writes it; the open drafts written first as the username they were typed under, a later change deciding over one still waiting; a draft that cannot be written refusing the change with its own refusal, or `DraftsNotSettledException` where it gives none; a text that is not a handle leaving a change still waiting on the drafts to land; `viewerSettled` completing at once with nothing waiting, and only once a change waiting on the drafts — and one asked for meanwhile — has landed; *the folder New project* proposes** (§9.2): none on a fresh installation, kept and restored across a restart and logged by its path; a stored value that is not a text none, said by the preference’s name, a blank one none; a store that cannot write keeping it for the session, in `unsaved`, until Try again writes it; development mode’s default taken from the build and its setter deciding `Settings.guards`, which a build without the mode ignores; dictation’s microphone and Hold to record, their defaults, a device cleared back to the default, the chosen microphone’s name kept with it and gone with it, read back only beside the id it was kept with, and the log naming the device and its name; a choice written in the background logged `settings.keep.start` as its write starts, then `settings.kept` with its key, value and outcome, a failure with its cause; the fallback write of `default` counted as the username’s last write, `viewerStored` waiting for it and answering that the store refused it; a change of username while scene 1 is held in its write, scene 2 typed into and scene 3 opened meanwhile, all three written as the old username before the new one is taken (`OpenDrafts.settleUntilQuiet`); typing that outruns the five passes refusing the change (`DraftsNotSettledException`), one write a pass and the username unchanged; the export’s encoder (§19): `auto` until chosen, Software only kept across a start and its save logged with `{old, new}` and the elapsed time, an unknown stored value read as `auto` and logged, a value that is neither refused with its start, code, reason and elapsed time, a store that throws a failure logged with its cause and marked unsaved until a later save succeeds, nothing retried by itself; Compare’s Show changes only on until chosen otherwise, a saved off kept across a start, and logged as an operation, no store a failure logged with the choice kept for the session; a build without development mode (`developmentModeAvailableProvider` overridden off) reading no stored switch and enforcing every guard, a build with it reading the switch, each start logging `settings.developmentMode`, and a change logged at its start with the value it replaced and at its end with `saved`, its reason and the elapsed time, or, where the store throws, answering false, kept for the session and logged `failed` with its code and cause; the switch’s failed write marked in `Settings.unsaved` and cleared by the next write that reaches the store; the render dialog’s last options (§9.3), one `render.last` entry per media kind and stage, surviving a recreated container, an unreadable value nothing with its code and cause, `settings.read` and each write logged whole
`packages/filmopen_ui/test/stage_selector_test.dart`	the shared stage selector: the three words, the value chosen, each segment identified `<id>.<token>`; initials below `Breakpoints.stageLabelled`, the word in their semantics, the narrow density and drawn smaller rather than overflowing; a tap answering the stage tapped and the stage in force again; held, no callback and the reason before every tooltip (§9.3)
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the order, Recommend, Images, Add to batch)	the dialog opens at the version’s stage, Recommend collapsed over Recommend: model, platform, settings, the stage, the prompt, Recommend and Images top to bottom and the price to Images’ right, Add to batch enabled with Render, held with Render’s reason while the plug-ins are read again, absent while a voice is designed, and answering exactly the request Render would, queued, each logged `render.answer {queued, model}`; Final in the dialog the request’s alone, the file and the page’s draft unchanged, the picker asked again and its model landing; a model chosen by hand kept at another stage, the picker not asked, the same stage `same`; an option or the count changed no model choice; while the recommendation at a changed stage is asked Render held, the new model then landing and sent, a model chosen by hand meanwhile kept, a dialog closed meanwhile ending the stage operation in the log, a landing under an open menu logging its end as it lands, and an answer that cannot be read holding Render with why and Recommend open until a model or the stage is chosen again; the same model and route at Final with other settings applying them and priced; a ready model with no picker recommendation renders; a refusal among Recommend’s controls opening it once; Images 1 by default, priced again and sent, the price once beside it; 0, 2.5 and 5 refused and logged with the text typed, an emptied one set to the route’s default; held at 1 with why where no count is offered; no box at a voice design, ready or not, its price or its not-ready reason still shown and `hidden`/`notImageKind` logged; no overflow at 375, 532, 700 and 1200 px collapsed and expanded (§9.3)
`packages/filmopen_forms/test/save_refusal_wrap_test.dart`	a refused save on the first card’s title row beside the file menu, at 1200 px, at the 360 px a page has beside the tree at a 700 px window and at 311 px: the stale refusal’s sentence painted whole, wrapped (`didExceedMaxLines` false), nothing overflowing, and at 360 and 311 px its way out under it, the sentence never narrower than the button (§9.3, helper and error texts wrap)
`packages/filmopen_forms/test/stage_control_test.dart` (the stage on the media card)	Prototype, Draft and Final in order with their tooltips and identifiers; a tap writes `render_stage` through the form and logs `media.stage.` with its stem; a stage moved up logs `media.stage.outdated` once for each render it puts below the stage — not one already below, a deleted one or an upload — and a stage moved down none; a held form says why and refuses; the same stage is not written; words on a wide card, initials on a narrow one, at their own size, a failed write wrapping the title row rather than crushing it; the card owns the key, so Other attributes* does not show it; a fork keeps it (§9.3)
`packages/filmopen_state/test/no_viewer.dart`	not a test: settings that name no viewer, the one door through which the controllers’ tests reach what they do with none, the username itself never being none (§9.4)
`packages/filmopen_state/test/build_stamp_test.dart`	the build’s stamp (§6.6a): a CI build and a local one, two local builds a second apart two stamps, a build with no moment, seven moments that are not an instant in UTC to the second left out (a space, a zone, a fraction, 31 February, 24:00, a word, a tail), defines of any length and any character giving printable ASCII within 120 and a version within 40, a full commit hash fitting, and the platform in lower case
`test/about_stamp_test.dart`	the build’s stamp on the whole app at 700 px (§6.6a): Settings → About and the support dialog’s About tab each show `FilmOpen <stamp>` as selectable text, the bare version gone; the stamp of a build without a script is the version with `dev`, `local` and the platform
`packages/filmopen_store/test/project_creator_test.dart`	creating a project on a real temp folder: a manifest with no `data`, exactly the root manifest and three folders, with two documents in `data/` and empty `media/` and `thumbnails/`, the first version (director, one epoch, no `kind`, `children` of `["sc_1"]`) and the first scene — its keys, its localized name, in use without a pick and nothing unfiled; a blank scene name falling back to the short name and a workspace writing as itself; refusing a non-empty folder and a bad tag; deleting a project folder with everything in it, a folder with `data/pj_…` and no manifest refused even though it opens as a project, and a folder without a manifest, a missing folder, a file and a link refused with nothing touched; a project that could not be finished taken back — an invalid author leaving no new folder, an existing empty folder left empty and usable, a link to an empty folder preserved with its target empty again, and `writeNewProject` refusing an invalid handle before it writes anything; a manifest-only session copy creates empty `data`, `media` and `thumbnails` folders; copy preserves arbitrary binary bytes under a `.txt` name and a directory source’s UTF-8 byte-order mark through an overlay; trash refuses links with trailing or repeated separators, `.` and `..`, preserving both target and parent manifests, sentinels, listings and link targets; a project under a linked ancestor deletes while the parent link and sibling bytes stay; a real project with a trailing separator still deletes; filesystem-root spellings are checked read-only without creating a root manifest or attempting root deletion; Copy to a folder streaming a file the source has on disk, never reading it whole
`packages/filmopen_store/test/first_scene_test.dart`	`isUntouchedFirstScene`: the template’s first scene as written; a key added, a saved time, a missing time, another version or tag not untouched
`packages/filmopen_store/test/project_writer_test.dart`	the writer on an in-memory project (§13, §17): save keeps unknown fields and stamps `updated`, refuses other authors, no viewer and read-only sources; fork numbering for own and others’ versions, the fork identical apart from the header and without a version label under either spelling, a project fork adding its author to `contributors`, the fork becoming the pick; the identity lock and a repair towards the filename, a stale file refused, a duplicate key refused at read, content validation, only a director writing the pointer; a new character or location written as the viewer’s v1 with its name and kind, directly in `data/`, recorded as the creator’s pick with nothing official, and refused for a tag the type or the library has, a bad tag or epoch, an undeclared epoch, a type without epochs, no handle, no name and a read-only folder, with nothing written; official set (rewriting the pointer, dropping its note), new pointer, clear; the pick order (pick, official, own, sole owner), the date a pick carries and abandoning one, pinning versus tracking official, a missing or other-epoch `pick` with its warning, per-epoch picks, the folding of an older stem and of the plain date beside it, workspace handles inheriting the owner’s pick, the project file following §4.1 unless a pick says otherwise; epoch order, re-encoding, default-epoch fallback, the no-epochs warning; kind vocabulary; and, a new folder and a new scene — the viewer’s v1 with no epoch in its name, a folder’s kind, the pick as a plain stem, no `children` written and nothing listing the file until the caller does, directly in `data/`, refused for a taken short name, an epoch, any other type, a bad short name, no handle and no name with nothing written, and a file of that name that appeared meanwhile refused and never replaced; the last look — `visited` written into the viewer’s own file only, per epoch, the pick and the entries kept, a second at one epoch joining the object, a file made where there is none, nothing written at an instant already recorded, refused without a handle and on a read-only project, kept in memory on a session copy, the plain shape for an entity without epochs and giving way to the object; deleting a take — the viewer’s own unnamed take and its thumbnail removed with the record kept, a take a plug-in rendered under the viewer’s workspace handle removed and another’s refused; a fork with content — the changed version written once, its header the fork’s and no version label whatever the content said, the source untouched, the fork the forker’s pick — refused, with nothing written, where the source changed since it was read, its identity is not the source’s or its content is not a version’s, another author’s refused as `NotYourFileException`, one another document’s live entry names refused naming it, a render’s and a batch’s inputs keeping nothing, a reference that is no take deleting nothing, refused without a handle; and the loader’s media warnings, each against its file; `deleteTake` refusing a take another author’s document names under a key that cannot name a group, the bytes kept; a plug-in’s setting the app does not know kept by a save, a fork and a plug-in run; non-null non-list children on projects/folders is refused with no write and the full sent value logged; null, lists and scene children remain accepted; a plain fork copies stored bad children unchanged and its next content save refuses it.
`packages/filmopen_store/test/prompt_stamp_test.dart`	the writer’s stamp of a prompt (§6.1a): a changed prompt stamped with the file’s `updated`, an unchanged one keeping its own unless carried (below); a new prompt stamped; a block’s with the block’s time, the file’s unmoved where only the stamp moved; a prompt identical but for `created` no content; `created` removed with the same words stamped; a stage chosen moving nothing; a fork written with content stamped against its source, an ordinary fork keeping a current prompt current; `promptsStamped` on `entity.saved` and `entity.forked`; `entity.saved`’s `prompts`, each stamp with its reason (`new`, `changed` with its members, `restamped`); a scene of 500 blocks, reordered, one prompt changed and one block added, stamping those two alone. A stamped prompt carries its holder’s current neighbours (`carried`), so two saves leave both current; a change of the holder’s other content carries nothing and names the keys; a block’s words carry that block’s neighbours only, moving the block and the scene, the file’s own prompts and other blocks kept; a same-word restamp moves only its holder; outdated, timeless and empty neighbours stay; `visual_style.prompts` is the file’s; `entity.saved` holds each holder’s decisions; a fork written with content does not carry.
`packages/filmopen_store/test/render_record_test.dart`	a render’s record (Project Specification §12.2, §7, §10.3): the loader’s warning row for a `render` record without a `request`, the record still listed and its items readable; the writer’s render record — `kind: "render"`, its `request` once, its items its files alone — refused where a required member is missing or null, and refused for a `tier`, a `partial` or any status but `done`, `failed` and `cancelled`; an import’s record with no `request`; `updated` as the content last changed — a note, a favourite, an inserted take, Keep and Reject leave it, a content change moves it — a block’s `updated` stamped where its text or its beats changed or it is new, and a fork keeping its source’s, entries and `kept_at` copied as content; the plug-in’s `metadata` and `metadata_refused` at the top as the run carries them, `delivered` and `error` never written there or in `request`; the place the render ran written in `request` where the run names one and read back, an older record read as before; the write’s lines — `writer.start` `importBatch` with what the run carried, `batch.written` with the request whole and `ms`, `writer.refused` naming a lacking member, `writer.failed` at the write with the exception’s message
`packages/filmopen_format/test/character_age_test.dart`	the age shown from a whole number or the exact `"N (YYYY)"`, none from a phrase (`"31 (1999) "` one); the legacy year of birth from the exact form; `ageFromYear` at an epoch with a year, without one and after it. Birth-date year/month/full-date precedence, a month giving its year’s age and a month or day out of range refused (`isBirthDate`), malformed authoritative dates, numeric fill, legacy read and input purity; all five kept reasons, including a missing era and malformed appearance.
`test/editing_test.dart`	editing through the screen on an in-memory project: Settings’ username box explaining a reserved or malformed handle and a dot with nothing on one side, the username staying what it was and named under the box, and taking an empty one as `default` with the box left empty and its hint shown at rest; a text pasted into an emptied box kept with its reason; a username waiting on an open draft landing without writing over a dot typed meanwhile; a change refused by a draft that cannot be written said under the box in the save’s words, and Try again asking the box’s text again; a username the store could not take said with Try again, which writes it, Settings → Development switching the provider’s writer from refusing another author’s version to saving it with the override logged, a pick naming a missing file removed with the check on the official version, Fork carrying what was typed a moment ago and stopped, with a message, by a draft refused as stale, its `write.fork` started at the press and timed through the drafts’ write, moving away twice and back while a save is held in flight with each file keeping what was typed into it, Compare’s fork dialog waiting for a draft another page left behind before it copies, an abandon with nothing to abandon writing nothing and answering false, the project form saves after the delay and the page survives the re-read, somebody else’s file offers Fork, Fork makes and shows the next version with the check on it, the tree shows flat author rows only for several handles, with an older pick checked on its latest author row and history in the pull-down, two genres in one save window, the version label, the check marking a pick and moving on a click (official in use wears the star alone; the check on the version in use only says why; the director’s star removes their own pick and leaves nothing stale; the star is disabled for a non-director), abandoning a pick and keeping it, a workspace whose owner has a pick writing the tracking value into its own file when it abandons and when the star moves (and writing nothing when the owner’s pick already names the new official), the star re-reading the folder even when the pick removal is refused, and the banner a pick the project overtook raises: its two answers, a refusal that writes nothing, nobody else being asked, and the project file asking on its own page; the §13.2 banner on a type with no form of its own and the version it forks, the file menu’s editor, folder and clipboard items, the viewer’s pick choosing the project version with a project fork picked at once, a rename in the version in use naming the epoch overview, a year of birth after the epoch refused inline and never written, a typed year stored as `"N (YYYY)"` with the epoch named in the hint as the tree names it, the overview’s age read from the stored form, and the JSON editor’s inline refusals; the epochs row in a provider scope, as in the app, since its boxes’ microphones read the dictation settings, and its label keeping more than 150 px of a 239 px card; a change of username refused because a page was still being saved after every pass said in a sentence of its own, pointing to no save
`test/project_menu_test.dart`	the ⋮ menu’s items (Copy to a folder… offered for a project in memory and not for a folder on disk), the New project dialog’s filtering, the director shown, prefilled with the username in effect, and never required, no file announced (the local creates uncheck the cloud box), creation into one folder with no locator and an upload into that project’s `media/`, the View toolbar’s folder and clipboard items on somebody else’s file, the library chip
`test/copy_to_folder_modal_test.dart`	Copy to a folder…’s dialog (§9.5), its copy held: what was typed in a focused field in the files copied, the field without the focus, a tap on the field and Escape reaching nothing and closing nothing, and the dialog alone taken away once the copy is open, its message said — from the project menu at 1200 px, from it in the drawer at 532 px with the drawer left open, and from the page’s line, the page leaving as the copy opens; a second ask while the picker is open copying nothing more; a copy refused taking its dialog away and saying why; an exit asked while a draft is still being written, before the copy starts, and one asked mid-copy, each answered only once the copy has ended
`test/phone_folders_test.dart`	a phone’s folders through the providers: Open project… is on the phone’s menu; Copy to a folder… is not; New project without the parent row, its Browse button and any media location controls, saying where the project goes under Folder for the project:, the project made under the app’s folder with its media inside the project folder, Create enabled; Create waiting with its reason while the folder is found and refusing with the sentence when it cannot be made; a remembered project under the folder listed by its tail; Settings → About naming the folder and the library card without Choose folder…; teardown retries only Windows sharing violations (errno 32), at most ten attempts within about a second, rethrowing other failures
`packages/filmopen_account/test/account_auth_test.dart`	the callback predicate (exact scheme, host, path; `code` or `error` required; fragments refused), the error mapping to problem codes that never carry the server’s text, and the log’s error data carrying it — `AuthException.message`, a `PostgrestException`’s message, details and hint, through the app’s storage wrapper too
`packages/filmopen_account/test/account_card_model_test.dart`	a sign-in reading nothing beyond the session, no profile request and no notice; the sign-in result through the link door: a callback opens the client and is exchanged through it whatever started the app, its refusal a notice and not pending; the same link handed twice is acted on once; another link with a client there is exchanged too; and a second model acts on no link the first already spent, a ledger that forgot being a fresh process; the defaults naming the development project; a launch with the hint restoring through the model, logged `account.restore`, `account.connected` and `account.restored` with its milliseconds, a hint that outlived its session cleared; a session the first connection restores posting neither a code nor a password sign-in and opening no browser for a provider, logged `account.signIn.restored` and `account.finished` with its time; a code sent logging its recipient whole, a refused address `account.refused` with its reason and the gesture `refused`, each with its milliseconds; a second code for the same address asked of the server, its own limit the rate limited sentence, logged `account.failed` with its time; the password road — a sign-in by the address and the password logged by its method and address, a refused pair its own sentence, logged as a refusal and the gesture’s one end `refused`, and another refusal the general one, ending `account.failed` with its time, an address that is not one or an empty password refused before anything connects, each logged with its reason, the password in no log line; a code that is not one refused before anything connects, logged `invalid-code` without the code
`packages/filmopen_account/test/account_withheld_test.dart`	an agent build’s account (§6.6), withheld: the connection answers not available (`AccountWithheldException`, the `unavailable` problem) with no client or secure storage made (`account.withheld`, neither `account.initialized` nor `account.initFailed`); a callback and a password sign-in reach no session and leave no client
`packages/filmopen_account/test/account_registration_test.dart`	who registers the sign-in’s scheme at run time: the desktops, not a phone, each through the platform override
`test/account_profile_test.dart`	the FilmOpen account’s place on the rail, its popup and the sign-in dialog (§9.4, §6.6), pumped without any plugin and without a progress bar: another setting’s change rebuilding neither the rail’s profile nor the signed-in popup, the username’s rebuilding both; signed out, the rail’s lines — the username, `default` where none is chosen, Login and Signup — and the whole as the tooltip; a chosen username shown, a long one cut with an ellipsis on a rail no wider than 64 px and whole in the tooltip; the popup one login button with the logo and no other button, no provider name, no e-mail box, and Close; the profile asking the link door once at start and ignoring a link that is no callback; a callback that comes while the popup is closed exchanged by the account’s state, once, and not again when the same link comes back; the Windows argument and the door carrying one link exchanged once; a door that throws logged rather than thrown; signed in with a stand-in session — the rail’s username in effect and no balance line where none could be read, no amount anywhere, the popup naming who and the balance’s sentence — and Sign out here returning the rail to Login and Signup with the username kept; the one opener opening the popup, and a second request while it is open opening no other; the opener’s reason said at the popup’s top, before what the account is, and by no popup a press opens; a code sign-in through the dialog — the code sent and verified by the stand-in — closing the dialog once, the popup beneath still open on Signed in as …; the browser’s opening for a provider sign-in said in the popup and no message behind it; the profile one focusable button to the semantics, its lines its label; a session the hint promised that cannot be restored leaving Login and Signup on the rail and the hint kept; the login button’s sign-in dialog with the logo, one marked button per provider, each 44 px, the or rule and the e-mail box with no microphone; an invalid e-mail refused inside the dialog before connecting, its text not outliving the dialog; the device notice only where a registration is installed; the profile and its popup at 375 × 420 px, drawn in the theme chosen, light and dark, nothing overflowing and Close at the popup’s end; and every problem code with a sentence of its own. The public snapshot (`AccountSnapshotAdapter`) through the real state: a fresh start signed out, nothing connected; a returning session whose client is held loading, then signed out; a launch with a sign-in’s result held loading; a restoration that fails signed out; a signed-in user authenticated with no address in the snapshot, a sign-out signed out; a state let go giving the default back, a newer source kept, a detached adapter silent though its state moves on. The rail and the popup over fixtures: a known balance in dollars from its cents (zero as `$0.00`, a negative with a true minus) on the rail and in the popup, a long amount shrinking to the rail on one line, unknown as words and unavailable as no line, with no digit, loading, a source that cannot say, signed out; the default source reading as signed out; a change drawn at once on the rail and in the open popup; the balance read from the website through a stand-in reader — nothing asked while signed out, the bearer sent, Balance unknown while the first reading runs, then $1.23 from 123 cents (`usd_cent`), read again as the popup opens with the last amount kept meanwhile, and a reading still out at a sign-out dropped; the rail shows the username in effect, never the display name; the popup’s Username pull-down at 1200 px light and 700 px dark — signing in sets the primary, a choice is the username, a draft’s refusal said with Try again, the refusal forgotten when the account changes; a failed read shown with Retry; a refusing draft at sign-in leaves the username; the snapshot carries the account’s id, never serialized; a returning session restored after a held client calls the sync binding’s `accountReady` once — the saved hint alone does not, and a sign-out releases nothing; the dialog’s boxes and buttons found by their identifiers, the password box obscured, its button with the box empty asking for the password and its Enter signing in without a code; a code sign-in that ends after Escape closed the dialog leaving the popup open on who is in
`packages/filmopen_account/test/account_balance_test.dart`	`GET /v1/balance` against a stand-in: the bearer sent to the build’s domain, `available` in `usd_cent` read as cents, a known zero; `balance` carried as `balanceMinorUnits` (`reserved` not read); the read logged `account.balance.start` then `done` with its status, both amounts and `ms`, `noSession` where no session answers, and `failed` with its stage — `token` for a session that does not answer, `send` for a refusal or a failed request, `decode` for an answer not of the shape; a unit other than `usd_cent` (`usd_micro` among them), a non-integer, a negative or a missing amount, a page that is not JSON, `401 no-token \| bad-token`, `403 no-ledger`, `500 ledger`, `503 identity-not-configured` and a failed request each unavailable with its code logged, a malformed answer whole, a refusal with the server’s `says` beside it, a failed request with the error’s message, and never the token; no session, no request
`packages/filmopen_account/test/account_ledger_test.dart`	`GET /v1/ledger` against a stand-in (§6.6): the path, `month` where one is shown and `limit=200`, the bearer alone; `next` followed as `before`, two pages read complete, five pages still naming a next read incomplete and a sixth never asked for; a lending settlement read as a debit with its job and an earning as a credit, a funded settlement, a kind this version does not know and a job under `detail` read without a job; a lending object whose job id is empty, not a string or not an object, a `next` neither an integer nor null, an instant that does not parse, months not a list or not of the route’s pattern, a unit of micro-dollars, a non-integer amount, a record without a ledger or not an object, records not a list and an answer not an object each unreadable as `malformed`; a second page that cannot be read dropping the first; `400 bad-query`, `403 no-ledger`, `500 ledger`, `503 money-off` and an HTML page unreadable by their code, logged with the website’s words or the page as it came, never the token; a malformed answer logged as it came; no session, no request; a 401 signed out and not a failure; a transport failure unreadable as `unreachable`, logged with its type and message; the read’s start, each page before it goes and as it answered with each record’s id, instant, kind, cents and job, and its end — complete, incomplete after five pages, signed out without a token or at a 401 — each with its milliseconds; the default seam signed out
`packages/filmopen_account/test/account_portal_test.dart`	`POST /v1/portal/session` against a stand-in: one credential per operation, the body the registered device’s id and build with the scope asked, held for its operation until it expires and asked again after, a credential let go asked again once for its operation alone and no other’s, no session no request; every refusal code the route has — `401` a sign-in, any other not configured — logged as `account.portal.session` with the scope, the operation, the status, the code and the website’s words; an answer not of the contract’s shape, or lacking any of its keys, malformed and not configured, never a failed request, logged with the check that refused it and the answer as it came, an object’s issued token left out, and an answer that is not an object (an array, a string, a number, a body that is not JSON, each holding the issued token) by its kind, length and content type alone, never its text; the ceiling read as `spendCeilingCents`, an answer in micro-dollars malformed; the request logged with its device and build, a transport failure with its type and message; the bearer in no log line, and an issued credential’s token in none
`packages/filmopen_account/test/account_funded_test.dart`	an operation’s read and end against a stand-in for the website’s contract: the read’s URL and the headers as given, its receipt once settled re-reading the balance, none while pending; an HTML page, an answer with no `operation` or a receipt short of a key malformed; five refusal codes for the read and the end alike, refused with the code, sent once, logged with the website’s words; a malformed answer logged as it came; the end posted once; a failed transport by its type and message; each send and outcome logged with the operation’s id and the milliseconds, the token and the bearer in no line; a settled read logged with its `receiptId` and the website’s answer whole
`packages/filmopen_account/test/account_lending_test.dart`	the supplier’s and the requester’s operations of lending against a stand-in (§6.6): each one’s method, path, bearer, device and build headers, a declaration’s version answered and one not a hash `malformed`, a publication’s body `{version, published}` for both states, the identity header on discovery and preparation alone — the primary’s, read through the community’s client just before (its answered line naming it), none without a primary, a failed read refusing the operation with its code and a primary’s id not a UUID `malformed` — content type and closed body; a preparation’s `Idempotency-Key` its job id and its replay under the same identity; a preparation’s body with `input` and no `manifest`; a job’s `input` handed up as it came — an object, an array, a string, a number —; a discovered offer, a buyer’s job with its money’s facts and its result, a result not an object `malformed`; a job’s state, close reason or fail code outside the design’s values and code grammar `malformed`, logged with the summary and the rule it broke; `complete` carrying its result in the one decision, and no operation reaching a result route; a result over 64 KiB refused `payload-too-large` with nothing sent; `NoLending` refusing the requester’s operations `lending-unavailable`; `lending.request`, `lending.answered` and `lending.unconfirmed` by operation, verb, job and milliseconds, the JSON body sent logged with the request, and no bearer or device id in any line; a refusal its code alone, its words logged, not returned; `unreachable` logged with its type and message; an answer of the wrong shape, a job’s id that is not a UUID and a body that is not JSON `malformed`, each logged with the answer as it came; nothing sent without a token or a registered device; `lending-unconfirmed` asked once more by the same request, and no more; the audience read into its record and written as exactly the design’s body with the website’s answer returned, eight shapes `malformed`, `terms-conflict` by its code, logged with the words; a discovered offer’s `lender`, null where absent; the supplier’s read through every page with the bearer alone, no device; a withdrawal with no device, its request and refusal naming the path and the offer; every withdrawal outcome — a 404 envelope, a 502 page, a malformed 200, no token — logged with the offer, the path and the body sent, and the status, the answer whole and the milliseconds
`packages/filmopen_account/test/account_media_test.dart`	the media client against stand-ins of `POST /v1/media` and the signed `PUT` (§6.6): shaped as the website’s deployed code answers: the mint’s bearer, device and build headers and no body, answered `201` with its expiry in milliseconds, the `PUT`’s bytes whole with its content type as its only header — no bearer, no device —, answered `204`, the answer’s key, download URL and expiry; a 200 or 201 `PUT` a success; the log trail of every stage under one upload id, with `ms` on every line and the key from the mint on; a parameterised content type sent and logged as given; refused with nothing sent without a device, without a token, at the token’s throw and its timeout (`token-unavailable`, logged with the error’s type and message), for empty bytes and for 32 MiB and one byte, 32 MiB itself sent; a mint refusal by its code and status, logged with the website’s words; a 200 or 201 mint without `downloadUrl`, with an `http` or a relative URL, an ISO expiry, an expiry of a fraction of a millisecond or past the last instant a date can hold, an empty key, or not JSON `malformed` with the mint’s status, its field names and expiry (or its text) logged without either URL, and nothing `PUT`; a `PUT` refused 403, 413 and 500 by code and status with the key logged; a transport failure at either request `unreachable` with its stage, the mint’s with its type and message and the `PUT`’s by its type alone; two uploads in flight keeping their own id and key; after every test, no log line holding the bearer or either URL’s token
`packages/filmopen_account/test/provider_funding_test.dart`	the funding resolver over stand-ins, a stand-in website that fails on any capabilities read: keys looked up through the slots on a platform; the person’s own key first even signed in with credit, with no request; credit for `http` on any platform, including xAI, Atlas Cloud, Salad and an unknown platform, and for `conversation` and `transcription` on `openai`, asked twice with no request; another platform’s conversation or transcription not configured; a credential per operation, asked at its first `portalHeaders` with its kind’s scope (`funded:http`, `funded:openai-realtime`), held for its later calls, a second operation asking its own; `portalRefused` dropping that operation’s alone; an OpenAI `http` and `conversation` operation open at once, each read and ended with its own credential; a credential let go at its end and at a settled receipt, and a read after a restart asking one of the kind’s scope; after a hold, a zero balance and an own key since stored changing nothing; a session refused or not of the scope asked giving no headers; a malformed read, a refused one, and a `401` of the credential letting it go; a read and an end that never answer failing by their type within the bound; signed out, loading, an unregistered device, a known zero, an unknown or unavailable balance each refused with no request made and its step logged; a sign-out letting every credential go and the generation advancing; a bearer read that throws after a hold giving no headers, no receipt and a failed end, its stage `bearer` and its type and message logged; an own-key lookup that throws unavailable, `own-key-failed`; an end failed or refused still letting its credential go, sent once, and asking no balance read; an end answered 200 asking one, `account.balance.refresh {reason: end, signedIn: true}`; every `account.funding.decided` with its scope, session and drop line, the token and the bearer in none
`packages/filmopen_device/test/device_key_test.dart`	the device’s key (§6.6b): the website’s worked example — the id, the body’s hash and the six lines’ hash its contract gives, its signature verifying under its key and over nothing else; a key made here — its id the SHA-256 of a 65-byte uncompressed point, canonical spellings, a signature of 86 characters that is the same each time and verifies under its key alone, forty keys from a seeded source all verifying, the stored text giving the same key back and nothing else being one (a character too many, one outside the alphabet, the scalar zero, one above the order, 31 bytes, the spare bits set); `openDeviceKey` — one key made and kept across two launches, the second writing nothing, two calls at once making one, a store that cannot be read making none and writing nothing, one that cannot write giving none, no store no key, a key the store does not give back not used, a value that is not a key written over and said to be, the store’s failure never in the exception; the verifier the tests stand in for the website with taking only what it takes — not a compressed, hybrid or off-curve key, not a signature spelt with its spare bits; a signature with a leading zero byte found and verified; the curve’s order refused and one below it taken; the public key read-only; a store whose door refused the write as `emptyStore` makes no key over the keys it lost, the failure logged with its stage and cause and never the key
`packages/filmopen_device/test/device_registrar_test.dart`	registering the device (§6.6b) against a stand-in for the website’s route that checks as the contract does — the path’s id, the proof over the six lines, five minutes, after the last accepted: the request byte for byte (method, address, no redirect, the headers, the five fields); four fields without a name; one request for a launch and a sign-in together and for a card rebuilt while one is in flight; a sign-out and a sign-in sending again a second later with the same key; another account dropping the first’s request; nothing for an anonymous sign-in, a store in memory, no store or an unknown platform; a store that cannot be read making no key and asked again next time; no token, and a sign-out while the token is asked for; a clock six minutes fast told `stale-proof`, signing again after the site’s moment and keeping the offset; `proof-replayed` twice giving up; a refusal remembered and a server’s failure forgotten; a clock refusal without the site’s moment, and an answer that is not JSON; every refusal of the contract — nineteen codes over `400`, `401`, `403`, `405`, `409` and `413` — logged by its code, sent once and remembered, a redirect not followed and not an answer, and `500` and the two `503`s asked again; a clock refusal signed again after a moment the site took, not before it; a token that never comes given up on in time with the next account not held behind it; an anonymous sign-in dropping the request of whoever was signed in before; no network and no answer in time, by their types, tried again; the log holding the name, the slug and the refusal’s body, and no token, private key or proof; the registered device published once the site took it — its id and the build stamp sent — and its reader told, forgotten at a sign-out, and none after a refusal; the device’s name: a claim’s slug in the signed body, the answered slug kept and logged as `device.claim.start`, `proof`, `done {status, code, ms}`; the stored slug on every later registration and the same slug again accepted; `slug-taken` and `slug-immutable` answered by their code, keeping nothing and leaving the device’s own name standing; `bad-slug` refused before anything is sent and when the site says it; a claim that could not be made keeping nothing; after a forget the stored name claimed again and kept, and, taken meanwhile by another device, dropped on the refusal with a new claim registering the device; an answer without a slug clearing it; a name the preferences could not keep leaving the device registered with it and logged `device.slugNotKept`; another account’s stored name never read; nobody signed in claiming nothing; the seam’s default; the host name reduced to the grammar
`packages/filmopen_device/test/claim_device_name_dialog_test.dart`	the device-name dialog (§6.6b): the host name proposed in the grammar, claimed, closing with true and logged; each refusal shown inside the dialog and cleared by an edit, then a second name claimed; a name outside the grammar refused before the claim, Cancel answering false, both logged; a device with a name opening nothing; 320 px without overflow and a 44 px claim button
`packages/filmopen_relay/test/remote_control_card_test.dart`	Remote control’s card (§9.4, §6.6c): the switch asking for the device’s name first and a cancel leaving it off with no socket; claimed, connected, the name and the connector address shown and copied, Address copied only once the clipboard took it and The address could not be copied. when it refused, each logged, the copy’s start logged while the clipboard is still pending; and turned off again without a second question; Connecting…, Stopped (4004) and Another copy of this device took over; after a forget, the switch on with no name on a registered device saying to turn it off and on, and `4003` and a `403` upgrade saying the website no longer admits the device; unregistered but signed in, the switch turning on through the name’s claim with no off-and-on advice; a setting that could not be kept said on the card; signed out, the switch disabled with its tooltip, and one left on still turnable off; connected with a 32-character name at 1200, 700 and 375 px, light and dark, nothing overflowing
`packages/filmopen_relay/test/relay_e1_test.dart`	Remote control end to end on the loopback (§6.6c), `dart:io`’s own socket against a stand-in of the website’s relay that checks the upgrade’s three headers, takes the catalogue only when its tool names have the relay’s grammar, supersedes an older socket of the same device (`4001`) and lists the live devices: the device listed with its name, version and `builtin.echo`, and a call reaching it and answered; a wrong token refused `401` and stopped; a second copy superseding the first, which stops; no line of the log carrying the token, the device, the build, the call id or the address
`packages/filmopen_relay/test/relay_client_test.dart`	Remote control’s client (§6.6c) against a stand-in socket and upgrade, in fake time: nothing held with the switch off and nothing published; a published offer holding the socket with the bearer and the device’s two headers and an empty catalogue; the switch turned on and off with lending published, the socket staying and the catalogue following each time with `builtin.echo`, `resources/read` and `resources/list`, the capabilities and the instructions; the switch off with nothing published ending the lifetime; sign-out, another account, the background and an unregistered device each ending it, a new lifetime each time; the switch off while connecting closing the socket unused; a call through the registry as the relay; a command not exposed refused; `not-remote` with the switch off and nothing run; an expired call refused with no effect; the guard closed by the switch while a call waits, the lifetime ended and its answer dropped, or, with lending published, the socket staying and the effect refused; a frame over 1 MiB by its wrapper alone answered `too-large`, and an effectful one replayed answering from the ledger without running again; `resources/read` of a minted link with `ttlMs` and `cacheScope`, logged with the URI asked, whole, and the content’s MIME type, bytes and `ttlMs`, an unknown or `http:` URI `-32002`, another method and the switch off `-32601`; `resources/list` empty, then two links with `ttlMs: 0` and `cacheScope: private` whatever the cursor, each link logged by its URI whole, its query included, its name and MIME type, and `-32601` with the switch off; a list or read lookup that throws answered `-32603` `internal` with a `failed` line naming its stage, type and text, its text in no frame; `lending.job` waking the supplier and polling the requester’s job with the switch off, an unknown kind, a callback that throws; unknown, malformed and binary frames and `pong` ignored; a response over 1 MiB `-32603`; a frame of an ended lifetime ignored, and an answer of a socket since replaced dropped; `4001` stopping until the switch is turned on again, not by the switch turned off alone with lending published; `4002`–`4004` stopping until a new sign-in; a transient close reconnecting at 10 s in a new lifetime; a call not yet admitted when its socket drops refused `stopped` at admission with no effect, and one admitted before completing and answering a resend from the ledger; a switch whose preference could not be saved staying on and said; `503` and a network failure retrying quietly, `403` stopping; no token waiting; a ping every 25 s; registry changes coalesced to one catalogue a second; no log line carrying the token, an argument, a call id, the device or its name, an unknown frame logged with its type and text, a request’s method as it came
`packages/filmopen_device/test/device_name_test.dart`	the name a device suggests (§6.6b): a host name trimmed; control characters, the two separators and lone surrogates dropped, nothing left no name; 80 code points, an emoji counting once
`packages/filmopen_account/test/account_device_test.dart`	the account telling the device’s registration (§6.6b) through a stand-in seam and a stand-in sign-in service: a sign-in names the account, not anonymous, with a token that is the session’s; a sign-out says so and the token is then none; an anonymous sign-in says it is; a session past its hour refreshed before its token is given; a card that finds no session telling the seam nobody is signed in; a model that never connects says nothing
`packages/filmopen_account/test/account_groups_test.dart`	the community groups’ client against a stand-in of the contract’s shapes (§6.6): my groups with each membership’s identity and role, the offset sent and `hasMore` kept, no identity header; create acting as the primary read from `/v1/community/self`, the body exactly `{username}`, `201` the success and a `200` refused; a manager’s roster read as the membership’s identity and a member’s answer with none; invite `{username, role: member}` as the membership’s identity, a group’s invitations, my invitations with no identity header, accept with no body, decline and leave (`DELETE` as the identity); a refusal’s code and status, `no-token` with nothing sent, a malformed invitation `malformed`, an invitation id not a `Uuid` refused before any path; every trail’s start, steps and answer, never the bearer
`packages/filmopen_state/test/community_groups_test.dart`	the community groups’ seam (§6.6): the inert default refuses each of its nine calls `not-signed-in`, each logged `community.groups.refused` with its arguments, nothing sent
`packages/filmopen_account/test/account_projects_client_test.dart`	the account’s usernames and project records against a stand-in (§6.6): each call’s method, path and body, the bearer alone and no device, build, identity or idempotency header, `name` with no bearer — `404 name-not-found` null, `200` the public record of a group, another 404 refused, an id not a UUID, a kind neither person nor group and a missing username `malformed`, the name logged —, a name the username rule refuses (`ShortName.validateUsername`) refused `bad-request` with nothing sent; the claim’s `201 {id, username, isPrimary}` read, a key the website added read past; a create’s `201` not a replay and `200` a replay of the same id; a `dropbox` record kept and a malformed entry failing the list; a location of 1,024 bytes sent and of 1,025 refused `location-too-long` with nothing sent, on create and update; a 300-byte name cut to 198 on a character’s boundary; each refusal by its code and status (`alias-limit`, `name-unavailable`, `primary-exists`, `primary-required`, `invalid-username`, `bad-request`, `too-large`, `json-required`, `community-unavailable`, `project-exists`, `not-your-project`, `cloud-data-remains`, `401`, `community-sign-in-required`) with its `says` logged and nothing retried; `no-token` with nothing sent; a session timeout `unreachable` at `stage: token`, a transport failure and a transport timeout at `stage: send`, each with the error’s text; a page that is not JSON, a malformed record and a malformed identity `malformed` with the answer logged whole; the `send` step’s method, path and JSON body logged before the bearer is read, and the answer logged whole; every trail starting with `account.projects.request`, ending in one terminal line, under one call id, with no token; a name the username rule refuses logged with the name and the rule’s problem
`packages/filmopen_state/test/media_entry_action_reasons_test.dart`	the local reasons of a media entry’s injected action (§9.3): the six first in their order, the analyzer’s ten and then `noHandle` appended, each with a sentence of its own, none the general one and none a provider’s
`packages/filmopen_state/test/seams_test.dart`	the device registration seam a no-op until one is installed (§7.1); the exit tasks run together and all waited for, one that fails, before its first await or after, logged with its error and keeping none waiting, and one taken back not running; the seams of §7.1: the no-op host installed by default and answering “not available” to everything, `install` replacing it and leaving `windowKey` and `rootKey` two distinct keys, the field registry routing to the form that registered and forgetting one that left, the draft observers hearing each change with its key and value until removed and unable to write into the value they hear or into what another observer hears; the doors `openProject`, `setViewer`, `setLocale` and `setTheme` answering nothing and changing no setting on the no-op host; the route seam silent with no listener, naming a dialog’s push and pop by its name and a page’s push, and a failing listener never stopping a dialog from opening, logged `routeEvents.listenerFailed` with its error and stack; the no-op host holding no file dialog’s answer (`takePickedFiles` null), so a product build’s dialog opens
`packages/filmopen_state/test/media_client_test.dart`	the media seam (§6.6): `NoMediaClient` the default, refusing `media-not-configured` with no status and logging `media.upload.start` and `media.upload.refused` under one upload id, the content type on the start line; an install replacing it
`packages/filmopen_state/test/field_registry_test.dart`	several setters on one stem (§7.1): each answering its own keys and refusing the other’s, each leaving alone and the stem going with the last, `unregister` with no setter removing them all, the same setter held once, and a setter that leaves while another types not asked after it left
`packages/filmopen_state/test/account_projects_test.dart`	the account’s projects seam (§6.6): `NoAccountProjects` the default, refusing each of the six calls `account-projects-unavailable` with no status and logging `account.projects.request` and `account.projects.refused` under one call id, no name in either; an install replacing it
`packages/filmopen_state/test/project_records_test.dart`	the record id kept per folder (§6.6): `keepRecord` answering `saved` only once a held write is released, the start line logged while it is held and exactly one outcome after; `failed` for a throwing write (`write-failed`, its type and message) and for no store (`no-preferences`); `recordOf` read back from a fresh container on the saved preferences; the id kept through the recent list’s eviction by 13 folders, the menu’s removal and a theme change; an entry not of the shape dropped and counted; the path and the id on the start line, a failure’s message on its outcome
`packages/filmopen_plugins/test/plugin_manifest_test.dart`	the manifest (§6.11): the sample library’s 1.10 manifest and the template read with no problem; an unknown field, entity hook, platform hook, setting type and action reported with the rest kept; a mistyped field inside a setting, a key slot and an action reported with the entry kept, a field the setting’s type does not use (`values` on a text box) reported, and bounds no number meets left out; a wrong type in every field reported, never thrown; an issue’s values part of its equality; `api` 2 refused naming both versions; another type, a bad tag, the tag `app` and a missing or mistyped header field refused; the code file named after the stem, and one elsewhere refused; key slots named `<tag>:<slot>` with their store and preference names, one naming a platform without a file reported and kept, a bad slot left out; `uses` with the app’s key, malformed ids reported and repeats dropped; `KeyId` reading only two segments; a default of the wrong type dropped, an enum without values and a model without a category left out; scope on settings and none on entity settings; entity settings for a type not applied; network hosts
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the documentation route), `packages/filmopen_plugin_host/test/host_runtime_test.dart` (documentation summary), `packages/filmopen_plugins_ui/test/plugins_tab_test.dart` (Docs)	valid and omitted guide routes; external, encoded and escaping routes reported and omitted; the summary preserving only the validated route; Docs opening the build’s documentation origin, absent without metadata; at 700 px, light and dark; unavailable and throwing browser openers reported without an exception
`packages/filmopen_plugins/test/model_picker_prompt_test.dart`	the app-only `model-picker` and the built `prompt` interfaces; a writer declaring its models and only the known targets; a prompt, `no-prompt` and a malformed absence distinct
`scripts/tests/test_check_catalogue.py`	a recording keep’s clone price accepted beside request pricing with a reference declaration, an unknown unit refused; the catalogue checker on an access row’s `render` and a price’s `match`: wrong types and a `match` naming a setting the row does not map reported; an access row’s `strings` list accepts mapped duration, refuses a scalar, a non-string member and an unmapped name; an access row’s `placeholders` required where its `params` map `reference_images` and refused where they do not, holding `{n}` once with words beside it (`image`, `{n} and {n}`, `{n}` and a number refused), and `max_images_per_request` a whole number from 1 (0, 2.5 and `true` refused)
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the server provider’s group)	what a server provider is — `implements: server-provider`, a declaration the reader refused included, never the lab’s `x.serverProvider` — and the calls that start a server, `deploy`, `wake`, `deployServer` and `wakeServer`, and no other; another extension making none
`packages/filmopen_plugins/test/plugin_manifest_test.dart` (the `x.dependencies` group), `packages/filmopen_plugin_host/test/plugin_views_test.dart`	`x.dependencies`, the one member of `x` the app reads (§9.4): absent, an empty `x` or an empty list none and no issue; valid tags kept in order, a repeat once; a non-list, an explicit `null` included, `wrongType` on `x.dependencies` and none; a non-string, an invalid tag, the plug-in’s own tag or the reserved `app` `badEntry` on `x.dependencies` and the whole list none; the host’s summaries carrying the tags as written, a missing one included, and none for a plug-in that names none; a generic render plug-in serving only rows marked render, a plug-in naming the model still serving it, and generic text choices unchanged
`packages/filmopen_plugins/test/plugin_strings_test.dart`	a plug-in’s strings (§6.11): metadata skipped, a key with a colon and a value that is not text refused, `@@locale` checked against the file’s name, a file that is not an object or repeats a key; `pt_BR` reaching `pt-BR`; the template’s two languages holding the same keys; the fall-back from locale to language to English to the key, reported once; the plug-in’s own namespace, `app:`, and another plug-in’s; an app string never picked up by a missing key; placeholders; a manifest’s name as a key or as written
`packages/filmopen_plugins/test/plugin_package_test.dart`	a plug-in folder and its zip (§6.11): the template in a library read with both locales; a stock manifest and a fork in one folder; a folder without a manifest, a manifest of another tag or stem, and one that does not parse, reported; a platform file for a new id making a slot’s platform known and one for a catalogue id refused; a file that is not text reported by its path with the rest read, a manifest’s among them; a missing code file and a folder without English reported; locale files under the folder a manifest names; the template zipped and read back, nested or flat; an entry escaping the folder — `..`, absolute, a backslash, a drive letter, `.`, an empty segment — or a link refusing the whole archive; macOS’s `__MACOSX/` and `.DS_Store` left out; an entry inflating past the limit refused, honest or lying about its size; a damaged entry refused as unreadable; a folder or manifests naming another tag, or no manifest; bytes that are not a zip
`packages/filmopen_js/test/engine_test.dart`	the engine (§6.11), each call in its own isolate: a function called with JSON and its value back; a promise awaited and two Dart doors awaited from JavaScript; a door’s refusal reaching the script with its code and reason, and another error, or an answer that cannot be encoded, as `failed` with its stage and cause; `onDoorFailed` told the door, the stage, the error and the arguments at either stage, the script catching it unchanged; a call whose isolate cannot start as `engine` with its stage and cause; one whose isolate dies on an uncaught error as `failed`, its message `isolate: <error>; function <name>`; an action called with `ctx` alone, with its settings, tag and strings; `ctx.now`, `ctx.job` frozen all the way down and `ctx.features` from the call’s data, none where it gives none, and `ctx.stage` asking its door; `ctx.project.scopes`, `export` and `import` asking theirs with their arguments as the prelude builds them (`arg` null and `options` empty where left out) and a refusal reaching the script; `eval`, `Function`, `Math.random`, `Date`, the host’s own functions, `require` and `fetch` absent and every function’s `constructor` refused; an infinite loop inside `try` ending at the time limit while this isolate’s timer kept ticking, a loop at the top of the file too, waits on a door and on `sleep` not counted, a growing array ending at the memory limit though caught, deep recursion at the stack limit with the default 1 MB, a result over its limit, the wall clock, and a sleep past it ended by it rather than answered as slept even while the caller is kept busy; a script’s thrown message, a syntax error, a missing function, a value JSON cannot hold, a promise nothing settles; a looping, a waiting and a sleeping script cancelled at once; flooding the doors ending at the memory limit without the process growing by gigabytes, and so does a slow door holding what was drained to it; a prototype’s `toJSON` and a thrown `cancelled`, `hung`, `limit`, `engine` or `stalled` code faking nothing, a door’s `refused` kept; a stack trace’s call sites not handing the script the host; replacing `JSON`, `Reflect.apply` changing neither the doors reached nor the outcome; a cancel before the isolate started; a last `log` and a missing string still reaching their doors, and requests queued before a time limit other than a `log` not started; a cut message, a lone surrogate and a function as a request’s arguments read back; the result limit in bytes; a throwing microtask not failing the call; and a thousand calls growing the process by less than 100 MB; callable frozen `http` with awaited `read`, and `partial` awaiting its door’s refusal A thrown `cutOff` is kept, the reserved codes still `failed`.
`packages/filmopen_plugins/test/stock_install_test.dart`	the stock install (§6.11): an empty library getting every file and a record, a second start changing nothing; a file at the top of the bundle — the interface definition — belonging to no plug-in and installed nowhere; an update replacing its own file while a person’s fork, their locale file and their own plug-in stay; a file of the same name the app never wrote left alone; a file the bundle dropped removed unless the person changed it; a deleted stock folder back at the next start, and gone at every start while the person keeps that plug-in disabled; pictures installed, updated, removed and left by their bytes; a text with a BOM installed byte-exact and its hash equal to the disk; a binary updated to text and back; a failed byte write with its stage and type; an unreadable record a `record` failure, an absent one the first run; an old text-hash record stays valid; a plug-in one of whose bundled files does not read left as the library holds it, its record kept, while another installs; the decisions with their reasons
`packages/filmopen_plugin_host/test/machine_setting_publication_test.dart`	accepted machine settings through controlled real settings-file lookups: save completed between first read and held second read reaches both ready snapshot and ordinary action; two keys and another tag preserve unrelated disk and nested fields; repeated edits and null removal win; a write pending at reload start survives its old tag read; later generation wins when the old read completes last; loading snapshots stay null and ready snapshots deep-copy; failed write followed by a quiet reload returns disk; successive publications retain the edit through the first post-completion-started publication, then retire it so a later reload follows external disk; failure of the latest edit preserves an earlier still-remembered edit; inert temporary plug-ins send no provider requests
`packages/filmopen_plugin_host/test/js_failure_log_test.dart`	a door’s answer that cannot be encoded, uncaught by the script, ending the call `failed` and the host’s `plugins.failed` line naming the stage and the cause, with its `plugins.door.failed` line; a door failure the script catches, at `encode` and at `call`, each one `plugins.door.failed` warning with the plug-in, the function, the door, the stage, the error’s type and message and the arguments, the call ending as the script chose (§6.11)
`packages/filmopen_plugin_host/test/plugin_log_test.dart`	a plug-in’s log line (§6.11): the level; a line written whole — nested data, a list, a 5 KB line, a sentence as `line` with its `text`; a level that is none of the four counted, and not written as the plug-in’s line; a writer’s `ai.complete` logged with its messages, its answer and usage, a failure’s code, reason and message, a refusal’s code and reason, and a thrown exception’s stage, type and message, the exception going on unchanged
`packages/filmopen_plugin_host/test/http_door_test.dart`	the HTTP door’s fork to FilmOpen credit (§6.6, §6.11) against stand-ins: the person’s own key first, the portal never asked, the request logged as the plug-in built it, its answer logged, the stored key in no line; with no key on credit fal’s queue URL sent to `/v1/portal/pass/fal/…` with the body byte for byte, `accept` and `content-type` alone of the plug-in’s headers, the bearer, the portal credential and `X-FilmOpen-Operation`, no `Authorization: Key`, the chain opened with no last four, the answer as the provider’s; status, result and cancel under the chain’s operation, the state header and the echo logged as they came; OpenAI’s `path` under its base and ElevenLabs’ query kept, the credit line’s host and complete pass target, query included, with its path after the base, the start line’s URL as the plug-in built it, query included; listed `api.fal.ai` and `fal.run` hosts on credit, an unlisted host refused, and no credit offered or a key check refused `no-key`; a body of 16 MiB + 1 refused `body-too-large` with nothing written or sent; a redirect not followed; a `401` marked `X-FilmOpen-Refusal: bad-portal-token` letting the credential go once, counted unsent, never resent, and a `401` without the header — its body saying `bad-portal-token` — the provider’s and the plug-in’s, logged `stage: provider`; a marked `409 insufficient-funds` reaching the plug-in as its status, logged `stage: portal` with its code; every code the website’s pass-through marks, and a value it never sends, logged as it came; no credential refused `not-funded`; a timeout failed by its type and counted lost, a malformed answer handed on as text; a provider’s error, even one spelled as a portal code, classified by its status alone and handed to the plug-in untouched; a chain already on credit kept there with a key entered; every `plugin.http.credit` line, the token and the bearer in none; the request’s trail — `plugins.http.start` with the URL, the plug-in’s headers and the body as the plug-in built them, `plugins.http.done` with the status, the bytes, the milliseconds and the answer — and a refused connection to a closed loopback port refused `connection`, its `plugins.http.failed` line saying `send`, the error’s type and message, the operating system’s code and the hop’s URL, a server’s route whole, its query included, in every line; a server’s refusal logging its address whole, the route’s query included, as a plug-in’s `url` is; on the credit route `plugins.http.start` written before the pass-through’s target and headers, with no bearer or portal token, and a refused credit reply’s portal credentials in no line; every non-2xx reply’s body in `plugins.http.refused`, and a provider’s non-2xx answer the plug-in is handed also in `plugins.http.done` — a portal’s refusal of its own credential (a marked 401) refused with no `done` line — an echoed stored key, and on credit the bearer and portal token, handed on and logged as they came, the hop’s URL and timing, one warning, no line on 2xx, a 5,000-character text reply logged whole; every header of an answer in `plugins.http.response` and `plugins.http.done`, `www-authenticate` and `set-cookie` withheld from the plug-in alone, and `onAnswered` hearing the plug-in’s copy once; a redirect’s head logged with its headers before it is judged; Omitting the optional diagnostic frame preserves the exact event maps and the supplied operation reused across requests.; a model completion on credit answered after the default completes, its head waiting as the provider takes, and any other request whose server never answers ending at the default; a plug-in’s `timeoutMs` honoured as asked past 300 s; a body whose bytes stop still timing out; Stop ending a head that never came, each wait logged with its source, an operation’s bound named where it is the shorter; with `host_runtime_test.dart`, Stop closing an action’s request that no bound ends, and with `plugin_calls_test.dart` a render’s left to its answer; a streamed answer on credit telling the ledger its head and each read’s events
`packages/filmopen_plugin_host/test/usage_chain_test.dart`	a usage chain on FilmOpen credit (§6.6, §6.7): recorded on `filmopen.ai` with no key, its operation a v4 UUID minted once, in `saved` and read back by `resume`, an operation that is not one not taken up; a chain on a key holding none, on `direct`; the receipt read by the operation’s id once, once more where eligible, a failed read logged `usage.receiptUnread` and a settled one never read again, each read logged `usage.receipt` with the operation and the round; a chain’s operation ended once by its id, the End begun first shared by a second ask, logged `usage.end` with the reason and the milliseconds, a failed End `usage.endFailed` with its type and message; a request on credit after the End began held until it completes, then refused `OperationEnded` and never counted as sent, a request on a key not held; a Stop while the first request’s record is written refusing that request unsent, its never-submitted operation not ended; a render’s stack overriding params.variant for its started row, model and estimate and its final unit charge, an unmatched stack taking the first row, no stack keeping params.variant, and usage.unitsPriced carrying only the safe selection and pricing decision; an ordinary call whose final write fails keeping its answer, `usage.notWritten` carrying the attempted record, its chain, its operation and the milliseconds; an own provider total, positive or zero, winning beside a lost request, an own charged unknown answer ending a failed call beside a lost request, and a nested total beside a lost request staying unknown on a succeeded call; and a chain on a key ending nothing (its cost from the receipt is the end-to-end render’s in `host_runtime_test.dart`); Frame-scoped operations are distinct, reused within one scope and ended together with one started chain; omitted scope retains the restored job operation, and failed appends list the chain’s operations; a closing end on credit telling the funding `balanceMoved('call-closed')` once though it holds two operations, a nonclosing end and a ledger on a key never.; a text call on credit: two completions on one key each charged by its own operation’s settled receipt, read once after its answer and once more at the turn’s end, the record `charged` with both operations and their request ids, `usage.charged` with the difference and `usage.ended` with the operation ids; a receipt still unsettled `pending` with its operation; a call’s own answer charged by its frame; a plug-in’s own `charged` refused; an own-key call’s record and `usage.ended` holding the provider’s request id; a lost completion on credit ended by its receipt, `charged` or `pending`, with its operation; the receipt’s id on the record, `usage.receipt` and `usage.charged`
`packages/filmopen_plugin_host/test/free_usage_test.dart`	free functions (§6.7), against one plug-in that renders, provides servers and checks keys: `status`, `verifyKey`, the server functions and `onEnable` free and a render’s functions not, by the function and never the plug-in, and no function of a free interface also another interface’s in the contract; on the person’s own key `status` and `serverOffers` send their requests and write no usage record, each logging `usage.key.unrecorded` with its function, key, platform, route `own`, decision, reason `freeFunction:<function>`, last four and milliseconds, its frame matching its `plugins.http.start`, and no credential in any line; the same plug-in’s render recorded `direct`; a key check’s candidate unrecorded as before and its other own key unrecorded and logged; on FilmOpen credit `status` and `serverOffers` recorded on `filmopen.ai`, and a key check’s other key recorded while its candidate never goes on credit; `status` on a plug-in with no `key-check` unrecorded on its own key; on credit every free function of the contract — `status`, `verifyKey`, the seven server functions, `onEnable` and `onDisable` through the switch — opening its operation and recorded on `filmopen.ai`; a server call cut at its bound while its own key was read sending nothing once the read returns, no record, `usage.key.refused` with reason `callEnded`
`packages/filmopen_plugin_host/test/host_runtime_test.dart`	the host against stand-ins (§6.11): machine settings that cannot be read taken as none at reload, with `plugins.storageUnreadable` naming the plug-in, the file and the error; a staged binary that does not decode refused at its own read, its plug-in installed with none of its files and so not listed, with the rest of the trail going on, and a bundle that does not decode ending the trail at stage `bundle` with its message and `plugins.loadFailed` with it; `ctx.http` sending the platform file’s header filled from the store, the platform’s echo of the key handed back as it came and its cookie withheld; a host off the platform’s, a redirect elsewhere, `http`, a key neither owned nor granted, a key with no platform file and an unlisted free host refused with their reasons; a granted key sent and, its grant taken back, refused; a key echoed JSON-escaped handed on as it came, and in a text answer JSON-escaped, percent-encoded or as character references; six asks at once reaching the provider four at a time, with ordered answers and one usage chain; a nested call refused another; a provider of `complete` refused another provider’s key without `capabilities.ai`; a caller cancelled or answering without waiting ending its nested call, with no request after it and every usage chain ended; a hung plug-in off until the next start; `ctx.ai.complete` from the text provider itself running, recorded as the action the person ran with the entry and model id, and refused to a plug-in without `capabilities.ai`; a key sent from an action recorded; a disabled owner’s key refused and a key checked by nobody but its owner; a transform cancelled midway leaving no version and no batch; a transform refused on a type it does not apply to and its batch without the machine setting; a film’s folder under a stock tag never registered and therefore unable to take the installed plug-in’s place; `verifyKey` reaching the candidate for one call with nothing stored; `ctx.project` answering the viewer’s versions with their `plugins` object; the template’s `transform` written as `<viewer>.template`’s v1 with its batch and the person’s version untouched; a `render` against a stand-in fal’s queue downloaded without credentials and staged as the run of `<viewer>.<tag>`‘s plug-in, no batch written by the host, and its usage chain `started` then `succeeded` with the stem, the entry, the platform, the key’s last four and the reported cost; a loop at the time limit and a throw with its message, the next call running; a third party’s plug-in off until allowed and off again when its code changes; a stock plug-in trusted and granted with the index read again after the install; a reading asked while the install writes a slow library waiting for it and publishing the stock plug-in, trusted; a fork beside it not running, the folder no longer the bundle’s alone asking; a grant, and its withdrawal, shown on the plug-in at once, before every plug-in is read again; the key cards’ owners; and a key check that may only read with the key it checks, a `POST` refused `keyCheck` with nothing sent; `verifyKey`’s answer held, `{ accepted: "yes" }` being `badResult` and no refused key; an answer’s header names handed on as they came, an echoed key included; and a `transform` answering an entity without its name `badResult` at `[0].name`, nothing written; and a call that waited for one of the five slots, its plug-in turned off meanwhile, `disabled` and never run; machine-settings snapshots are unavailable before or during the current load, deep-copied when ready, reflect setting changes, and preserve the latest generation when an older load finishes; listeners see readiness when notified; a plug-in’s key on a platform of its own file bringing that file to its section of Provider keys; `ctx.keys()` reading a key’s record through the one door, a build’s reader answering alone; a render on FilmOpen credit through a stand-in for the funding seam and fal’s queue behind the website’s pass-through: submit, status and result to `/v1/portal/pass/fal/…` under one operation with the portal’s headers, kept in the job’s receipt and read back through it, the receipt read through `receipt` with the kind `http`, the records on the route `filmopen.ai` with no key and the receipt’s cost, reported; a receipt read at the job’s end once and once more after the bound, and none a cost unknown; a pending answer and a succeeded job ending no operation; a cancel ending the operation once, before the receipt read, its record `canceled`, whatever the plug-in answers — `cancelled`, `finished` or `unknown` with a settled receipt confirmed `cancelled`, without one unconfirmed; a Stop through the real manager during a collect on credit ending the operation while the status is still asked, the result request held until the End completes and then refused with nothing sent, the job `cancelled` with no take, no cancel and one End; a managed job submitting on credit with no key record; an own key entered while the render waits sent nowhere; `ctx.keys()` saying a key not stored usable on credit, `mode: 'funded'`; the shared offers one JSON list beside the enabled list, read back as written, the listeners told once per write, an entry not of the shape and a string that is not JSON left out at the read, a malformed entry refused at the write with nothing written; the names resolved for the free list one JSON object read back as written, logged as they are, five bad strings and a list read as nothing; a stock plug-in with a picture installed byte-identical and trusted, with its log lines; a personal file and a failed byte write logged by path, stage and type; the unchanged count, a modified file with its path and a disabled folder’s decision; a bundle that cannot be read before the start logged `plugins.stock.failed {stage: bundle}` with its time; the encoded-key text refusal’s `plugins.http.refused` line holding the body whole, as it came; the recycle bin at the doors (§6.11): `entities` and `script` leaving a deleted entity out, `resolve` refusing it `notFound`/`deleted`, each door’s start with what it was asked and its line with its outcome, the stems it answered and left out (by tag for `resolve`) and `ms`; the settings read logs each plug-in’s values and whether they were saved, absent or the default; a transform’s answer the contract refuses logged whole on `plugins.badResult` with its plug-in, path, problem and `ms`, nothing written; every ending between one `plugins.transform.start` and one `plugins.transform.end`, a refusal before any code included; Sequential and reversed concurrent funded completions through actions hold distinct portal credentials and correlate whole HTTP prompts to child-frame operations and caller ids; a missing-spend 500 or 2xx beside a known nested part writes unknown with subtotal and counts logged; fresh runtimes collect and cancel saved renders under their original single operation, one started chain per job and one cancel End before its receipt.
`packages/filmopen_plugin_host/test/plugin_choice_test.dart`	`choosePlugin` (§6.11), on render plug-ins: the only candidate; a plug-in naming the model over a generic one, whatever the enable order; the later enabled first among equals, a bare tag no enable order; never-toggled candidates by the lower tag; a wrong model, a disabled and an unrunnable plug-in never chosen; the model picker by enable order alone; the prompt writers for a kind (`promptWriterOrder`): every plug-in’s writers of the target, `fo-prompts`‘s first and said `stock`, then by tag whatever the enable order (`lowerTag`), `only`, `noWriter` for none; one plug-in’s writers in its manifest’s order, its other targets’ left out; a writer naming models offered with no model asked and refused for another model; a disabled or unrunnable `fo-prompts` not offered
`packages/filmopen_plugin_host/test/render_seams_test.dart`	the host’s `defaultModels` and `buildPrompt`: the picker needing no open film and given the kinds and stages, logged `render.picker.start`, `plugins.choice`, `render.picker.done` with the picker’s answer whole beside its count, and an answer off the contract `badResult`; no picker and no writer distinct refusals, an empty runtime unavailable; the writer given the unsaved exchange source and the entry, and `no-prompt`, a malformed answer and a throw distinct; the writer receiving projected args.source with an empty selection, a missing catalogue entry refused badArgs/entry, and noWriter logged as outcome none while retaining its code and reason
`packages/filmopen_plugin_host/test/prompt_writers_test.dart`	the prompt writers as the host runs them (revisions 12, 13 and 17, §6.11), with stand-in writers and no network: each of the eleven targets asked with no model, an unknown one never offered and refused `badArgs`/`target` at the developer page’s door; a voice and a treatment asked with no model and no entry, nothing sent as null, a model sent with its entry and a model the catalogue lacks `badArgs`/`entry`; a frame’s block found by its id and passed, and an id no block has, one two blocks have, none, a cue’s ids and a source that is no scene each `badArgs`/`block`, a block only for a frame; the offered media tokens selected by target: a sheet’s references else inspirations, a block context’s first sheet else reference, including an older character’s first sheet from actual page candidates, one picture per context character, outfit, location and prop in context order (the four sheets `first-sheet`, else the references `first-reference`), absent when none or empty, refused `badArgs`/`tokens` for a voice, a treatment and a malformed token, named in `render.prompt.start`; a writer’s words naming the `@reference-1` it was handed read back as written; a treatment’s preset the project’s, a folder’s own, its ancestor’s, the viewer’s picked fork’s, the project’s for an entity outside the script, absent where none is chosen and for any other target; `promptWriters`: only writers of the kind, `fo-prompts`’s first then by tag, named `<plug-in> / <label>` where two plug-ins answer and by the label alone (read from the plug-in’s strings) where one does, a model-restricted writer offered with no model and left out for another, logged `prompt.writers` with each pair and the prefix decision, empty without a host; the writer handed its declaration, logged whole in `render.prompt.args`; a named pair asked, a plug-in alone its first writer, an id it does not offer `notFound`; a declaration with `targets` alone and a writer with no asset refused and logged at reload (`plugins.manifest.refused`, the plug-in, stem, file, field, code and why, `leftOut` false); a plug-in whose only manifest is not JSON left out and logged so (`leftOut` true); `buildPrompt` without a name the list’s first, a named writer run and logged `named`, one not declaring the kind, unknown or disabled `notFound`; the writer’s `negative` passed through and in `render.prompt.done` with the words; the source and the arguments handed, whole, in `render.prompt.args`, the source’s stem and `$id` in `render.prompt.start`; every target has context; a character’s default outfit and an outfit’s wearer, unassigned outfit empty with the exact diagnostic; block treatment composed through project, folder and named Style with sources logged, and context/token rules logged for every target; a scene listed twice skips folder treatment and logs treatmentAmbiguous with project leaves/sources, ordinary composition logs false; the developer page’s `buildPrompt` prepared as Generate prepares it: a character reference with a model handed the writer’s declaration, the model’s entry and the card’s media, the LLM decided from the writer’s own `llms`, `render.prompt.context` and a `context` line written, the first writer where none is named and `notFound` for an id it lacks; a treatment chosen from a folder with the folder’s preset; an unknown target `refused/noWriter`, as Generate says it; the page’s prefilled `buildPrompt` example — the plug-in’s first writer by its id — running through to it; a writer object from the box, a declaration or `{"llms": 17}`, refused `badArgs/writer`, logged in `plugins.promptPrepared` (`why: notAnId`) and `plugins.devCalled`; the box’s JSON tokens handed as the writer’s list, malformed ones refused `badArgs/tokens`
`packages/filmopen_plugin_host/test/wan2gp_text_route_test.dart`	WanGP’s local LLM as a text route through the real host and the real assistant policy, with no socket and no WanGP: a keyless provider on `wan2gp` whose row names the FilmOpen helper’s endpoint offered and admitted `local`, its one POST carrying the row’s path, the engine as `model` and the catalogue’s `max_tokens` at the top with no credential, its tokens in Usage on the `local` route with no cost; the same request as a Gradio call (`{data: [...]}`) refused `max_tokens` before anything is sent; the staged `fo-wan2gp` offering both WanGP entries, admitted `local` and sending the bound request; and, with a fake WanGP program in a Pinokio-shaped folder, a turn while nothing answers failing in the plug-in’s sentence (press Start WanGP), the Start WanGP action starting the chosen Python with `wgp.py --multiple-images --advanced --server-port 7860` in the folder above its venv, the next turn answered, and quitting stopping the program — on POSIX a shell script probed with `kill`, on Windows a batch file whose wrapper and waiting child are both gone by `tasklist`
`packages/filmopen_plugin_host/test/clip_args_test.dart`	a clip’s arguments as the host makes them (§6.11), with a stand-in writer and no network: the block, the covered blocks in the order named, an id naming no block or two refused `badArgs`/`covered`, no `blocks` where none is covered; the context — the speaker at the cast entry’s epoch, the scene’s location at its `location_epoch`, a mentioned prop and a mentioned character in no cast, each once, a covered block’s location mentioned twice sent once — with a character at an epoch it has no file at, an ambiguous one and an unknown one left out; the language from the block, else the project, an empty `lang` as none, absent where neither; first-frame and last-frame receive their own block’s context and language, not covered blocks, with cast-selected and default outfits; `render.prompt.context` on the call’s `ref` with `references` alone carrying each request/reason and resolved stem/fallback or problem, without duplicate resolved/unresolved lists, the covered blocks, the language and its origin, the entities’ documents in `render.prompt.args`; from the developer page’s JSON box (`jsonDecode`), a clip’s covered ids handed exactly as Generate’s — the same blocks in order and the same context — an empty list none, and a repeated id, a non-string, an unknown id or a non-list refused `badArgs/covered`
`packages/filmopen_plugin_host/test/reference_freeze_test.dart`	a render’s first reference picture frozen before its source is replaced, the frozen bytes uploaded, logged `render.freeze {input, bytes}` with no path; a frozen copy changed before the upload failing `mediaChanged` with nothing uploaded; a reference missing from the film’s media refused `mediaMissing` before any JavaScript or HTTP, logged `render.freeze.refused` with its reason
`packages/filmopen_plugin_host/test/marked_rows_test.dart`	`candidates`: a render plug-in naming no models offered an entry only on a `render: true` row of its platform, and one that needs the film’s media only with `capabilities.upload`; a plug-in naming the model still admitted; the eleven stock fal entries, ComfyUI’s Z-Image, Wan 2.2 TI2V 5B and FLUX.2 [klein] 4B, Wan2GP’s Z-Image and Wan 2.2, and OpenAI’s GPT Image rows marked and decoded without issues; Wan’s two rows, ComfyUI’s and Wan2GP’s, marked with its first frame required, and either local renderer without `capabilities.upload` refused it `needsUpload`; Wan2GP admitting exactly its two entries, ready without a key, not billed, with no row price or quote, and its runtime listed; each platform’s marked admission logged; OpenAI’s per-image estimates equal fal’s by variant, its token rates unchanged, and high and auto quotes log match and unmatched; only the reviewed H3 Max, Seedance (its first and last frames too, and its text and reference variants each by its own fal row), LTX-2.5 audio-to-video, Kling Avatar 2.0 and Eleven TTS fal rows marked, other variants and the other flf2v entries unmarked, and each marked Seedance row retaining strings for duration; fal’s MiniMax voice design and speech offered to a plug-in that implements `voice` on fal and never to a generic renderer (`unmarked`), the design quoted USD 3 a request and speech USD 0.10 per 1,000 characters, and Eleven v4 on ElevenLabs alone, as v3 priced; Eleven v4 routed to the plug-in that voices ElevenLabs and MiniMax’s speech to the one that voices fal, their `inputs` empty and a first frame refused by name; a voice plug-in no candidate on a row marked `render` on its platform, logged `voiceOnRenderRow`, a plug-in that renders that row keeping it, and rows with no mark still its own
`packages/filmopen_plugin_host/test/google_routes_test.dart`	`fo-google` as the host offers it, from the staged stock and the bundled catalogue: both text entries choosing it on `google`, the render candidates of both image entries including it, its manifest asking the upload grant an embed needs, both text rows naming the compatible endpoint and model the assistant policy binds, and one assistant turn on Flash through the real policy against a stand-in, its top-level model and output bound sent, the key added by the host and never logged, its priced bill in Usage with a receipt the stream held
`packages/filmopen_plugin_host/test/match_price_test.dart`	the options’ quote logged `render.quote` as matched, unmatched or partial — an edit’s unmatched setting staying unmatched before its reference-input charge leaves a matched total partial — and an edit’s usage keeping its floor; a route’s stack pricing its marked row, render.quote.start then render.quote with its safe stack decision; bundled i2v H3 Max options at 768P and five seconds quote $0.40 and log stack matched, basis when
`packages/filmopen_state/test/speech_providers_test.dart`	the two speech providers (§6.7): `openai` → `fo-openai:openai` and `xai` → `fo-xai:xai`, each key under `filmopen/<tag>/<slot>` from the binding’s fixed tag and slot, with or without the plug-in; ready only installed, allowed, on, runnable and declaring its own slot on its platform — missing, off, not allowed, not runnable, no key, another slot, another platform and another plug-in declaring the same slot each refused; `openPlugin` showing Plugins and asking for the page once, a second door asking again
`packages/filmopen_l10n/test/app_strings_by_key_test.dart`	the generated `appStringsByKey` equal to the English file as it is, the language shown and maintained (`scripts/gen_app_strings.py`); the frozen Spanish keysStoreUnavailable value agrees in its source, generated getter and key lookup, and appended Spanish job/key messages agree through both generated lookup doors
`packages/filmopen_plugins/test/plugin_archive_memory_test.dart`	alone in its file, so that the process’s high-water mark is its own: a gigabyte of zeros behind a zip whose directory claims one byte refused as too large with the peak memory growing by less than 400 MB (§6.11)
`packages/filmopen_plugins/test/plugin_text_test.dart`	`isPluginText` against `scripts/tests/plugin_text/`, the script’s own fixtures: valid UTF-8 is text (a NUL, a BOM, an empty file, a multi-byte character), anything else binary.
`packages/filmopen_l10n/test/arb_keys_test.dart`	every key of `app_en.arb` a message name with its metadata, and no metadata without its message; no key or metadata in another language that English lacks, while a frozen language may lack a message English has; none of a pinned list of messages found unread by any Dart file or stock plug-in left in any language (§10); no English description citing a milestone, a plan, or a decision or an open item by its letter and number
`packages/filmopen_l10n/test/picker_words_test.dart`	the style picker’s nine English words, the held picker’s tooltip among them, and the same English in the frozen Spanish, which lacks them (§10)
`packages/filmopen_automation/test/agent_mouse_test.dart`	the agent’s mouse (§4.3) as a widget hears it: a click a mouse’s packets with the primary button, shift held at the down and let go after; one clock across gestures, never zero, and a fresh pointer per gesture; a drag’s moves carrying their real deltas; a failure after the down cancelling the pointer and letting go of every key it pressed, logged `agent.keys.up {reason: failed}` and `agent.pointer.cancelled`; a key another input holds refused as `keyHeld` before anything is pressed, and left held
`packages/filmopen_automation/test/protocol_test.dart`	the agent data channel (§4.3) on an injected host: `ping` — literal, empty, missing or JSON — whatever the host; every op reaching the host with its arguments and answering what the host answers, one case per op; every op that reaches the queue logging `agent.started` with what was asked and `agent.done` with its time; a `set_field` into the developer page’s arguments box logged in `agent.started` and `agent.refused` with its stem, key and value, whole, as every other field’s value is; a host that cannot act, the product’s no-op host among them, answering `not_available` to every op and hearing nothing, and a host without `Recording` answering `not_available` to `record_start`, `record_stop` and `record_state` alone; a message that is not an op refused as `bad_args` whatever the host, and every malformed argument refused as `bad_args` naming the part before the host hears of it, a language the app lacks and an empty label among them; `set_locale es`, a language the app keeps but does not show while it is in development, refused as `languageUnavailable`, the host hearing nothing — on a host that can act, since one that cannot answers `not_available` first; an unknown op refused, and named only when it is a name; `not_found` naming the identifier, the field or the kind of target, never the typed text or the label; a host without the semantics taps answering `not_available` to a tap by label or position, and one that cannot exit to `quit`; `tap_at` marked a diagnostic; the log travelling whole — an error’s message and stack, the account’s events’ data — and a line that is not an event staying behind; a host’s refusal travelling as its code, and an unexpected failure as its type, logged; ops one at a time in arrival order, with neither a ping nor an unknown op waiting; an op past its time answered `timeout` / `running` and still ending before the next starts, one whose time ran out in the queue answered `queued` and never run, and a late success, refusal and failure logged; a selection of every kind in the plan’s shape and back; `find` over a semantics tree; `set_tab` naming Settings’ `general` and `keys`; the `usage` tab; a selection of the kind `script` and of the type `fo` surviving the trip, and the types `se`, `ep` and `sq` refused as bad arguments; `set_tab` passing `servers`, `share`, `remote` and `workflow` to the host; a selection of the kind `pending` for `cp`, `as` and `rd` surviving the trip, without a type or with another refused on `type`; every refusal logged as `agent.refused {op, args, code, detail, ms}` before it is answered, an unexpected failure’s included, and before the queue — a message that is not an op (`args` the message, no `op`) and an op the app does not know; `click` with its keys, and an unknown, repeated or non-text key refused on `keys`, a host without `MouseInput` answering `not_available`; `drag` with its place, `centre` by default, a place of another name refused on `place`; `pick_files` with paths or none, a list that is not one of texts refused on `paths`, a host without `FileAnswers` answering `not_available`; `set_tab now` and `set_tab files`, Activity’s two
`packages/filmopen_automation/test/clipboard_install_test.dart`	the agent build’s install of the clipboard asks (§4.2) on a test messenger over a stand-in delegate: two concurrent asks one ask of the delegate, the reply’s bytes to both, `Clipboard.getData` reaching the delegate in order, `via: agent` on the start line and `callers: 2` on the done
`packages/filmopen_state/test/semantics_walk_test.dart`	the walk over the semantics tree (§4.3, §7.1, §6.8) — a scene’s block boxes (`script:`) among the identifiers whose values travel, as a form field’s do — on a pumped tree:
`packages/filmopen_state/test/settle_frames_test.dart`	`settleFrames` on one clock: nothing animating ends `idle`; a spinner with the owner ends `stable` with its quiet age; a semantics value changing every frame ends at the cap; without an owner a spinner holds to the cap, never `stable`; the listener gone after each end

a node by its identifier, and by its label (a tab by its label’s first line);
the tabs of a tab bar;
a tap going through a wrapper to its button, and from an identifier inside a tappable item to the item, but never through a disabled button, nor up past a disabled control, a button without a tap or a route;
a pull-down (DropdownMenu), whose field offers expand rather than tap, opened through its identifier and an item chosen by its label, and a disabled one refused although it still wires expand (activationOf);
a rect in logical pixels at a pixel ratio of 2;
the tree as data: a project field’s value travels, an unidentified text field’s value is withheld, a label keeps its e-mail address, an address in a project’s field is read as it was typed, and a provider key’s obscured box travels neither its value nor its bullets, while a key box shown by its eye is withheld by its identifier, not by obscurity;
the entity page’s tabs by their ids — Workflow workflow among them — and the selected one;
the control at a point (semanticsNodeAt, describeControl, the issue recorder’s rule): a button by the identifier around it, and the same by its node id; a chip by its label within the row that carries the identifier; a pull-down by its identifier opened with expand, and its item by its label once the pull-down is open; a dialog’s button by its label, borrowing no identifier from beneath the navigator; a tab as a tab; a point on nothing that takes a click not resolved; a control only a tooltip names, and a second control of the same label, not resolved; a control keeping its own identifier though it holds another control (a row around a star button, a text field around a clear button), one drawn outside its parent still found, and a label holding an e-mail address resolved;
textValues and focusedTextIdentifier: a value read under new-entity.tag and withheld under account.login, and the focused box named only under a project identifier | | packages/filmopen_automation/test/ring_log_sink_test.dart | the host’s copy of the log (§4.3): an event’s line with its time, level, name and data, and an error with its message, stack and type; the ring keeping the last lines, oldest first; a value JSON cannot hold, written as its text; the log’s threshold still applying | | packages/filmopen_recorder/test/tape_test.dart | the tape on its own (§6.8): one JSON object per line, LF, seq and t rising, at in UTC milliseconds, a line’s own fields never overwriting its header (seq, kind); every text written as it is, in keys, lists and maps, with a typed value outside a project identifier refused — a dictation’s words among them, whose box fills a field the tape reads again — while the plug-in developer page’s choices, its arguments box and its two file paths travel as a project’s field does; what was typed — a path under the home, a comment marker, /* … */, \o/, A:/B testing, a drive path — written as typed, so that replay types what the tape says; a report path refused when it could leave the folder; the log’s tail keeping this session only, from the app’s last start; a value JSON cannot hold written as its text | | packages/filmopen_recorder/test/snapshot_test.dart | the project snapshot (§6.8): every text file copied and media left out, the copy taken after a write differing from the one before by that write; a Drive-shared film’s manifest reaching the report as it is, and the snapshot logging its prefix, how many it copied and its time; the folder on disk appending the tape line by line and writing files beneath it; a recording’s folder named after its second, and a second one in the same second getting -2, both read back by the one grammar (isReportStamp, stampTime, reportFolderName) that refuses a short, trailing-dash, lettered or five-digit stamp; the web build writing no report folder (hasReportFolders, which support’s hasReportFiles is); a path inside a report folder plain (isReportPath, checkReportPath): no empty path, leading /, backslash, drive, colon, empty, . or .. segment | | packages/filmopen_recorder/test/shots_test.dart | how many pictures a recording has written (§6.8), what the flash and a commentary’s cut listen to: zero at the start, and rising only once the picture’s bytes are in the folder and its line is on the tape, once per picture and in order (shots/0001.jpg, shots/0002.jpg); the next recording starting its count again from zero, the fall heard at its start; a picture whose capture threw, painted nothing or could not be written not counted, the next counted as the number of pictures written and not of those asked for | | packages/filmopen_recorder/test/log_runs_test.dart | the log a report carries (§6.8): two runs in the file give both, from the start before this one, whole and unchanged — a line that only mentions app.started no start —, with the starts, the lines and thisRunFrom; the run before in the rotated filmopen.1.jsonl gives both across the two files; a single run gives that one, incomplete with its reason; the collection’s own log line rolling the real file sink over loses nothing, the runs found the runs copied; nothing is capped; no log file is said in the log; a copy whose writer throws logs recorder.log.failed with its file and the stage copy and leaves the file closed (Windows deletes its folder) | | packages/filmopen_recorder/test/verbose_recording_test.dart | the log verbose while a recording runs (§6.8): on at start, the setting untouched; off at a stop, at the app’s exit stop, at a stop that fails and after a start that fails, each logged log.verbose.forced | | packages/filmopen_support/test/recording_verbose_test.dart | a recording’s verbose log in memory alone (§6.8): with verbose logs stored off and on, a recording and a stop that fails leave the setting and the stored preferences as they were, the threshold the setting’s after | | packages/filmopen_recorder/test/report_facts_test.dart | what a report says of the build, the screen and the pictures, and that its files hold the paths and the log as they are (§6.8): reportWord keeping a commit, a build and a version as they are — a hash with -dirty, local, dev, 0.1.0+dev, v1_2 — a commit up to 64 characters and a build up to 40, and anything else, an empty word, one with a space, a leading - or ., a slash, a backslash, an accented letter, a line break or one over the limit, the fallback, so that a word the website would refuse is never sent on a ticket; a person’s pictures the view’s logical size at quality 80, and by default the screen’s pixels at quality 90; captureWindowJpeg painting the window at the ratio and quality asked, else at the view’s own, the bytes those of the same pixels encoded at that quality; the build, the commit, when it was built, the screen in physical pixels and the view in environment.json and on the tape’s start line, the pictures the size asked; the build and the commit written as given and a moment that is none left out; a recording started with nothing said of the build — the agent layer’s — writing none of it and taking the screen’s pixels at quality 90 as before; a platform that names no screen giving no display while the recording goes on; a library path kept before the recording writing no line when another setting changes, and its own change written as it is; the report’s paths and log: every path — the project’s, the log file’s, a log event’s, a setting’s — in the environment, the tape’s start line, a log event and a setting as it is; a log event’s data, error and stack on the tape, an account’s event among them; and in log.jsonl each line as the log file holds it, a plug-in’s data and an error with its stack included; a dictation’s end, a refused target, a commentary line not written, a voice conversation’s turn and its release, and a report described with its commentary on the tape and in log.jsonl with the person’s words, whole; the app’s log naming a recording’s folder by its path | | packages/filmopen_recorder/test/compare_shots_test.dart | replay’s measure of two pictures (§6.8), a person’s painted at the view’s logical size and an agent’s at the screen’s pixels: the same page painted at 1 and at 1.25, 1.5 and 2 the same — compared at the smaller size, the pair marked scaled, the share of pixels that differ under kSameShare, on text drawn at fractional places as it lands at 125 %; a panel in one of them a difference, at two ratios as at one; one size compared as it is, with nothing different | | test/recorder_test.dart | each rail page but the project’s (Watch, Activity, Share, GPU, Settings) named as the initial page in start, state and environment snapshots; changed pages named consistently in navigation and their associated state snapshots; the issue recorder on the whole app (§6.8): an overlay session is identified in its environment; a dialog is in windowKey’s picture and not in rootKey’s, and the route seam hears it open and close; a scripted sequence — a character’s box, the Low chip, Add character with a tag typed and cancelled, Compare, Settings and the handle — on the tape in order, with a picture and the state after each action, no account value, the project’s files before and after, a tape whole line by line before stop, and every door given back; a door that fails mid-recording leaves a readable tape, its error and stack on the tape’s log line, and the recording goes on; wheel ticks at one control are one scroll line, and a tick at another control begins the next; a start that fails gives back every door, logs its error and names no folder; the rail’s ? opens Get Support and About (the specification’s version, the open-source notices), its intro saying the recording can be described and sent, its Record an issue, a target of standard density at least 44 px high, closes the dialog and starts a recording (its pictures the view’s logical size at quality 80, its start line naming the build — the app’s version, its build and its commit, local in a build made without a script, no moment it was built — and the screen, nothing overflowing at 700 px), and the ? becomes the stop, which opens no support dialog and whose click is on the tape once; the dialog fits at 375 and 1200 px in dark, on both tabs, its intro the same | | test/report_pictures_test.dart | an agent’s recording (§6.8), on the whole app: the agent layer’s record_start taking the screen’s pixels at quality 90, and the tape’s start line naming no build and no commit | | test/recording_flash_test.dart | the flash on the whole app (§6.8), wrapping the window a picture paints so that no picture holds it: the flash an ancestor of the window’s boundary and not inside it; none before a picture; a picture caught at the flash’s brightest — the theme’s peak — holding no white at the middle of the window; the rail’s Settings button answering a click during it; every flash gone once it has lasted, and the click’s own picture counted | | test/recording_caption_test.dart | the caption of what is said on the whole app (§6.8), a recording’s rail drawn with its microphone: at 375, 532, 700 and 1200 px and a text scale of 1, 1.5 and 2, the caption covering neither the rail’s microphone (nav.record.mic) nor its stop (nav.help), nor a message of two lines at the bottom | | test/commentary_test.dart | what the person says beside a recording’s pictures, on the whole app (§6.8): the box in Get Support — the dialog fitting at 700 px with it — ticked and starting the microphone with the recording, the rail showing the microphone while the recording runs, a failed stop releasing the microphone with one terminal Usage record and the next press opening a new one; the rail’s stop settling the commentary before the recorder closes its folder, the words still being said when it is pressed taken by the stop’s commit, written to the commentary file, and whole in the dictation’s end on the tape, its lines appended before the tape’s stop line, the microphone off and the usage chain ended; with the box not ticked, the recording starting with the microphone off and no connection opened, and the rail offering it | | test/report_flow_test.dart | a recording’s stop on the whole app (§6.8): the rail’s stop closing the recording, then opening Describe the problem on the folder the recorder wrote, at 700 px with nothing overflowing; the recording listed as not sent from the stop on; signed out, Save and no Send, the consent shown the first time; the description typed written as the folder’s description.txt, as typed, and in no line of the tape, the log holding it as report.descriptionWritten; the recording waiting in Get Support, whose Send opens the dialog again with its description, and Sign in landing on Settings with the account’s popup open on its login — the one opener — saying at its top what became of the recording, with nothing sent; Get Support‘s tab bar staying where it is when About is chosen, at 1200, 700 and 375 px; a login the account’s server refuses to renew — a refresh token not found or already used, an expired login — being the sign-in with nothing sent, and any other answer — a server failure, a rate limit, a connection that could not be made, a bad reply — staying a failure, which is could not be sent now; no Send offered, with the reason, for a recording being sent; the rail sending through the website, as this build names itself — its address, version, build and commit — where nothing else was installed, and not making the sender twice | | packages/filmopen_support/test/recording_flash_test.dart | the flash at every picture (§6.8), on a window of one colour with a button in its middle: over a light window a layer at peakLight once a picture is taken, held at its peak a moment, fading, and gone once it has lasted; over a dark window a gentler one, peakDark; a picture written while a flash is under way flashing no second time, and the next once it is over, so that no more than three start in a second; a tap during a flash reaching the control under it; the window’s picture painted at the flash’s brightest holding no white, the layer standing outside the boundary a picture paints; a count that falls while a recording runs no picture, nor one that rises while none runs, and a rise from where it fell one; with animations off, a still layer that does not fade, gone once shown, and none again before the last would be over; nothing flashing on a tap while nothing records, at a stop or after it; a new recording’s first picture flashing | | packages/filmopen_support/test/commentary_test.dart | what the person says while a recording runs, beside its pictures (§6.8), on a fake microphone and a platform that answers only what the test says, every picture cutting the stretch in progress and a stretch standing at the tape’s moment it began. Lines: words said before the first picture standing from the moment the microphone came on, none said between two pictures giving no line, a sentence with a picture in its middle giving two lines, its start before the picture and its end after; a pause giving two lines between the same two pictures, and words that come after the next picture still standing before it; a line of at most 1,000 characters, a stretch of 1,500 two lines of one moment cut at a space, a longer word cut at the limit and never inside a character (an emoji across it whole on the next line), and an e-mail address as it was said; after 2,000 lines nothing more written, the microphone off with the reason full and not started again in that recording; a stretch flushed after the folder filled logged support.commentaryNotWritten with its words and reason: full, not written. Why the microphone stays off: with no speech service, no key or no microphone the code saying why and no connection opened; a microphone whose start throws going off as start_error, logged with its error’s text and never left starting; a stop that comes while the setup is still read opening no microphone. A failed stop: answered mic_unavailable and released once, never retried, by natural end, finish and recorder stop; bounded text/report/Usage finalization and sealed publication while raw Stop or session Close remains pending; last words settle once before physical retirement; obsolete pending Audio.start keeps its grant until the late capture stops; exact once-only token release and no new session or Usage after logical closure. Stops and other recordings: a recording stopped by any door — an agent’s stop, the app’s exit — turning the microphone off, closing its connection and ending its usage chain; a stop by another door keeping the lines in the order of t, the clock that reads zero once nothing records never moving the boundary back; the last line landing during the person’s own stop keeping the recording full, and nothing starting the microphone again in it; a reason kept with the recording it came in — one found after another recording started, one left by the last recording, a full commentary and a drop while the last words are awaited — none carried into a recording started meanwhile; a stretch that ends after another recording started standing within the recording it was said in and in no other. The words: the person’s words in commentary.jsonl and whole in the dictation’s end, in the app log and on the tape, in no line of the usage log, and commentary.jsonl left out of an archive sent with Send what I said unticked, each stretch logged by its time, lines and characters, the recording’s stop committing the words still being said and waiting for them before it closes the connection, and the usage records naming their purpose, support.commentary. The rail’s button on the real commentary: the message saying why the microphone went off by itself — a dropped connection, a full commentary, no key, no speech service, a start that throws — and, for the person’s own stop, or a drop while it awaits the last words, saying nothing more than that the microphone came on — unless the microphone would not stop, which it says (mic_unavailable). The caption: none while the microphone is still coming on; Listening… while it is on and nothing has been said, then the turn in progress as its words come, the last turn said until the next takes its place, the words still shown while the last ones are awaited after the stop, and nothing once the microphone is off or while none is; an e-mail address as it was said; outside the boundary a picture paints, under no pointer and in no semantics; a long stretch shown by its end, from the start of a word — one beginning just where the last 160 characters do kept whole — never half a character, nor a part of one written as several (a family’s emoji); where two lines hold less — at 375 px, at a text scale of 1 and of 1.5 — as much of the end as they hold, the last word whole and nothing cut at the end, one word more not fitting; the longest end that fits, from a word’s start, and within a word too long for the caption from a whole character, a flag never split; a commentary the folder will not take turning the microphone off, the rail saying why (not_written), the session closed and the words lost logged with the refusal, and on the tape of every archive of that folder, ticked or not; for each family of events that carries the person’s spoken words — dictation., voice., assistant.voice., support.commentary, report.description — its own events and one it does not have yet keeping the words whole in the app log, on the tape and in every archive, ticked or not | | packages/filmopen_support/test/commentary_button_test.dart | the rail’s microphone while a recording runs, and the support dialog’s box (§6.8), each state saying what it is and what a press does: nothing drawn while nothing records; an actual failed Stop at 700/1200 px in both themes releasing the microphone, off and offering a new start, and a stop slower than its limit released at the limit with its late end releasing nothing again and adding no report line or Usage record; off offering to start, and a press starting it; connecting greyed; listening with the time spoken and the cost so far, in the recording’s red, a press stopping it; stopping greyed; off by itself in the rail’s own sentence, not in the recording’s red, enabled so that a press tries again, for every code the commentary ends with — no key, a key store that cannot be read, a usage log that cannot be written, a microphone that cannot be used, a key refused (401, 403) naming Settings → Plugins, a speech provider not ready naming it and its page (Settings → Plugins → <provider>) with no microphone opened, another status, an unavailable or missing speech service, a start that failed, twenty minutes without speech, the time limit, a connection dropped, not reached, unanswered or refused, a microphone whose format cannot be used naming where another is chosen (Settings → General → Dictation) — none offering the popup’s Resume; a full commentary greyed, saying nothing more is written in the recording; a message when the microphone comes on, said once and not at every tick, and when it goes off by itself with its reason — a drop named once the microphone is off and not while the last words are awaited, a full commentary named while it still listens — none for the person’s own stop and none while nothing records; the cost with a decimal point and dollars before it; the box off until ticked, its choice kept in the preferences and read back on another start of the app On FilmOpen credit the cost reads Cost unknown, never a price or zero. | | packages/filmopen_support/test/describe_dialog_test.dart | Describe the problem at a recording’s stop, the consent, and the recordings not sent (§6.8), with a sender that counts what it is asked, nothing sent but on Send, signed in. The description: the text typed — an emoji, an accented line and a trailing space among it — written as the bytes of description.txt and logged whole as report.descriptionWritten, beside the choice (report.chosen); a tap beside the dialog or Escape writing it as typed; a blank one leaving no file and one erased removing it, by Keep, Send, Save or a tap beside; 4,000 characters, counted as characters and not code units, the most that can be typed; one that cannot be written or erased logged with its error and its recording’s stamp; on disk, the UTF-8 bytes as they are, a file that is not UTF-8 or is missing read as none, and deleting what is not there changing nothing; a stamp naming a report folder only where it is twelve digits with an optional numbered suffix as -2, never a path, and its moment read from it; the web build keeping no recording to describe or send. What was said: the commentary’s texts read line by line, a blank line, a line with no text, a line that is not JSON and one that is not an object left out; Send what I said ticked while there are words, so that a blank description may be sent with them, and when unticked Send saying why until a description is typed; the choice staying with the recording however the dialog closes, and at Try again. The consent: shown, saying what is sent and that an AI reads it, until Don’t show this again, which is kept for the next start of the app and takes effect the next time the dialog opens, What is sent? then bringing it back. Nothing sent unasked: Keep, a dialog dismissed, a signed-out Save and Sign in sending nothing and asking for no token, the recording listed as kept or saved, its description read back when the dialog opens again, and Sign in handing the account’s popup what became of the recording and where to send it from, said there and in no message under it; signed out, no Send and no Keep. The list and receipts: the stop listing the recording as not sent before its dialog, so that a window closed on it loses nothing, a second stop of one folder keeping what the first said; Recordings not sent newest first by the moment each was made — a second recording of one second above the first, one retried last still where its moment puts it — each with a Send that closes the list first, none for a recording being sent, with the reason, and no list once all are sent; Send there opening the dialog with the recording’s description, a recording whose folder is gone, or whose tape is, forgotten with its zip and the person told, and one whose folder cannot be read staying listed; receipts kept between starts of the app, one per recording with its last word in its first place, an entry that is no object, names no report folder or has a state of no kind dropped, and a number that is no number dropped from an entry otherwise kept. The zip: Send zipping the recording beside its folder before the sender is asked — only what a box takes, no commentary.jsonl where unticked though it stays in the folder — the receipt keeping the zip’s hash, the same bytes at a retry, and the zip deleted once sent, where the recording turns out too large, and after Keep, Save or Sign in following a send that could not go; a zip that cannot be made or written, a tape that cannot be read at the moment and a sender that throws each could not be sent now, the recording pending and its zip kept for the retry, the log with its error; over the bound (lowered in the test) too large to send, its size in megabytes taken up to the next tenth, the sender not asked and the recording kept and listed. What came of the send: sent, the recording leaving the device — its pictures, tape, what was said, description and zip — and its receipt staying, sent, with the ticket’s id and number, listed nowhere, the deletion in the log by whether all went, and the description and what was said logged whole as they are sent; through the website’s own sender on stand-ins, a box’s 201 letting the recording leave the device, and a box’s 409, or a Try again the website answers 409 already-sent — as it answers a ticket expired or refused — sent with its ticket’s message and deleting nothing, the folder and its zip staying and no discard logged; a window closed during the upload still leaving the device clean once the box answers 201; sent with neither number nor id, Your ticket was created., no folder’s name shown as a ticket’s; Ticket 127 was created., a number of four digits or more grouped by commas (Ticket 8,877 was created.), or the ticket’s id where the website gave no number, with View on the website opening the site once, and the language at the send passed on; a sent recording that cannot all be deleted saying so after its ticket, its receipt still sent and View on the website still offered; a ticket’s number written as the website writes it, its digits grouped by threes with commas from the right up to 9,007,199,254,740,991, and read back without them as the number it was; a send that could not go keeping the folder and the zip; a website wanting a sign-in taking the person there and keeping the recording saved, its folder with no zip left; too large for support keeping the recording as it was, its folder there; Sending the recording… staying while a long upload goes and replaced by what came of it, and a second Send of a recording being sent sending nothing more; a description changed since the first attempt getting a ticket of its own, an unchanged one keeping its ticket; the ticket kept with the recording as soon as the website makes it, and after a sender that throws. The description said: its box carrying the microphone and no menu beside it, what is dictated going in at the caret under the box’s limit and into description.txt as typed text does, Send enabled by it as by typing, its usage record naming the box and never the words, and the microphone opening the app’s dictation over the dialog; with no speech key, the dictation’s Open General leaving the dialog as a tap beside it does — the description written, the recording kept and said so, Settings on General. Send and the folder: a description the folder will not take never sent stale — newly typed words it could not write, and erased ones it could not delete — the dialog staying, saying so, with nothing zipped or sent and the refusal in the log with the words it could not write; on disk, the zip never written through a link at its place, what the link led to untouched. Cancel: a question first — Discard this recording? — No, Escape and a tap beside it each leaving the dialog, the recording, its receipt and what was typed as they were, its buttons 44 px tall and Yes in the error’s colour; the question fitting at 375, 532, 700 and 1200 px in both themes, signed in and out; on a desktop’s layout every button of the dialog and of the question 44 px each way; on Yes, the recording discarded — its pictures, tape, what was said, description and zip, and its receipt with the ticket’s id and number — opened again from the list, with nothing written or sent, the choice and the discard in the log without a word of the description, and Recording discarded.; signed out, beside Save, with its tooltip; Escape still keeping the recording; one that cannot all be deleted staying listed, nothing typed written, the person told; on disk, the folder with all it holds and the zip beside it gone, a link inside deleted and never followed, neither a folder with no report’s name nor a report’s name that is a link ever deleted, and on Windows a zip another program holds open leaving the discard incomplete — the folder gone, the recording listed — and, let go, gone. Layout: the dialog fitting at 375, 532, 700 and 1200 px, in both themes, signed in and out, with a long description and what was said, its buttons 44 px tall at the least; Review files before sending opening the folder through the file browser’s door, a picture marked up there before Send the one sent, hidden on a phone; the ticket’s own page and, for an administrator only, its administrators’ page, the id encoded; a log of 20 MB and more sent whole, the zip’s 300 MB the one bound | | packages/filmopen_support/test/report_zip_test.dart | a report’s zip, on a folder on disk (§6.8): only what the support box takes, in a fixed order — the tape, the environment, the log, the description, what was said, the pictures, the project’s files, the project after and the library — a stray .docx, a .exe among the pictures, a picture with too few digits or nested deeper, a .png in the project, a .mp4 in the library and a .tmp draft of the description left out, and a listing that names a path out of the folder, a Windows path, an absolute path, a colon or an empty or . segment never in it; the same folder giving the same bytes and hash twice, whenever it is zipped and whatever its files’ times, every entry stamped with one fixed moment; unticked, what was said left out of the zip and still in the folder; the size and hash announced those of the file written beside the folder, which is not inside itself and can be deleted; every entry taken whole however large, the zip’s 300 MB the one bound; the zip built from disk the same bytes as the archive package’s ZipEncoder makes from the same files, on disk and in memory, a mebibyte and a byte of noise among them, with the same SHA-256; on the web’s path, a folder in memory zipped with the archive package’s own deflate at level 1; a zip and its .part that cannot be deleted each tried and each refusal logged with its path; past its bound stopped, its temporary file removed, with the size it reached; every stage logged — listed and chosen with sizes, each file read, the compression, the size against the bound — and a failure with its stage and file, carried home from the other isolate; a folder zipped on another isolate to the same bytes, with and without the words; a folder named with a trailing separator listing and zipping as without it; the size in megabytes taken up to the next tenth, one byte over the limit never reading as at it; links: a link in the folder and a file under a linked folder — a junction on Windows — never listed nor zipped, and the description never written through a link, wherever the system lets a test make one; a file that cannot be read — a folder in its place, a description not UTF-8 — logged report.fileNotRead with its stamp, path, reason and the error’s message, and a missing one not logged; a file the zip’s isolate cannot read logged in the app’s log with its path and the error | | packages/filmopen_support/test/report_zip_stream_test.dart | a report’s zip built from disk as a stream (§6.8), alone in its file so that the process’s peak memory is its own: a folder of 310 MiB of log, which zips below the bound, zipped with its whole size and CRC in the directory while the process’s peak resident memory grows by less than 64 MiB | | packages/filmopen_support/test/report_sender_test.dart | the sender that takes a recording’s zip to FilmOpen support (§6.8), against MockClient stand-ins for the website and two support boxes that answer as the test says and reach no socket. The ticket and the upload: the ticket announcing the app’s version, its build and commit, the platform, the zip’s size and hash and the language, the account’s token going to the website alone and the upload token to a box alone, the zip put whole under reports/<id> at the box’s address with its length announced, and no redirect followed; a status of 200 as good as 201, from the website and from a box. The boxes: a box answering 503 or 500, or with a redirect that is never followed, leaving the same bytes to the next, a 413 ending the attempt as too large with the ticket kept, a 409 counting as sent since the box holds the report already, though not as taken in this attempt, which a 2xx alone is; a box whose certificate is refused left for the next, and one that stops taking the zip for a minute aborted and left for the next, while an upload that moves — a piece every forty seconds — is never cut; a box whose address is not https, has a user, a query or a fragment, names no host, has no address or is named by a bare address rather than an object skipped, each with its code, the answer logged whole; at most three boxes contacted, however many the website names, the log saying how many were left; both boxes failing keeping the ticket pending, the next send asking a fresh upload token for the same ticket, and a 409 on that ask being sent with no box asked, and not as taken. The website’s answers: a 401, or no login at all, asking for the sign-in without a request, never a Bearer of nothing; a 413, a 429 — with a code or without, a limit it may name never read — a 403, a 503 and a 500 each ending by its code, the server’s answer logged as it is, with no box contacted, the 429 could not be sent now with the recording pending; a website that never answers (ended at its limit, the request aborted), one whose certificate is refused, a token that cannot be had, a client that cannot be made and what nothing expected each could not be sent now, logged by a code, the error’s type and its message, the receipt as it was and a ticket already made kept for the retry; a ticket with a bad id, none, a token with a line break or no boxes uploading nothing. A ticket that outlives an attempt: a ticket the website no longer knows, or whose route names no box, refuses it, takes no POST or says it is gone, made again once, and dropped even where making the next goes wrong; one whose route answers a redirect, a 429, a 500 or a 503 kept for the next retry with no other made, and a 401 or 413 there kept as sign-in or too large; a ticket told as soon as the website makes it, before any box, one with no box to send to kept and its retry asking its route. The log and the rest: the log holding each request and answer, the id, the bytes, the box’s name and codes, never the session’s token, a request header, and every answer whole, the upload token and the box URLs included — the refresh’s among them, and one cut short logged as its text; no sentence of the package speaking of a day, today or tomorrow, in English, the language shown, read from the app’s English file under the keys the package’s sentences have there; the package’s manifest naming no account package; a zip on disk uploaded from its file, whole, with its size and hash | | packages/filmopen_support/test/support_words_test.dart | the support package’s words are the app’s (§10): its 63 sentences in app_en.arb as one block in their order, right after the message that ended the file when they came (analysisDiscardEdits), any message free to follow them — a later append passing and a stray inside the block, the block moved or a sentence missing failing, checked in memory — each with a description and its English, placeholders, their types and their order equal to a fixed copy of what they were (support_words_baseline.dart), never the file compared with itself; the frozen Spanish file byte for byte as pinned, having lost only keys English dropped, so that they read in English there; the generated getters and appStringsByKey giving the same English; no ARB folder, l10n.yaml or generation left in the package | | test/agent_host_test.dart | the agent’s host on the whole app (§4.3), on a fixture; state.page names Activity and Settings at their rail positions. Setup and navigation: installed and attached, it names the project; it navigates to a version and refuses a selection that names nothing. Compare and typing: it opens Compare, copies a row by its identifier and types through a form’s own setter; the autosave writes both, and the log names compare.copied and entity.saved; a pull-down takes no text; an unknown identifier and a tab the page lacks are not found; a blocked Compare is refused with its reason’s code. Fork and dialogs: find names the version row’s four controls; a fork by its button lands as a click’s does, the state naming the new stem, the tree its row and the log entity.forked; Compare’s question is intercepted and answered by a dialog button’s label. Page and settings: the page is painted as a PNG; dark and English go through Settings’ doors, a language the app keeps but does not show during development (es) is refused as languageUnavailable and one it lacks as bad_args, and the tabs answer to their ids; an e-mail address typed as the handle refused as invalidHandle, the username staying what it was and no address in the state; an empty handle default; a tap at a position opens Settings. Recording: the recorder’s ops (record_start, record_stop, record_state) starting, naming and stopping a recording, its folder named as it is, an e-mail address in it included, and its tape hearing the agent’s taps marked via: semantics. Quit: the open drafts written before the answer, the exit asked for only after it, and a running recording stopped first, its tape ending with the exit; a draft that cannot be written refusing the quit, and the application staying; a username that cannot be put back refusing it too (viewer), before anything has ended; the settings the session started with put back through Settings’ doors; quit waiting for the username it put back to reach the preferences, and refusing (refused / viewer) where the store failed to keep it, nothing ended — and where the agent had put the username back itself and the store did not keep that; a refused write tried again by the next quit, which goes through once the store takes it; a session that never touched the username quitting though the person’s own change could not be saved before it; quit writing a draft typed into during its first write by a second pass, not refusing it; a username changed through Settings’ own box answered for by every quit until the store keeps the person’s, and one put back through the box with its write refused answered for though quit restores nothing; a quit refused because the username could not be put back writing nothing of the agent’s to the store. Unattached: nothing is answered before attach, and the host is not available after detach; Settings’ tabs by their ids — and, below 700 px of window, Settings’ pull-down of pages opened and chosen from by set_tab, its value the state’s tab, a tab Settings lacks not_found; quit putting dictation’s microphone, its name and the switch back too | | packages/filmopen_support/test/report_sender_test.dart | the sender that takes a recording’s zip to FilmOpen support (§6.8), against MockClient stand-ins for the website and two support boxes that answer as the test says and reach no socket. The ticket and the upload: the ticket announcing the app’s version, its build and commit, the platform, the zip’s size and hash and the language, the account’s token going to the website alone and the upload token to a box alone, the zip put whole under reports/<id> at the box’s address with its length announced, and no redirect followed; a status of 200 as good as 201, from the website and from a box. The boxes: a box answering 503 or 500, or with a redirect that is never followed, leaving the same bytes to the next, a 413 ending the attempt as too large with the ticket kept, a 409 counting as sent since the box holds the report already, though not as taken in this attempt, which a 2xx alone is; a box whose certificate is refused left for the next, and one that stops taking the zip for a minute aborted and left for the next, while an upload that moves — a piece every forty seconds — is never cut; a box whose address is not https, has a user, a query or a fragment, names no host, has no address or is named by a bare address rather than an object skipped, each with its code; at most three boxes contacted, however many the website names, the log saying how many were left; both boxes failing keeping the ticket pending, the next send asking a fresh upload token for the same ticket, and a 409 on that ask being sent with no box asked, and not as taken. The website’s answers: a 401, or no login at all, asking for the sign-in without a request, never a Bearer of nothing; a 413, a 429 — with a code or without, a limit it may name never read — a 403, a 503 and a 500 each ending by its code, the server’s answer logged as it is, with no box contacted, the 429 could not be sent now with the recording pending; a website that never answers (ended at its limit, the request aborted), one whose certificate is refused, a token that cannot be had, a client that cannot be made and what nothing expected each could not be sent now, logged by a code, the error’s type and its message, the receipt as it was and a ticket already made kept for the retry; a ticket with a bad id, none, a token with a line break or no boxes uploading nothing. A ticket that outlives an attempt: a ticket the website no longer knows, or whose route names no box, refuses it, takes no POST or says it is gone, made again once, and dropped even where making the next goes wrong; one whose route answers a redirect, a 429, a 500 or a 503 kept for the next retry with no other made, and a 401 or 413 there kept as sign-in or too large; a ticket told as soon as the website makes it, before any box, one with no box to send to kept and its retry asking its route. The log and the rest: the log holding each request and answer, the id, the bytes, the box’s name and codes, never the session’s token, a request header, and every answer whole, the upload token and the box URLs included — the refresh’s among them, and one cut short logged as its text; no sentence of the package speaking of a day, today or tomorrow, in English, the language shown; the package’s manifest naming no account package | | test/agent_host_test.dart | the agent’s host on the whole app (§4.3), on a fixture; state.page names each of the six rail pages, and navigate and open_project from each land on the project page. Setup and navigation: installed and attached, it names the project; it navigates to a version and refuses a selection that names nothing. Compare and typing: it opens Compare, copies a row by its identifier and types through a form’s own setter; the autosave writes both, and the log names compare.copied and entity.saved; a pull-down takes no text; an unknown identifier and a tab the page lacks are not found; a blocked Compare is refused with its reason’s code. Fork and dialogs: find names the version row’s four controls; a fork by its button lands as a click’s does, the state naming the new stem, the tree its row and the log entity.forked; Compare’s question is intercepted and answered by a dialog button’s label. Page and settings: the page is painted as a PNG; dark and English go through Settings’ doors, a language the app keeps but does not show during development (es) is refused as languageUnavailable and one it lacks as bad_args, and the tabs answer to their ids; an e-mail address typed as the handle refused as invalidHandle, the username staying what it was and no address in the state; an empty handle default; a tap at a position opens Settings. Recording: the recorder’s ops (record_start, record_stop, record_state) starting, naming and stopping a recording, its folder named as it is, an e-mail address in it included, and its tape hearing the agent’s taps marked via: semantics. Quit: the open drafts written before the answer, the exit asked for only after it, and a running recording stopped first, its tape ending with the exit; a draft that cannot be written refusing the quit, and the application staying; a username that cannot be put back refusing it too (viewer), before anything has ended; the settings the session started with put back through Settings’ doors; quit waiting for the username it put back to reach the preferences, and refusing (refused / viewer) where the store failed to keep it, nothing ended — and where the agent had put the username back itself and the store did not keep that; a refused write tried again by the next quit, which goes through once the store takes it; a session that never touched the username quitting though the person’s own change could not be saved before it; quit writing a draft typed into during its first write by a second pass, not refusing it; a username changed through Settings’ own box answered for by every quit until the store keeps the person’s, and one put back through the box with its write refused answered for though quit restores nothing; a quit refused because the username could not be put back writing nothing of the agent’s to the store. Unattached: nothing is answered before attach, and the host is not available after detach; Settings’ tabs by their ids — and, below 700 px of window, Settings’ pull-down of pages opened and chosen from by set_tab, its value the state’s tab, a tab Settings lacks not_found; quit putting dictation’s microphone, its name and the switch back too; a tap on a > that Compare does not draw answered not_found and logged agent.refused | | test/agent_host_test.dart (the stage put back) | quit puts back the stage a film had when the agent attached and forgets one given during the session, the maps compared by content (§4.3) | | packages/filmopen_plugin_host/test/capabilities_test.dart | the capabilities the app calls (§6.11): a picture granted to that call alone and described, its clothing as the prose outfit_description; a leaf in the plug-in lab’s camelCase never renamed; media the entity does not name, one it deleted, none, a kind the plug-in does not describe or media of another kind refused before anything runs; an answer the definition does not hold refused; a plug-in that is off, or a function that is no capability, not called; a style described from the project’s picture in the document’s own leaves; a recording granted as a sound and its voice answered as heard; an answer of another kind than asked, or a description of an entity that is no character, refused; a call filed under its function for its entity; a call’s usage chain ending with it, of a cost nobody says; a description that failed keeping the plug-in’s own words, never a kind it did not name; a writer asked for prop-sheet, and a kind no definition names refused badArgs/target; callCapability‘s buildPrompt handing the writer’s declaration, a target no writer declares refused/noWriter | | test/agent_modes_test.dart | the agent build’s modes (§4.3): nothing asked, the stub checks keys and the host keeps its connection; live keys for every platform with a file or the ones named, in the folder FILMOPEN_KEYS names, the platforms checking keys; a live-keys value that is not 1 or platform ids refused; a stand-ins file routing origins to the loopback accepted, and one routing off the machine, to the platform itself, from an origin with a path or of another scheme, to a base with a query or a user, empty or not an object, or unreadable, refusing the launch; a request sent to its stand-in with its method, headers, body and query, after the stand-in’s base path, and logged by its host; a body streamed without a length, a form with its type and boundary, and none at all sent as they came; a host in capitals or with its default port routed as its origin; a redirect answered as it came, never followed; a keys folder that is not there refusing the launch; attached, the live keys filling the cards the tab draws, now and when a plug-in brings a card; any other origin — another host, scheme or port — refused with nothing sent and logged by host; each named platform’s key saved from its file through Provider keys, cleaned, checked once by the platform, never twice a session unless its plug-in’s settings changed since a try that stored nothing — an unrelated notification leaving it alone, a change during the check tried as the check ends —, a platform not named, one with no file and one needing two values left alone, and no value in the log; a key the platform refuses not sent again; the plug-in host reading a key’s record from Provider keys itself in an agent build — a save answered, a removal none, nothing written — the reader installed in every mode; an isolated fixture’s decision logged once per name and record — 254 reads of one unchanged record one .skipped, a changed seed a second, no line per read; the agent build’s link door opening no link outside the app — a guide, a key’s page or a sign-in answered as not opened, the link’s host alone logged, never its path or query; an import proposal read from the file FILMOPEN_AGENT_IMPORT_PROPOSAL names, refused unread or invalid, proposed once the film opens as its viewer and again for another username, writing nothing; the assistant fixture (FILMOPEN_AGENT_ASSISTANT_FIXTURE) started only in the launcher’s private data folder on Linux or the sandbox home on Windows, refused beside live keys or the stand-ins, its connection refusing every request and its keys checked by the stub, its six packages written into a library of the run’s own — two catalog assistants with their portraits, plan 160’s text provider on OpenAI, a provider on OpenRouter for Opus that declares tools, the Settings model the fixture selects Opus on that provider, an image route on fal, and a model picker naming that route for the kind and stage asked, its install stage picker, its manifest model-picker at revision 1, no ctx.http in its code and its getDefaultModels answer under Node — each stage said on the startup output, never a path; the providers’ own JavaScript run under Node where it is installed (skipped otherwise): a question, the person’s last words on Apply, and with tools a typed render or open answered as one tool call naming the context object’s $id, a typed prop <name> as one create-entity call with its name and its tag in lower case with hyphens, needing no focus, a typed cast <n> as n create-entity calls in one reply — a character, then a location, in turn — and their answers as one update-entity call on each id answered, those answered in a word, the tool’s output answered in words, the text.tools diagnostic with counts alone, and no request (plans 160 and 165 drive it whole); the Windows sandbox isolating a build with the fixture or without it, a sandbox without a drive-absolute home refused (sandboxHomeInvalid); the device’s credential store in memory unless FILMOPEN_AGENT_PERSISTENT_STORE is 1, and then the device’s key alone in the device’s store, every other name — a provider’s key — in memory, the store ephemeral, so that a key saved there keeps its record in memory and the machine’s preferences, a product record among them, stay as they were; live speech off unless FILMOPEN_AGENT_LIVE_SPEECH is 1, beside live keys, and refused beside the stand-ins or the fixture (liveSpeechCombined). A fixture installation refused by a file where a folder is required logs its platform-selected FileSystemException or PathExistsException name; the thrown object is separately checked as a FileSystemException, with no path in the log; a Linux agent build only in a private home: the person’s own XDG_STATE_HOME or XDG_DATA_HOME, an unnamed or an empty one refused homeNotPrivate; folders of its own, FILMOPEN_AGENT_REAL_HOME=1 and a non-Linux start pass; a Windows agent build without the sandbox refused homeNotPrivate, the sandbox or FILMOPEN_AGENT_REAL_HOME=1 passing; every name in the store (all) only under the launcher’s folders on Linux, refused on Windows | | test/agent_account_test.dart | the agent build’s account mode (§4.3): asked, an AgentAccount over the keys folder, unasked the account withheld; accepted, agent.account.start and agent.account.dev logged; the check’s start and outcome on stderr, a refusal’s values and elapsed ms with it; refused before the file is read with accountNotDev (a production auth project or site), accountNeedsStore, accountCombined (the stand-ins, the fixture), accountNoFile and accountCallback. The sign-in: nothing stored, the password from its file through the model’s door, sent without its line ending, the device told of the sign-in; the test account’s stored session restored, no password read; another account’s — or one naming nobody — refused accountOtherSession with no connection, no store write or delete and no registration; a rejected password accountSignInRefused, a key file that cannot be read accountUnreadable (a folder in its place, given to the sign-in directly: the launch’s check refuses it earlier as accountNoFile); a store that cannot be read accountStoreUnavailable, a file gone by the sign-in accountNoFile, a password answered by another address’s session accountSignInFailed. The device and the balance: the ordinary registrar rebuilt on the device’s store, its onRegistered kept, the device’s key written there, the balance read, agent.account.ready with both; a refused registration or an unread balance accountNotReady with its stage within the bound. The sentinel: a sentinel password in no log line and no answer in every one of these tests, success and failure, the restored path and the malformed session included; the mode beside the assistant fixture refused as accountCombined with the fixture isolated as either platform asks — Linux’s XDG folders, Windows’ sandbox home — so that the combination is what is refused on both | | test/spec_history_test.dart | the Software Specification in its own terms (§12): no part carries a numbered development-process reference, nor a decision or an open item by its number, an algorithm’s own numbered steps and another specification’s sections passing | | packages/filmopen_mcp/test/server_test.dart (set_tab‘s description) | the tool’s schema offering Settings’ two pages, general and plugins, the GPU page’s servers, share and remote, the Script page’s contents, script and workflow, and neither keys nor usage | | packages/filmopen_mcp/test/server_test.dart (launch on android requires a device and refuses a size, a home or a device on a desktop, the device reaching the launcher, and a client that sends "size": null is refused by the tool’s own schema, which names the property, before any argument handling is reached) | | packages/filmopen_mcp/test/server_test.dart | the MCP server (§4.3) through an MCP client on an in-memory channel, against a fake link:
Tools: a tool for every op of the app’s channel, quit among them (checked against filmopen_automation’s agentOps), beside the window, the wait, enter_text, launch and stop; enter_text handing its text to the link’s text entry and never to the channel, answering typed, and refusing a missing or non-string text as bad_args.
Answers: each op tool sending its op with its arguments and never the URL, and answering the result as JSON text; page_shot and screenshot answering image content; an app’s refusal returned as an error result with its code.
The link: a failure on the link, or a request past its time, dropping it, answered by its type and its message, whole, the service URL included, logged as mcp.failed with the tool, the step, the error and the stack, and reconnected on the next call; every tool call logged on stderr’s channel as mcp.started with its arguments and mcp.done with its outcome and time, a refusal’s answer with it, enter_text’s text and a set_field into the developer page’s arguments box logged whole as every other field’s value is, the service URL whole; a vmServiceUrl that is not a string, or not on this machine, refused as bad_args for state and for stop, the link kept; the announced agent build found by itself, looked for again only once its link fails, and no_app without one; a service that is not an agent build named so, and nothing kept; a window shot written only as a new .png inside its folder, or over one the server wrote, and any other path — outside it, not a PNG, another’s file, one the file system refuses — answered bad_args, the link kept; wait_idle; calls sent at once opening one link between them; calls still queued when the client leaves answered without running, no launch starting, and a link opened meanwhile closed; a client leaving asking the app it launched to quit before q.
Launch and stop: launch starting, linking, waiting, applying its options and answering the state, and refusing a second launch and a platform it cannot run; the launched app outranking the URL named at start; a launch whose app does not let the driver in answering launched: true, and still stopped; a launch that fails before its app answers giving its reason, its exit code and its last lines; a launched app that ends by itself retains its owned identity, closes its link and clears temporary resources once; subsequent operations report no_app / ended without adopting another announcement; a client leaving mid-launch stopping what was started; stop ending a launched app with its quit and q, over a new link when none is open, or saying it had to kill it; a draft it cannot write keeping it running, a quit still writing waited for (timeout when it stays), and an app without quit ended with q (by: q); foreign explicit URLs on operations and stop are refused while owned, leaving the other app untouched; stop acknowledges an ended owned app, and a new launch after stop succeeds; operations after stop still never rediscover another app; a never-owned server asking a discovered app to end through its own quit and waiting for (timeout when it stays), a refusal to quit passed on, and no_app with nothing to stop.; a launch on Linux answering its instance, the home named or one made for it, a refusal after the start naming it too, its path as it is, and a Windows launch none; a launched app whose quit fails ended with q, logged as mcp.failed with the step quit, the decision q and its reason | | packages/filmopen_mcp/test/discovery_test.dart | finding an agent build (§4.3): the log folder on each system, as the app computes it; an announcement of a service on this machine read, and anything else — another machine’s included — refused; a build found while its service answers, and not once it has gone, nor from a half-written file or no file; a stand-in service answering, and a closed port not; a sandboxed Windows build’s log under FILMOPEN_SYNOPSIS_HOME | | packages/filmopen_mcp/test/launcher_test.dart (an android command line takes the device’s serial where a platform’s name would stand and never xvfb-run, a launch with no device is an ArgumentError rather than a guess at -d android, a launch on a Linux host gets a process group of its own whatever the target, the keys reach an android build, and android’s launch environment is empty, the screen being the device’s) | | packages/filmopen_mcp/test/launch_console_test.dart | the command line’s launch of an android app with a stand-in flutter: both streams printed line by line as they came, the VM service’s URL whole; a key forwarded to the child; the child’s exit code the launch’s, its own input never closed; the whole URL in agent.json read back through AgentAnnouncement.parse and discoverAgent, logged launch.announce.start {path} and launch.announce {path, ms} | | packages/filmopen_mcp/test/launcher_test.dart | starting an agent build (§4.3): every launch passing FILMOPEN_BUILT_AT, the moment in UTC to the second, last (§6.6a); FILMOPEN_ENGINE in the environment passed as --dart-define=FILMOPEN_ENGINE=<name> on Windows and Linux and nothing when unset, each said as launch.engine {platform, requested, source: env|unset, define, ms} (§19.16); the service line flutter run prints matched, and the DevTools line not; the command for Windows, and for Linux under setsid xvfb-run with the Xvfb screen of size; parseWindowSize; the launch environment (FILMOPEN_WINDOW, the Linux XDG paths asserted as literal /tmp/agent-home/share, /tmp/agent-home/state and /tmp/agent-home/cache regardless of host separators); prepareAgentHome; one desktop home (desktopHome) for the server’s launch and the command line’s — a named one made absolute with .. resolved and not owned, none or an empty name a new one owned, on Windows under build/sandbox-home/, none on android; on Linux a process group ended as a group, and a launch that makes a temp XDG home which stop removes, a named home left; the repository an executable belongs to; against stand-ins for flutter, a launch answering the printed URL, a second launch refused, q reaching the process and ending it, a process that ignores q ended once its time runs out, a stop asked for while flutter run is still being started ending it once it has, and a flutter run that ends first failing with its exit code and its last lines, whole, the service URL and an e-mail address kept; a Linux launch under a session bus of its own where the machine has dbus-run-session, with a keyring unlocked in it first where asked and none without the bus, its environment never the desktop’s bus, and its home the instance’s identity while it runs and none after the stop; both desktop launch environments set private FILMOPEN_AGENT_DATA, Android sets none, and Windows-target server and ordinary CLI stand-ins on the host exercise distinct private homes, journal-preserving named relaunch, owned-home removal after normal or failed exit, each ending in launch.ended {platform, exitCode, ms, homeRemoved?, error?} on stderr, and named-home preservation; the command line’s launch logging launch.started with its inputs, launch.command, and launch.lock with a wait for another launch’s lock, which launch.ended’s ms includes; a Windows launch given the app’s sandbox under its home (FILMOPEN_SYNOPSIS_VOICE_SANDBOX, FILMOPEN_SYNOPSIS_HOME), none where the person’s folders are asked for; the command line’s Windows message naming the home | | packages/filmopen_mcp/test/launch_lock_test.dart | one build at a time from one checkout (§4.3): two launches at once, the second waiting until the first has let go of the lock beside the builds, then building; a lock a launch left behind taken over once it is stale, and a launch letting go of its own lock alone; past its wait a launch taking the lock over all the same; a lock that cannot be made waited for, never spun on, the launch going on without it past its wait; a lock whose launch has ended taken over at once, on Linux | | packages/filmopen_mcp/test/cli_parse_test.dart (launch android --device <serial> parsed, a size or a home there a usage error, a device on a desktop a usage error, and the command line built from the command as parsed — the join where --device was once parsed and then dropped with every suite still green) | | packages/filmopen_mcp/test/cli_parse_test.dart | the executable’s command line (§4.3), read as the executable reads it: no words, and serve, serving MCP; every op command’s message, quit‘s included, and words starting with a dash (tap --label, open-project --sample, a negative number); the executable’s own options anywhere before a --, the words after it the command’s, and --help wherever it stands; pictures written to a named or default file; launch on this machine’s platform unless it names one, with --size and --home; enter-text with its one word; record-start, record-stop and record-state; stop and wait-idle; a command line it does not understand, an option without its value, a --size outside <width>x<height> 320–4096, an empty --home or an enter-text without its text, refused with a reason | | packages/filmopen_mcp/test/app_link_test.dart | the link to an app (§4.3), against stand-ins on the loopback: a service URL on this machine being http on the loopback; the WebSocket address the driver derives, from the URL’s first path segment; a service that answers probed and let go; a closed port refused at once, and a listener that never answers refused once its time has passed, as ServiceUnreachable naming no address, to the probe and to a connection; the wait for a service to end; a VM service whose isolate carries no driver extension refused as NotAnAgentBuild, its connection closed; the time running out in a request NotAnAgentBuild where the service had answered and ServiceUnreachable where it never did, never a bare timeout; one whose isolate carries it sent the driver’s own commands, a request past its time failing; and one whose isolate is paused at its start resumed, then connected | | test/ui_cleanup_test.dart | a live unknown mention hit cached before cancellation taped with its label; the header with the name alone, no Version word and nothing after Fork, the label button between the pull-down and the star; the file menu on the first card’s title row without making it taller, and no save status while saving; closing the window writing a draft typed inside the save delay, and ending an open dictation, before answering exit; Compare’s left heading without pencil, check or status, and << and <<< centred on the rows’ gutter; the epochs without chips or explanation; Close project and its blank page, the menu then offering neither Close project nor Re-read files; × taking a remembered folder off the list with the folder kept, the trash naming the project folder in one permanent-deletion question with no checkboxes, No doing nothing and Yes deleting the folder and its row while a separate media folder named by an existing local locator remains; a manifestless project, a non-project folder and a link refused before closing or deleting; Edit JSON… above Copy JSON, opening on the tree, a tapped value changed, applied and saved; a long value kept to its row at 700 and 1200 px; the microphone on the value dialog and never on the tree or the text mode | | packages/filmopen_forms/test/json_tree_edit_test.dart | the JSON editor’s tree without a widget: every path the tree spells reaching its value through objects and lists, a value written at exactly that path, a path two keys would spell alike left out, and a typed value keeping its kind | | test/new_entity_test.dart | Add character, Add location and Add prop — Add prop on the props’ page, never Add location; the prop’s dialog with its title and sentence, its epoch, its kind optional with None first and chosen and A.3’s ten after it in order, a kind written and none written where none was chosen, the prop opening on its own form, no folder made —: the dialog’s identifiers, a taken tag refused inline with Create disabled, the filename filtered to a segment, the name, kind and author written and the page moved to the new version on Edit; the epoch pull-down only where the project has several, an empty name written as the short name and no kind written when none is chosen, at 700 px without an overflow; a file of that name appearing before Create refused as taken with nothing replaced; the file written as the username in effect, with no username box — a change of it while the dialog is open said, nothing written, and the next Create writing as it; the button disabled with the reason on a read-only project; a disabled Create saying why and naming the box — the filename’s problem, then a taken one, on the button’s own semantics node — and nothing once it is enabled; default written where none is chosen; a file of the name written meanwhile refused as taken with that one file read, nothing else | | packages/filmopen_forms/test/beats_editor_test.dart | a block’s beats in the editor (§9.3): the rows under the duration with their identifiers, no position without dialogue and a position outside the three as written; Add beat (during the line where the block speaks), a description, a position and a duration each one draft change; a duration refused as the block’s own; a beat’s move by menu or by drag reseeding the boxes and dropping a refusal, equal durations included, and the block’s own move doing so; Delete beat to the last; the menu’s ends disabled; no beats on the placeholder until its first text; locked read-only; set_field of blocks.<id>.beats.<k>.<key> and its refusals, logged with the key and the value as given; the position pull-down’s trail opened, chosen, unchanged or cancelled, a position outside the three logged as written; a beat the draft no longer holds refused noEntry; the total and its warning above a set duration, the order warning, each logged once as it comes and as it goes, none on a locked editor; every script.beat.<op>.* line with the value entered, the beat as it was and as written, its outcome and ms, a throw logged as failed and rethrown, a block named by its log name, while the block’s own script.block.opened names a free-text id as it is, its index beside it; a block whose id is not bl_<n>: its warning, its clearing, its position’s and its menu’s lines and an agent’s refusal naming block_id beside its place | | packages/filmopen_forms/test/subtitles_editor_test.dart | a block’s subtitles in the editor (§9.3), the beats’ cases over subtitles with Subtitle for Beat: the rows under Add beat with their identifiers, the beats beside them untouched; Add subtitle, a text, a position and a duration each one change, logged from script.subtitle.<op>.start with the value entered and the subtitle as it was to .ok with the subtitle as written, .refused with its reason and .failed with its stage and its error’s message; a duration refused with what was typed; a move and a drag reseeding the boxes; Delete subtitle to none; locked read-only; an agent’s blocks.<id>.subtitles.<k>.<key> and its refusals logged with the key and the value, a negative place refused as out of range, never thrown; Subtitles: 5 s under the beats’ total and the two warnings, script.subtitles.warned and .cleared; Compare’s line of a block with a subtitle; at 375, 532, 700 and 1200 px, light and dark, nothing overflowing | | packages/filmopen_forms/test/script_editor_test.dart | the blocks’ editor on a draft it is given (§9.3): the condensed line — the dialogue beside its speaker’s mark, the speaker alone and beside the direction but never beside an action, the action, (empty block), no id; a click opening the block on the field its line shows, the focus leaving condensing it, Tab opening it; the speaker’s pull-down — No speaker, the scene’s characters by name in the text colour, a line, the others muted, a short name nobody wrote said under the box, and a film with no character saying where one comes from; Tab through an open block’s controls in their order — the dialogue, the direction, the action, the duration, the menu, and no microphone — the block open throughout and condensed once Tab goes past the menu; Tab onto a condensed line opening its block on the first box, and Shift+Tab into a block opening it on its menu, then walking back to the duration’s box, past no microphone; a second Tab before the opening frame not pulled back, one block left open; a block that comes to an open block’s place — a removal beside the editor, a delete from the keyboard — condensed there; a microphone on every box that can be typed into, the dialogue’s only once a speaker opens it, none on a locked block; dictated words (a scripted transcriber on fakes for the microphone, the key and the usage log) landing in an open block’s box and draft as typing would, the block open behind the popup, no box with a menu beside its microphone nor a popup with one, the usage record naming blocks.<id>.action and the duration’s duration_sec; choosing writes character alone and puts the focus in the dialogue; the dialogue box locked with its tooltip without a speaker; typing each box with no key told, an emptied box removing its key; Duration‘s auto at rest, 4. written as 4 with the box keeping its text, and its refusals; a block’s output_duration_sec shown nowhere and kept when its dialogue changes; a caret kept when another block changes under the draft; add and insert under the next number and open on the pull-down, delete with the number never back, Move up / Move down disabled at an end with their reasons and the focus following the block, a drag by the handle dropped where it is let go; a refused duration not following a position, nor a re-read that puts another block at its place; a doubled id’s later block and an unreadable entry locked as JSON with only Delete block; an id-less block numbered at its first change; a block of the old shape rewritten only when it changes; with a mouse on Linux, macOS and Windows: a speaker chosen, the block menu and the handle keeping the block open, a drag of an open block, a click outside condensing it; locked mode, a locked box wearing lockedDecoration; every identifier unique; nothing overflowing at 700, 520, 330 and 270 px in both themes; a duration of 400 digits, 1e400, Infinity or more than a day refused inline and never written, a day taken; an empty script showing its first block, local, nothing in the draft, and Add block making it one; a block’s media: an open block’s places in the table’s order under its fields, the two frame places always, each under its frame prompt as the place’s header and drawn once, none on the condensed line, Add a place… on a block without media naming the other four groups, an empty place shown and gone with the block’s condensing, nothing written by drawing, the menu logged block.place.opened, chosen and cancelled; a locked block’s places without Add a place…; no media for a block with no id or of an id given twice; nothing overflowing at 700 and 330 px, light and dark; the speaker’s entries 56 px tall by the picture or the icon, each use of the menu logged from its opening to one outcome — opened by a press, by the keyboard and by a screen reader’s expand, closed by a collapse; each block opened and condensed logged script.block.opened / .closed {stem, block, index, reason, ms} — tap, focusLeft, tapOutside —, a block come to an open block’s place closing it as the block it was (blockChanged); the focus parked — the window’s focus lost (Windows’ view focus, Linux’s lifecycle), a box’s own unfocus — keeping the block (kept {focus_parked}, then focus_returned), a finger’s tap on another block on the desktop condensing the first a frame later, a mouse press outside condensing through tapOutside with no kept, Tab past the last box focusLeft; the script focus under a real scope with a watcher: published after the frame by a person (a click, a block added, the placeholder’s first words), a re-read and a removal publishing the old block’s close, an opening changed in its own frame skipped, navigation away clearing its own block and not a newer one and closing the subscription; a request while the timeline is in charge opening its block without moving the focus, scrolled into view, the open one condensed (timeline), script.focus.answered {opened | missing | not_following | other_scene | unmounted}, two in one frame the first skipped {overtaken}, a request delivered to its block where a re-read moved it and answered as that block and place, one whose block went skipped {gone}; a block the timeline opened condensing when the person Tabs or puts a finger into another card; with a stand-in dock, its press keeping the block (kept {timeline_press}), a click back in the editor, Tab into a card and a press on another block taking the charge back, a press elsewhere condensing the block and ending it (page_press), the window’s focus restored not ending it, the placeholder ending nothing | | packages/filmopen_forms/test/script_speaker_mark_test.dart | the speaker’s mark on a condensed dialogue block (§9.3): none on an action; the speaker resolved once a row a build, through the mark’s one door, the line’s nameOf never asked; the name under it, the whole name its tooltip; the icon for a speaker without a picture and for one no character has, the name as written; a picture that cannot be read drawn as the icon and logged script.speaker.picture {stem, reference, error} once; the row as tall as an action’s and the mark inside it, editable and locked, at 1200, 700 and 375 px, light and dark, nothing overflowing; the dialogue starting right of the mark | | packages/filmopen_forms/test/scene_blocks_card_test.dart | the Dialog and actions card in a scene’s form (§9.3): the speaker’s mark named and drawn from one resolution — the character’s name, else the tag as written — with the resolved character’s first live reference image, a deleted and an archived one passed over, and the icon for a speaker without one; a block line and the synopsis typed together going out in one write of the one draft; the keystroke’s census on 300 blocks — one seeding a keystroke while the draft is dirty, each block read twice at most once the draft is dirty and three times at the first keystroke, the open card’s boxes alone alive, no prose box re-projected by a keystroke nor by the re-read after the write, which changes no candidate, and the boxes made re-projected when another hand renames a character or adds one; an agent typing every block key and the form’s name on one stem, not found for a block nobody has; another author’s version locked with the guards on and editable in development mode, the stem among the forms being edited only while editable; a doubled id locked, a blocks of ids a value; a keystroke telling the observers no key and a delete blocks; a comparison’s rows labelled #1, #2; another scene shown in the same form inheriting neither an open block nor a refused duration; typing in a scene of forty blocks drawing the form once, at its first letter, and never again per letter; a name cleared and typed again losing its error at once; speakerName at the cast’s epoch, else the scene’s, an odd cast entry not hiding another’s; a scene’s Location through the menu, New location… and the agent’s door, one rule (§9.3): the same location changing nothing, another replacing it and clearing location_epoch, Clear location and an empty text removing the key alone, an unknown location and a value of another shape refused and kept, each decision logged as scene.location after its scene.location.start, with the door, the values before and after (none once cleared), the decision, its reason and the time; New location… logging the location made and put in the scene, and a cancel leaving the scene as it was, each way out a scene.create.decided line with its outcome, reason and the stem made, a form with no draft making nothing (noSaver); a location made while the username changed left out of the scene, its line naming the stem and the change | | packages/filmopen_forms/test/insertion_move_test.dart | insertion completion against source and target during the initial settle, direct target save or fork, removal and source settle; stale move refusal, captured foreign target, draft-preserving attachment and truthful copied-only outcomes | | packages/filmopen_forms/test/script_move_test.dart | Move to scene… (§9.3; Project Specification §10.3), on a memory folder whose writes the test watches, makes stale or refuses: the list (a folder heading, this scene absent, a scene listed twice drawn once, a fork marked, the order); a target whose own save landed and is still publishing taking the block over that save, never refused stale; onto the viewer’s own scene — the target written first under its next number with every key, the source one block fewer, Moved after; onto another author’s — a fork written once, their file untouched; a block edited while the dialog was open moved with its latest text; a target changed after the dialog’s read refused with nothing moved; a source block changed between the copy and the removal, the copy kept and nothing removed; a source save refused after the copy, said, the card’s status in error, and one that landed while more was typed counted as moved; the item disabled with its reason on a block with no id and on another author’s version; a move held at its target’s write not closed by Escape or a click beside the dialog; the log naming the fork written; after a fork-and-move stopped half-way, the list showing the fork in use and the choice cleared, so that a second press needs a new one; a page gone to another scene before the confirm refused with nothing written in either scene, and one gone during the target’s write ending with the copy made and said, never Moved; a block just added whose re-read is overtaken and still pending, then its removal refused as stale: the copy said with the refusal, both files as they are, never Moved; a removal that landed while the move’s re-reads are overtaken: Moved, decided by the controller’s view, not the published index, with no file read; the film closed while the removal is written: the copy said, never Moved; a patch that landed and still publishes kept in the draft when the page is drawn again over the old index, typing after it written over it; a write of what was typed failing while the removal waits behind it, the removal then landing: Moved, another write’s error deciding nothing; a block whose entry covers another block, or that another block’s entry covers, refused before any write with the blocks by position and the covering entry logged, whichever block owns it, every file unchanged; a block with an until extent, a clip of its own block alone and a deleted entry moving with its media as content, renumbered; a scene in the recycle bin offered as no destination; one deleted after the list was drawn refused before any write, its trail — the start, the settle, read and recheck stages, the timed refusal — logged with the film, the source, the block and the target; a move’s trail to its timed end | | packages/filmopen_forms/test/prose_form_test.dart | real form prose upgrades, exact source seeds/copies/agent assignments, mode and shape cancellation, source validation, literal paths; the project’s synopsis, logline and rating, the character’s summary as prose saving canonical source; the Age box’s numeric, phrase and empty paths; a four-digit birth year writing Birth date, filling numeric age, seeding both boxes and locking Age; a kept year retaining its inline error, writing Birth date and restoring draft age, including partial digits typed quickly or autosaved slowly with re-reads; refusal and unexpected-failure logs; stable project/viewer candidates and contextual preview/thumbnail metadata; a changed leading presentation retains the real Name chip and canonical chooser write; foreign shown placeholders are cleaned before draft validation and writes, and recorder samples retain canonical tokens | | packages/filmopen_forms/test/local_prose_test.dart | the prose boxes a row or a dialog owns: a relation trimmed, a blank removing it while the row keeps its other keys, a re-read reseeding it, the character literal; every garment box prose, the notes up to four lines, read-only without a microphone; an epoch label’s chips and its required-label rule; the add-epoch label’s autofocus, Enter submitting canonical source, and its lock while the epoch is declared; each microphone bound to the editable target | | packages/filmopen_forms/test/prose_script_test.dart | script prose source and plain duration, clipboard and keyboard traversal, a character the same candidate source gains making a shorthand a chip in a box already made at the source’s revision, real microphone insertion around chips, cancellation and changed block bindings; real form autosave and placeholder materialization carrying committed snapshots only; mouse and keyboard chooser use keeps an open block in both layouts while genuine departure still condenses it; agent assignments publish cleaned canonical source | | packages/filmopen_text_ui/test/prose_editor_consumers_test.dart (the editor’s parameters) | autofocus taking the focus and onSubmitted reporting canonical source, not the shown chip; onChooserOpen reporting a chip’s replacement chooser and a typed mention’s chooser as each opens and closes | | packages/filmopen_text_ui/test/prose_controller_test.dart (a frame’s media token) | @ch_kira:character_sheet-1 typed a character at a time saved exactly so, raw while typed and one chip once the caret leaves; loaded whole, one chip; @ch_kira typed alone or before a colon and a space still the character’s chip | | packages/filmopen_text_ui/test/mention_query_test.dart (media) | media lead the chooser in their source’s order, filtered by name like the others | | packages/filmopen_text_ui/test/mention_query_test.dart (the boundary) | a letter or digit of any script before @ — café@b, a Greek or Arabic-Indic one, a supplementary letter from its surrogate pair — or an underscore starts no query; a space, a parenthesis or an emoji before it does | | packages/filmopen_text_ui/test/prose_editor_consumers_test.dart | consumer focus/group rules and one outer identifier; suffix ordering, a read-only box asking its suffix builder — which withdraws or keeps its control — and bounded geometry; chips and the chooser keep derived identifiers; controller handoff retains chip interaction, retires old field constraints and preserves consumer refusal through replacement and removal | | packages/filmopen_forms/test/script_dictation_test.dart | dictation into a scene’s block on the real form (§9.3, §9.6): open on a block with no id, which takes its number as dictation starts; another hand’s block inserted before it and the clean form re-read; the words dropped and said, written into neither block, the registry still addressing both by their ids and no box taking the focus; a block still at its place taking the words, its usage record naming it by its place; a block whose id is an address named by its place in the usage record, the address logged as it is where the line names the block; a removed or switched block cancelling its caption, live registry and audio without writing late words; a mounted changed binding retaining its refusal tooltip | | packages/filmopen_forms/test/script_placeholder_test.dart | a scene with no block on its real form (§9.3): one placeholder, a first block open on its fields with no ⋮ or handle, named as the first block; a visit, a focus, a speaker, a duration and blank typing writing nothing — no entry, no next_block, the registry naming nothing; the first nonblank text making one block, bl_1, with the speaker and the duration that waited, the focus and the caret kept, typing on going into it; a count ahead of the blocks kept (bl_5); a block already there, however empty, drawn as itself and nothing written; leaving the page, or opening another scene, dropping what waited; a scene changed on disk meanwhile refused as stale, never written over, and the re-read showing what was written there; Add block making it the block, once, and another adding the second; a microphone on it taking no number — cancelled, nothing written; accepted, its words making the one block; a text set through the semantics, as a recording replays it, making the block under the same name; another author’s scene read with no placeholder and the card’s sentence, saying who writes them; the scene’s last block deleted, the placeholder that comes empty and its next words a block of their own (bl_2); a discard that leaves no block bringing an empty placeholder; a block another change brings opening nothing; what waits on the placeholder said to wait, until its first words; its boxes as wide as a block’s, its first words moving nothing, on a phone’s platform and a desktop’s; Dialog and actions, Direction for character and the two hints, e.g. look into the camera and e.g. Cars are passing by, shown while the boxes are empty, any other direction keeping its own word; a duration refused on it staying, with its message, on the block its first text makes | | test/direction_label_test.dart | Direction for character whole at a 700 px window (§9.3), measured in Roboto loaded from the Flutter SDK, since the tests’ own font draws every glyph an em wide: on an open block and on the placeholder, light and dark, the label laid out no narrower than its words, and an open block’s ⋮ under its fields | | test/identifiers_test.dart | the six pages’ numbers — the three of before unchanged — and names; the Watch, Project, Activity, Share, GPU and Settings rail controls occur once each, in that order above Help and the profile, the app opening on Project, each tap showing that page’s own title in the stack; the semantics identifiers an agent acts on: unique on the overview, a version page, the open project menu, the New project dialog (only its parent, browse, title, tag, cancel and create controls, plus existing dictation controls; no media controls and no username), a category page and the New location dialog, the label dialog, Compare and Settings — no account login on General — and the account’s popup the rail’s nav.profile opens, beneath nav.help (account.login, account.close); the rail (nav.help and nav.profile among them), the tree pane and its rows, the project menu, the version row, the file menu, the fields (file and key), the media card’s places — each of a character’s five places’ Upload, a tile and its menu — the dialogs and the copy controls named; a form registering its setter, typing through the registry reaching the box by the field’s own setter, a pull-down and a key no field owns answering false, the locked column having no setter; General’s keys and a plug-in’s key cards on its page; the microphones on the tree’s filter, a form field, both dialogs and Settings’ handle, the label dialog’s box, the popup’s doors opened from a filled box and from a blank one, and Activity’s Usage section’s; none on the New project dialog’s folder box or the key cards’ boxes; a scene’s page with three blocks, two sharing one line, one open: every block’s identifier present and unique, the dock’s timeline.dock, timeline.handle and timeline.popout with them, the form and the editor on one stem; a character’s three Prompt cards in its media card named once each | | test/identifiers_test.dart | the Project, Activity and Settings rail controls occur once each, in order, and select indices 0, 1 and 2; the semantics identifiers an agent acts on: unique on the overview, a version page, the open project menu, the New project dialog (only its parent, browse, title, tag, cancel and create controls, plus existing dictation controls; no media controls and no username), a category page and the New location dialog, the label dialog, Compare and Settings — no account login on General — and the account’s popup the rail’s nav.profile opens, beneath nav.help (account.login, account.close); the rail (nav.help and nav.profile among them), the tree pane and its rows, the project menu, the version row, the file menu, the fields (file and key), the media card’s places — each of a character’s five places’ Upload, a tile and its menu — the dialogs and the copy controls named; a form registering its setter, typing through the registry reaching the box by the field’s own setter, a pull-down and a key no field owns answering false, the locked column having no setter; General’s keys and a plug-in’s key cards on its page; the microphones on the tree’s filter, a form field, both dialogs and Settings’ handle, the label dialog’s box, inline microphones and captions on filled and blank boxes, retired popup doors absent, Create during a live partial saving only the committed title, and the Usage tab’s; none on the New project dialog’s folder box or the key cards’ boxes; a scene’s page with three blocks, two sharing one line, one open: every block’s identifier present and unique, the form and the editor on one stem; an import’s review naming import.review, import.apply, import.discard and each change once, over the page, and closing at Discard; Compare’s > controls absent on another author’s version; two own project versions in Compare, each column’s epoch year and remove reached by its own identifier (epochs.now.year, right:epochs.now.year) and writing only its version | | test/app_shortcuts_test.dart | paste as plain text (§9.5): PastePlainText above the navigator; Control-Shift-V pasting into a scene’s Name in the app, logged app.paste.shortcut with the keys, the field’s identifier and handled: true, never the clipboard’s text, and Control-V as before; a dialog’s box pasting on Command-Shift-V; a focus that is no field logging handled: false with reason: no-paste | | test/tab_order_test.dart | the window’s Tab order (§9.1): from a scene’s Name, Tab walks the page to its end — the synopsis, the notes, Add block — and leaves it for the rail, never the tree beside it; at 700 × 600, with the body scrolled so an open block’s top runs under the header, Tab from the block’s menu reaching the next block, never the header or its tabs; an open block’s own controls — its frames’ Prompt cards and Add a place… — counted as the block’s while Tab walks out of it to the next block | | packages/filmopen_format/test/platform_file_test.dart | the catalogue’s platform files (Project Specification §14.6, §14.9): the bundled index’s eighteen platforms, the first version’s three first, then xAI, dictation’s second speech service, Anthropic on its own key, Gemini on an AI Studio key, ElevenLabs, Atlas Cloud and local Wan2GP, the nine supported and every other pending with its obstacles; every listed file parsing with no issue under the id it is listed with, the supported remote ones carrying what Provider keys needs, and Wan2GP local on port 7860 with no credentials or auth header; the README platform summary and these testing rows naming Wan2GP with the current platform count and two local rows; a check’s rejected as its whole list, 401 and 403 where it writes none, a list that does not read leaving the check out, and xAI’s and Google’s bundled checks counting 400; a file that cannot be used reported by code and never thrown (not JSON, a missing or mistyped field, an unknown kind, a key platform without credentials or with a placeholder no credential fills, a credential id that is not a plain token or repeats one, a header that is not Name: value, a keychain other than filmopen/<id>, a base URL over http or off its hosts, another id), a bad page URL leaving the file usable, and a check that cannot be used (a method that is not a token, an http or unlisted URL) leaving the check out and the file usable; credentials only over https or wss to a listed host; paths — prefixes matched by whole segments, a host it does not name taking any path, a path that cannot be made plain refused badPath before any match (read raw where the caller has the text, and as sent where it does not; an escaped % among them), a paths naming a host hosts does not, a prefix that is not plain, a value of the wrong shape, an empty paths and a host named twice each making the file unusable, a verify.url outside them leaving the check out, and every bundled file’s verify.url and every access row’s endpoint passing its own file’s paths, read from the catalogue; the header filled from both fields of a two-field platform; an index status other than pending read as pending, and a listing without its file, name or kind, or with one of the wrong type, left out; a *. host standing for exactly one label before its domain, only at an endpoint a provider resolved and there within the entry’s paths — never two labels, the domain itself, a look-alike or http — and never for an address a plug-in names; a * anywhere else making the file unusable | | packages/filmopen_platform/test/credential_store_test.dart | the credential store’s seam (§6.7): nothing installed failing closed; the memory store round-tripping a value, counting every call and failing when told; the device store running one call at a time, in order, and turning an operating-system failure into CredentialStoreUnavailable with its type only, the next call still running; a platform failure’s code (KeyringLocked, and a Windows failure’s HRESULT) in its log line, the stored value nowhere in the log; a native write ending after its caller’s timeout still holding the queue, so a later write lands after it; behind a native call never answered, a queued caller failing closed as timeout without its call running, and a call after the stuck one ends running; the inventory and its guard: a read logs found and never the value or its length; seven names expected and every read absent refuse a write emptyStore and leave the item untouched, as does a protected file that reads as an empty map; a fresh install seeds an empty inventory and writes, the first run with the door seeds it from the store’s names, the first read finds a lost name absent; a Remove takes its name out, so an empty store then saves; a delete is never blocked; starting again lets a save through while the other names stay absent; a name that reads again clears the empty store; a Linux failure logs the phase its message names, not the message; a store that returned only some of the names refuses a write partialStore, naming what is present and missing; a delete names its caller and the pid, every call the inventory before and after and the store’s names, the first the startup line; an inventory file that does not parse is seeded again; a key the person removed is never said to be missing, starting again keeps the names still held and a later loss of one is still refused; another process’s names in the file are kept; a process whose view of the inventory is stale sees another’s names before it writes and refuses over a lookup that missed; a reset keeps a name another process added; two isolates saving the inventory at once never leave it unreadable; an inventory file that does not parse refuses writes until starting again, which keeps every name held | | packages/filmopen_account/test/account_keys_test.dart | the account’s names against the door (§6.6, §6.7), the library’s own client against a stand-in server: a key entered before any account stays byte for byte through a sign-in, a sign-out, a sign-in again and a refresh the server rejected, the deletes the account’s own names alone, the rejection logged with its status and code; a refresh with no network leaves the session as it was, each try logged; a captive portal’s redirect and a proxy’s page answering a refresh are not the auth server: the session stays; a gateway’s JSON 403 ({"error":"Forbidden"}) keeps the session; the auth server’s legacy invalid_grant still signs out, the session alone going | | test/no_delete_all_test.dart | no file under lib/ or a package’s lib/ calls deleteAll (§6.7) | | packages/filmopen_platform/test/key_verifier_test.dart | the key verifier’s seam (§6.7): nothing installed checking nothing and sending nothing; the stub answering by how a fake value ends | | packages/filmopen_keys/test/http_key_verifier_test.dart | the check’s request against MockClient (§6.7): a 2xx verified, with one request to exactly the check URL carrying the key in the platform’s header and its other headers; 401 and 403 rejected, and any other status not checked; the bundled Google platform’s 400, its answer to a wrong key, rejected; a platform’s own refusals, the statuses its file lists and those alone, and the bundled files — a wrong key rejected on xAI, which answers it 400, where OpenAI’s 400 still could not check; a 302 not followed; a timeout and a failed connection; the request logged before it is sent, the answer with its status and text, a failed connection with its message, and the key in no line; the method sent as written, and a value dart:io refuses in a header answered as bad_value; a check on an unlisted host kept out of its file, a wss check refused, and nothing sent without a value | | packages/filmopen_keys/test/provider_keys_test.dart | the keys’ controller on the memory store and the stub (§6.7): Save checking a value with the platform and storing one trimmed JSON object under its slot’s store name, filmopen/<owner>/<slot> where the platform accepts it, and replacing a stored key; a refused key and an unanswered check, neither of which reaches the store, both keeping their code for the line under the box; a platform with no check, stored unchecked; Remove deleting that name alone; a two-field platform stored as one entry; an unusable store changing nothing, without throwing; the states in memory for an ephemeral store and in the preferences otherwise, read back without opening the store; log events carrying the platform and a code only; no last four for a short value; one action per platform at a time, recorded for the cards, another platform not waiting; a verifier that throws, which could not check; a value cleaned of invisible characters, and one no key could hold refused; a refusal keeping its code; a preference that is not text, and a state the preferences refuse to keep; a state read from JSON; a platform with no verify checked by the owning plug-in’s verifyKey — accepted and stored, refused and not stored, a failed check not stored with its code; Save’s trail — its start, the check, secret and record steps and its completion after the written record, each with elapsed time —; a record write that throws after the secret is stored answering storeUnavailable, logged with its error; and a refused Save naming the step it stopped at with a safe code, a busy gesture logged as keys.busy, and a busy Save’s own start and refusal at start with busy and its elapsed time, no line carrying a value | | packages/filmopen_plugins_ui/test/plugins_tab_test.dart | Settings → Plugins over a runtime the test answers (§9.4): the web build’s one sentence; a plug-in that needs consent turned on only through Allow, Cancel leaving it off, the consent naming its keys and hosts, a 44 px Allow, turning off asking nothing; a plug-in’s page — a machine setting saved 700 ms after typing and through FieldRegistry, a number box saying inline that its text is not a number and saving nothing, an action running once at a time with its answer, a key not entered said as such, a grant; the preferred providers’ pull-down and its line when none provides, None: ask me shown where none is chosen — never the first plug-in as if chosen — and chosen to take a choice back, and the line saying when the preference is asked; the providers redrawn as the plug-ins change, the list staying on screen; an action that failed said in its own words or its code, in the error colour, never Done., and one done in its own words; the list, the consent and the page at 700 and 375 px in light and dark and a model setting’s choice at its longest; a value stored while a plug-in’s page is open reaching a box the person has not changed, and never one they have; a page a door asks for (openPlugin) opening, the request handed back once after the frame, and one not installed leaving the list; Configure on a plug-in low in the list and back returning to the same offset every time, three times without a scroll between and twice after a drag; Install from file answered writeFailed or failed saying Installing this plug-in did not work with the code, never that the file is no plug-in; reloadFailed saying the plug-in is in the library and its plug-ins could not be read again, never that the file is no plug-in; and a refused zip still saying it is not a plug-in FilmOpen can install | | packages/filmopen_plugins_ui/test/plugins_tab_test.dart (the tree of x.dependencies) | the list as a tree (§9.4): a parent’s two children under it and indented, each level alphabetical by name with the tag the tie-break; a child with two parents once, under the first by name, saying Also needs the other; a child whose parent is not installed a root naming the tag; a loop’s two plug-ins both roots, each with the loop’s line, and a third needing one of them under it; a child grey with Off while ComfyUI is off at 700 px in light and dark, its switch its own and the parent’s its own, the grey gone once the parent is on; the empty state unchanged | | packages/filmopen_plugins_ui/test/plugins_tab_test.dart (a plug-in’s own keys) | a plug-in’s page (§9.4): on, its two key slots two cards drawn by the builder the app hands in, the grants beneath, at 1000 px in light and 640 px in dark; off, Turn this plug-in on to enter its own keys here. and no card; with no key of its own, the grants alone; an action borrowing a provider’s OpenAI key refused for no key, its sentence naming General and the plug-in’s page; the package importing no keys package | | packages/filmopen_keys/test/provider_catalogue_test.dart | the tab’s platforms out of the one reader’s catalogue (§6.7): a platform whose card would repeat the tab’s identifiers left out and logged, pending ones counted; the bundled catalogue giving Gemini and Anthropic their key slots; a catalogue that could not be read gives the tab nothing, and the tab logs nothing of it | | packages/filmopen_l10n/test/job_labels_test.dart | unknown job states use the phase’s sentence without exposing the code or server words; job actions use localized labels; recordNotWritten said as its own sentence; a render saying where it is by its own phase and why it ended by its own code in a render’s words — the host’s refusals, a closed application, the contract’s unknown as a render sent whose outcome is not known and never with its code, a render given up after a week, a plug-in’s own code as it gave it, a failure with no code the job could keep — any other code none of the render’s, and a job’s own words unchanged; a render done within one call Rendering… from the moment it is sent; a failure a paid service took a request of said with It may have been charged: Activity → Usage shows the cost. after its own sentence, and a mark with no code after it taken as the code it is; a producer’s job for a film with no folder another film replaced said in the insertion’s own words, never the transform’s; acknowledgementPending and journalEntryUnread map to their own render sentences; before-send binding-changed says nothing was sent without exposing its code; FilmOpen credit’s provider-refused, portal-busy and lost in sentences of their own; a lent render’s insufficient-funds, lending-unconfirmed and terms-conflict their own sentences and a bare busy the fallback; a job waiting for its film (projectNotOpen) reads Not attached yet — press Attach again when the film is open., not the writer’s sentence | | packages/filmopen_l10n/test/labels_plugins_test.dart | a plug-in call that came to nothing, in the person’s words (§6.11): no model, no entry, nothing on and able to run serving it (with the platform where one was named), ctx.ai.complete with no model and no text plug-in, several serving a model or several text plug-ins with nobody’s choice, a render still pending, an output that is not its mime, and a call on a plug-in not installed, off, on and unable to run, or offering no such function; Settings → Plugins built from the tab names; a reason with no sentence null; and a plug-in’s problem in its sentence — badCodeFile in its four cases and archiveTooLarge with the folder’s two limits from its args, 64 MB and 2000 files, never naming the code, a zip’s refusal without limits and a code with no sentence null — and, beside them, that the write refused because the film is gone is a sentence and never the code, by its own arm; recordNotWritten said as the job path says it; and upload, stage and embed, the doors the contract settles and this build does not answer, each with its sentence; and serverSession, a server started only from its own screen; FilmOpen credit’s provider-refused, portal-busy and lost in sentences of their own | | packages/filmopen_l10n/test/labels_media_actions_test.dart | why a media entry’s injected action may not run, from a code (§9.3): the seventeen local reasons — the analyzer’s ten and noHandle among them — and the eleven provider refusals each a sentence of its own and none the general one, Settings → Plugins named in the app’s words, and a code this version does not know said in general words, never as the code | | packages/filmopen_l10n/test/labels_servers_test.dart | the servers in the person’s words (§6.15): each phase, each refusal of the sessions with no code shown, each problem — the sessions’ and the host’s codes in sentences, a provider’s own code named as its refusal — an offer’s priority and its availability for one and many, and a server’s time in Usage; a server still starting, and the price of a render on a server; a route that runs through a platform plug-in naming it where its state is the reason, and the plug-in with no key saved, a key the plug-in it runs through may not use yet, and a plug-in it calls that is not installed; a render choice’s words where its route gives none — Variant and Background among them; a server its provider no longer lists as Not listed: whether it still runs is not known, with the time it stops by at the latest; timeout and cancellation with distinct exact sentences, the other host failures retained, and five capacity/quota refusal sentences distinct; a plug-in written for an earlier FilmOpen in one sentence on its card, as a refused call and as a route not ready | | packages/filmopen_l10n/test/labels_media_actions_test.dart | why a media entry’s injected action may not run, from a code (§9.3): the seventeen local reasons — the analyzer’s ten and noHandle among them — and the eleven provider refusals each a sentence of its own and none the general one, Settings → General or the plug-in’s page under Settings → Plugins — both where the key’s owner is unknown — and Settings → Plugins named in the app’s words, and a code this version does not know said in general words, never as the code | | packages/filmopen_l10n/test/labels_servers_test.dart | the servers in the person’s words (§6.15): each phase, each refusal of the sessions with no code shown, each problem — the sessions’ and the host’s codes in sentences, a provider’s own code named as its refusal — an offer’s priority and its availability for one and many, and a server’s time in Usage; a server still starting, and the price of a render on a server; a route that runs through a platform plug-in naming it where its state is the reason, and the plug-in with no key saved, a key the plug-in it runs through may not use yet, and a plug-in it calls that is not installed; a render choice’s words where its route gives none — Variant and Background among them; a server its provider no longer lists as Not listed: whether it still runs is not known, with the time it stops by at the latest; timeout and cancellation with distinct exact sentences, the other host failures retained, and five capacity/quota refusal sentences distinct | | packages/filmopen_l10n/test/labels_keys_test.dart | a key check’s codes to their sentences, a refusal’s sentence for a 403 and for any other, and the key boxes’ labels translated where FilmOpen knows the word, the platform file’s own otherwise; a use that asked no model named by its plug-in and what it did — Check for a status from the plug-in’s page or the developer page, an action by its label else its id, any other function by its name; a server provider’s seven functions and the four entity hooks named in words, a later function by its name | | packages/filmopen_l10n/test/labels_dictation_test.dart | Activity’s Usage’s names for the boxes a use was for, a project’s name as its Title, and its failure sentences without the popup’s Resume; a sentence of its own for every code a dictation gives, canceled and provider included, the two refused-key statuses sharing one, and an unknown code naming itself in the general sentence; a speech key’s sentences naming its provider’s page, Settings → Plugins → <provider>, and every other key’s Settings → Plugins alone; any other use’s failure said as a sentence — a render’s as The render did not finish (…), a plug-in call’s as It did not finish (…) — never a code bare credit_ws_<status> reads as the session refused with its status. | | packages/filmopen_keys/test/provider_keys_tab_test.dart | the key cards on their own, over the bundled catalogue (§9.4): General’s section — the explanation, then a card another package brings (leading) between it and the keys and none on the web build, then the app’s OpenAI and xAI, then the pending line — and the Default AI assistant’s OpenRouter and fal as its page draws them, four boxes in all, no owner’s header, xAI’s card with its How to get a key as the others, a plug-in’s cards gone with the plug-in and the app’s staying, every identifier once and no store opened; obscured boxes without suggestions, every disabled action’s reason, and Save ready as soon as every box is filled; a mismatched prefix warned about only once what was typed can no longer become it, and saved after Save asks, the box emptied, and the key on no widget and in no log line; a refusal and an unanswered check, each with what to do, nothing stored and the box keeping the paste, and then the same button storing it once the platform answers; a platform FilmOpen cannot check, stored unchecked; Remove asking first, with a 44 px confirm; an unavailable store saying Save could not be confirmed inline, the box keeping the key; the web build’s sentence; an unreadable catalogue; the links’ addresses, and a link that cannot be opened, each attempt logged as it starts and as it ends with its address, whether it opened and its time, a throw with its message and time; through HttpKeyVerifier on MockClient, a 200, a 401 and a timeout, with the checking line and every action’s reason while it waits, and each request to its own platform’s check address; no way to show a stored key; a card built again while its key is on its way to the store, Remove‘s question outliving its card, no undo bringing a key back, Save asking first and its cancel keeping the box, Enter saving, a value no key could hold, and a 403’s line; the longest lines, none cut, at 635 and 295 px, light and dark; the eye on a secret box: shows the key, hides it, a refused key stays shown, a stored one is not left on screen, and a box that is not secret has no eye; while a recording runs every box is hidden and the eye says so, the choice standing once it ends; the busy eye says why; a plug-in’s own platform given its card, the key checked by that plug-in’s verifyKey and stored under its slot, a file that takes no key given none; a plug-in’s key in its own words titling its card while Save’s question, what a save says, Remove’s question and what a removal says name the platform, never saying key twice, Remove’s body naming this key; a removal forgetting the last save’s answer, and a box’s answer cleared by a change of its text alone, never by its focus; a valid identity shown without a secure-store read; a refused final publication reporting unconfirmed Save even though secure replacement occurred, and a refused Remove giving Remove recovery advice without asking for Save; a Remove whose record cannot be cleared after its key went saying so with Remove disabled, never asking for it.; at 700 px a key its record names but the store no longer gives back reads Missing from this computer’s keyring, logged once, opening no store; the keyring line, light and dark at 700 px, says the store returned none of the keys and starting again asks first, a Cancel changing nothing; a key read as the host reads it (readStoredKey) that the store gives back nothing for is missing on its card, on an inventory seeded empty, no health injected | | packages/filmopen_keys/test/usage_tab_test.dart | Activity’s Usage section on its own, in a host’s scroll view (§6.7, §9.7): an unreadable log said so; UsageSection.refresh reading a record no change announced, the lines read kept while a held reading is pending; the log read once at the first build and again at the next; the web build’s sentence; an empty log; the totals by month and platform, newest first, a live session counted as spent and a waiting estimate as pending, a refused call counting nothing; each use with what and which box, when, the minutes, its state, a failed dictation’s sentence and its cost at the end of the Your Key column, newest first; the month filter; English decimal marks and currency; a call of a version this app does not know left out and said; an append showing at once, and another copy’s record when the section is built again; the file each box belonged to; the words pending and possibly charged explained where they are shown, and only there; nothing cut or overflowing at 635 and 295 px, light and dark; a use whose cost nobody said reading Cost unknown, the totals counting it apart with the line that says what it means, and Spent left out where nothing was spent and a cost is unknown, a pending estimate beside it or not; the widths’ test holding such a use too; each use saying where its cost comes from — an estimate, the catalogue’s price, the platform’s report — and the platform’s id of the call where any of its records names one; a use that asked no model named by the plug-in and what it did — Check for its status, an action by its label, a function run on the developer page or a server’s by its name, an earlier version’s use by the plug-in’s name now, a plug-in no longer installed by the tag its stem holds — never unknown, its cost still unknown, and a use that asked a model still named by its model whatever called it; a render’s use named by its model as the render dialog names it, its group and its version, never the catalogue id, and a voice kept said so. A voice conversation’s and its captions’ uses read Conversation · Synopsis and Conversation captions · Synopsis, an old record its raw id; the shared plug-ins’ card: an earning with a plus sign in green and a payment with a minus sign in the text’s colour, light and dark, each labelled and dated with its job, the totals and the net, a net below zero plain; a funded charge counted once — in this device’s Spent and never in the card —, under words true on FilmOpen credit as on the person’s own keys, the heading and the empty state never saying your keys; a month only the ledger has, chosen, showing this device’s empty state, no totals, the filter and the card; a log that cannot be read still showing the card; the signed-out, unreadable, empty and partial lines; earnings with no use on this device still showing the filter and the card; the rows kept while another month is read; refresh reading the ledger again with the log; the widths’ test holding the card too; a use on FilmOpen credit at 700 px: charged to your FilmOpen credit with its request, not yet settled by filmopen.ai, and each operation’s id a button that copies it, says so and logs usage.operationCopied, a clipboard refusal said too; the receipt’s id on the line; the copy’s start logged before its outcome; light and dark, in a section 700 px wide, a use on the own key costing in Your Key, its cell shaded, one on credit in FilmOpen Credits, the other cell empty, and one whose route names neither in neither column and said, nothing cut; the totals split the same way — the own key’s Spent $0.03 in Your Key, shaded, the credit’s Spent $0.19 in FilmOpen Credits, never added together, and the unknown route’s $0.05 in neither, said under them; light and dark, an own key’s $0.017 estimate and a credit’s $0.19 as Pending $0.02 and Pending $0.19 in their columns, and as Possibly charged likewise when the platform says neither call exists, never added together and nothing beneath; a use on credit not yet settled, with no estimate, counted 1 use, cost unknown in FilmOpen Credits beside the own key’s Spent, and an own key’s use of unknown cost estimated in a currency the month has no line in counted in Your Key | | packages/filmopen_l10n/test/job_settlement_text_test.dart | the attached-but-unsettled and same-film mutation-wait state codes use their own existing sentence in English and Spanish | | packages/filmopen_keys/test/usage_providers_test.dart | what Activity’s Usage reads (§6.7): the log read, and read again after this app appends a record; calls newest first, by the month they count in, and the totals as §6.7 says; the month filter starting on every month and keeping what it is given; no log installed reading nothing, without throwing; sharedMoney keeping the lending settlements and earnings that moved money — never a funded settlement without a job, a kind this version does not know, a hold or an amount of nothing — and adding them up, earned, paid and net; the ledger read for the month shown and again when it changes; a publish of the balance alone not reading again, a change of sign-in reading again; no reader installed reading as signed out | | packages/filmopen_sharing/test/sharing_targets_test.dart | manifest-to-target selection for Drive, Cloud and machine-local folders; the Cloud decision logged whole (film, identity, outcome, an invalid identity’s refusal) and only when it changes — repeated reads once, A→B→A, a changed invalid identity, Cloud→Drive→Cloud; Drive and folder decisions logged the same way — a Drive film without an id one noId warning asked twice, a folder film without this machine’s path noPath, each selection at info; no target for session copies, missing preferences or absent sync; construction reads no credentials | | packages/filmopen_sharing/test/drive_account_test.dart | preference hints without credential reads, no credential read on Sign in, sign-out, abandoned consent and a superseded sign-in leaving the signed-out hint; a sign-in’s and a sign-out’s driveAccount. lines in order — start, the lookups forgotten, the hint from and to, done with ms — and an abandoned sign-in’s start and refusal with no step | | packages/filmopen_sharing/test/folder_rule_test.dart | the folder rule on a file system of the test’s own, folders compared as resolved: folders outside the film — a link’s own target, another beside it and a folder beside the film named through .. — taken; the film’s own folder, one inside it and one holding it refused, each refusal with its reason (notFull, missing, filmFolder, holdsFilm), a path resolved through a link included | | packages/filmopen_sharing/test/sharing_model_test.dart | a share’s manifest sent in one job — the target’s listing after the first answered late, as Drive’s can be, and the manifest’s send held, no second pass lists it during the send and queues the manifest again (SlowListingTarget); a first share to a folder delivered there with no settle and a gesture slow to come back from its write, the folder kept before the write, and a share to another folder whose write is refused putting the folder kept before back; one reconcile per gesture, the harness’s binding’s, as the application’s; a sign-out while the held sign-in is refreshed, Google then unreachable, answering no with no consent page; a sign-out forgetting the Drive folders’ lookups, the next inventory under the sign-in after it asking for the film’s folder afresh, and a sign-in forgetting them too, with no sign-out between; manifest writes and re-reads, machine folder preferences, Drive folder lookup/create over an HTTP stand-in that answers Google’s token endpoint, every model notice — syncUnavailable, driveUnconfigured, signInFailed, signInRefused (a 401 and a 403 after the one refresh, with no second), folderUnavailable, manifestMissing, staleFile, driveUnavailable, filmChanged (said on the film that took the place), noViewer, writeFailed, restartRefused (a refused dismissal, a stop that does not settle, a send that offers no dismissal) and failed — explicit Share restarting cancelled jobs including durable records, serialized gestures and preference completion after the displayed film changes; a folder refused before any write where it is not given in full (whatever the current folder, and a Windows path without its drive), not there, the film’s own, inside it, holding it, its other spelling, a link to it, a path through .. into it or, on Windows, the extended-length spelling of the film’s folder, of one inside it and of the one holding it; a folder given in quotes or with forward slashes, and one beside the film, taken; ensureSignedIn — a held sign-in taken with no consent page and none held signed in, a refused one renewed by the consent page, Google unreachable or too slow going on with the late client closed, a sign-out during the refresh answering no with no consent page, a Cancel during the refresh answering no at once, and a second sign-in joining the first; a notice kept on its film; one model, busy while a gesture waits; the log of each gesture — a share to a folder’s start, its stages, the restart wait’s start and end and its timed sharing.done; a refused dismissal and a wait that times out ending the share restartRefused with dismissRefused or timedOut as the cause and the time it took; a folder that cannot take the film refused with the check as the cause and nothing after it run; a Drive share’s sign-in tried as held, its folder found with its id and name, the manifest; a sign-in cancelled at the consent page ending cancelled with its notice; a sign-out’s and stop sharing’s start and timed end; the dismissal of a cancelled send before a Share logged as it is sent (sharing.jobAction) and as it ends (sharing.jobActionDone), accepted or refused | | packages/filmopen_sharing/test/sharing_card_test.dart | Sharing states, account line, controls, tooltips, counts and cancellable sign-in at 375, 700 and 1200 px, light and dark; no credential reads while built; each state of the card at 375, 700 and 1200 px with nothing overflowing — not shared, the sign-in’s wait with its Cancel and the busy reasons, no Google client, shared on Drive, a folder unchosen then chosen, a session copy, no film; a disabled button’s reason — no Google client, no folder typed, no sync this session — and an empty username, default, asking for nothing; the model outliving the card with its wait, Cancel and notice; a refusal standing on its film only, and a session copy keeping a sign-in’s wait and Cancel, the cancellation in the neutral colour; the step under way said inline, with no film on screen too, and the waiting folder box’s reason; independent send and receive counts only while shared, including mixed, single-direction, cancelled and unknown-kind jobs, singular/plural wording and the unchanged send-count expression; recognized no-copy done outcomes excluded from received totals while unknown markers and other directions retain normal counting; restartRefused in its own sentence and the error colour; a folder that cannot take the film said why, above the account’s line. The view-only sync fixture exposes an empty arrival stream | | packages/filmopen_sharing/test/sharing_test_support.dart | shared fixtures for controlled credential reads, manifest writes, sign-in and Drive replies; a recording sync service exposing film-filtered views, recorded actions and an empty arrival stream; a real application binding connecting rereads to reconciliation, and folder targets with held sends or delayed inventory replies | | packages/filmopen_sharing/test/sharing_cancellation_test.dart | a failed share to another target preserves manually stopped sends | | packages/filmopen_sharing/test/project_record_test.dart | the account’s record by its kept id (§6.6), on a stand-in account and a record store that is held or fails: a fresh record kept before its create (a held save: no request until released) and confirmed after it; an id the store did not save never sent, on the first press nor the second, and sent once saved; a lost answer replayed by the same id, never a second record; a recorded id read back, then updated by id; a recorded id missing from the account, or a read that fails, refused with nothing changed; a replay’s stored record in another place moved by id, going on only on that move’s success; a replay under another username refused; a confirmation not saved answered markerNotSaved, the same id used next in the session (updated) and after a reload (replayed); a session copy refused noFolder; the three places; an unexpected failure logged by stage and type; the record’s start logged with the username, the tag, the provider, the location and the path as they are | | packages/filmopen_sharing/test/cloud_sharing_test.dart | sharing on FilmOpen Cloud: the username checked, the record kept then created, then sync written, in that order, and the state shown; a username not the account’s, signed out, or a balance known zero refused before anything is written; a record refused, unreachable or not saved, and a confirmation not saved, stopping before the restart and the manifest; recorded under another of the account’s usernames refused with no update and no manifest write, under the same one moved and shared; a stopped send dismissed and a stopping one waited for before sync; a refused restart and a manifest that cannot be written each their stage’s failure; an unexpected failure logged by stage and type; Stop sharing leaving the record; the trails logged | | packages/filmopen_sharing/test/cloud_sharing_card_test.dart | the card’s Share on FilmOpen Cloud and Record on … on a film with a folder, signed out, at 700 and 375 px, light and dark: present, disabled, each tooltip its reason, Google’s share as before, nothing overflowing; a zero balance disabling the share and not the record; a balance not known yet until the account says it; no viewer; a cloud film’s state and Google’s share disabled on it; Record’s outcome said on its own film only and Record disabled once recorded; a lost answer said as a failure and its replay as recorded again; a confirmation not saved; a refusal with its code, never as success | | packages/filmopen_sharing/test/cloud_choice_test.dart | the new-project dialog’s cloud block (§9.2): checked by default; every cloud disabled signed out with Login / Signup and the tooltips, Create’s reason FilmOpen Cloud’s, unchecking permitting it; a known zero with the red line and Top up opening the account page, a launch answering false or throwing said inline and logged (opened, returnedFalse, threw); a balance not known said, never a zero; a positive balance enabling FilmOpen Cloud, the first enabled in effect, a pick of Drive kept; Drive signed in in effect where FilmOpen Cloud cannot be; Sign in to Google’s wait and Cancel, then Drive enabled; the coming-soon clouds inert; the ⓘ’s paragraph; Login / Signup asking the popup with its reason; at 700 and 375 px, light and dark, nothing overflowing signed out, and at 375 px for a zero, unknown and positive balance; a Drive share ending with no notice and no Drive in the manifest — the real model over the in-process Drive, a sign-out while its sign-in refreshes — answering notShared; the account’s snapshot builder (accountSnapshotProvider) drawing a source’s change and a source installed meanwhile | | packages/filmopen_sharing/test/director_choice_test.dart | the director block (§9.2): signed out the box prefilled, Login / Signup, at 700 and 375 px, light and dark; default where none was chosen, an empty box default, an invalid entry its rule with the last valid kept; signed in the pulldown, primary first, the username in effect selected, the alias item last; a username not the account’s giving way to the primary; signing in at either button removing both and showing the pulldown, the names read once; a source installed meanwhile followed; a failed read with its code and Retry; an account with no username claiming its primary, a cancel keeping the box; a sign-out and a sign-in as another account reading the names again; a late answer for an account that signed out, or for the account before a direct switch, dropped and logged stale, the new account read; each decision of the director logged by its name, source and outcome — accepted, defaulted, kept last valid; Signed in, the director is never typed: reading, a failed read and an account with no name show it read-only, with Retry or the primary’s claim; the names are the account’s, read once (account.names) | | packages/filmopen_sharing/test/alias_dialog_test.dart | the alias dialog (§9.2): Checking… then Available enabling OK, 500 ms after the text settles, at 700 and 375 px, light and dark; a taken name and only the settled text checked; an invalid name never checked; OK claiming an alias, and the primary on an account with none; each refusal (alias-limit, name-unavailable, invalid-username, unreachable, another code) said in the dialog, Available gone and OK waiting; an unreachable check; an answer for a text typed over dropped (current: false); unexpected failures of the check and the claim logged by type and said failed; a refusal at 375 px dark; Cancel answering nothing | | packages/filmopen_sharing/test/pull_manifest_test.dart | A FilmOpen Cloud record’s manifest fetched with the installed token, verified and bootstrapped; the inert access sends nothing; an MD5 or length refusal leaves no folder; Drive’s lookup only reads, absent creates nothing, found bootstraps; an unconfigured build and an unknown provider refused before anything is asked. Drive refusing the lookup is said by Drive’s own code at the lookup, never as an unexpected failure; each stage’s start; the bootstrap’s tag and path in the log, the token never. | | test/activity_usage_test.dart | Activity’s Usage on the whole app (§6.7, §9.7): at 700 px, with a film and without one, the usage first, then Adding media, in one scroll view; a record another copy wrote while the project page was shown, with no change announced, read when Activity is shown again; a use in the log fitting at 375, 532, 700 and 1200 px, light and dark | | test/rail_captures_test.dart | not a check: where FILMOPEN_CAPTURES names a folder, pictures of the states the agent build has no fixture for — the GPU page with a server in each phase, a deployment genuinely under way (its provider’s answer held) among them, GPU’s two lines with a running server and with nothing (the drawer opened below 700 px), the rail’s profile in each balance state and loading — at 1200, 700 and 375 px, light and dark, set in the SDK’s Roboto and Material icons; elsewhere it skips and writes nothing | | test/watch_page_test.dart | Watch (§9.1): Tutorials and Featured works, in order, each an empty state saying what will fill it and that it is a placeholder, nothing cut at 1136, 635 and 311 px, light and dark | | packages/filmopen_render_ui/test/share_groups_test.dart | the Groups card under the audience block (§9.7a) over an in-memory CommunityGroups and Lending, at 700 and 1200 px, light and dark: two invitations to the person, one accepted and one declined; a member offered no Invite but Leave; New group refusing -x in the dialog with nothing sent, then making film-club, whose only owner is offered no Leave; Invite sending as the membership’s identity and the invitation listed as pending; Share for free adding the group to the audience with one write, its chip reading its name and the button then disabled; each gesture logged, the username rule’s refusal with its ms; no exception; the sharing read refused device-not-admitted and the card still shown, read and acting, Share for free disabled; two memberships of one group as two rows naming their usernames, each with its own Leave; the card read once when shown, once more when the app is resumed with the roster changed elsewhere, never on a timer, and once more when shown again, each logged with its cause; a group of the person’s own in the free list named from the card, an id the card does not hold Added on another device | | packages/filmopen_render_ui/test/share_groups_test.dart (a slow exit) | an exit whose first observer is awaited while the card is disposed: its hook is still asked, answers exit with no error, and logs app.lifecycle.lateCall {owner: shareGroups, event: exitRequested} once (§7) | | packages/filmopen_render_ui/test/share_audience_test.dart | the audience block (§9.7a) over a scripted Lending, a scripted community client (AccountProjects.name), an account source and a runtime with a names store: signed out and the inert source — the line naming the website, no control, no request; loading a wheel and nothing sent, a sign-in while open reading, a sign-out clearing; a read refused hiding the controls with the line and Retry, which reads again; own devices checked, disabled and saying why; the public box one PUT with the revision read, the website’s answer shown and not the change sent — while the write is held too —, the next write under the new revision; every control disabled and saying why while a write is held, the chip’s × with it; a name trimmed and lower-cased, looked up and added with one PUT, its chip reading the name and the store holding it; a name the username rule refuses — -ab and official among them — refused with no call and logged with the rule’s answer, a name not kept said, a lookup refused on the line; a name already listed changing nothing; an id never resolved reading Added on another device, removed by its ×, which is the node an agent’s tap reaches; terms-conflict reading again and showing the fresh answer beside the line without replay, another refusal keeping the last answer; the store trimmed to the answer’s list and not written where unchanged; chips, the box, its error and every line fitting at 351 px of pane, light and dark; official read with its reserved sentence and -ab with the username rule’s; a sign-in published through accountSnapshotProvider alone reading the audience, a sign-out clearing it | | packages/filmopen_render_ui/test/gpu_page_test.dart | the GPU page (§9.7a) over stand-in sessions restored from a journal: every phase listed with its lines — found, a stop owed, the lease —, Stop where the sessions can act, none where nothing is left to stop, disabled with each reason; a provider off and on with no session, Start following without the page being made again, and with sessions, Stop’s reason; Start through the offers dialog, a deployment listed as deploying with nothing to stop, then starting, the page’s sentence said; the badge’s count through a restore, a stop and the provider’s list ending it; counts for every phase, found and owed; a restore ending after the page is drawn; the projection letting go of its listeners; no sessions (the web) — no Start; with no provider on and no session, the reason on the page; the count the badge shows said on the page; a refusal under a row erased once its provider is on again; every row fitting at 1136, 635 and 311 px, light and dark; this computer’s ComfyUI: no row without a platform plug-in some comfyui model plug-in calls or that renders on comfyui itself, the row for fo-cui‘s shape — the platform and the render at once, calling nobody —, its states — off, enabled and open to check, checking, ready, the plug-in’s words, else what it needs is not there — following the record’s changes, of two copies the enabled one, the row fitting at 311 px in dark, and its link opening Settings on the plug-in’s page; the three tabs in their order, opening on Servers, the body switching on a tap, leaving GPU putting Servers back; Share my plugins signed out — the line and no control; at 375 px the bar scrolling to the third tab, nothing cut, light and dark; Stop makes its N shared offers unavailable counting the published offers of that provider and GPU offer, gone when none is published, absent with a second running server of the same offer and on a starting one; two stacks on one GPU offer each counting the published offers of its own stack, none where another running server holds the stack or names none, and the row’s Model stack; past its deadline and unconfirmed, the line, its minutes at the deadline, the badge keeping it, Stop asking its provider again until it answers stopped — a stopping answer keeping the line —, and with its provider off the line and how to stop it, every width fitting; arriving on GPU asking every provider’s list again (gpu-page) and the local render engine’s status (refresh), never a remote platform’s, once per arrival and nothing while staying, each logged with its reason, the plug-in’s words and a failed check’s code; a starting server its provider is still assigning a GPU to waiting for it in place of Starting, a running one not; Using remote plugins listing the offers this person may use — name, lender, per image, per another unit, free, their own device — read-only, at 1136 px, and at 700 and 375 px in light and dark; the empty state with none | | packages/filmopen_render_ui/test/share_tree_test.dart | Share my plugins’ offer tree and editor (§9.7a) over a stand-in runtime and render backend: the places — this computer’s ComfyUI ready, not ready after a failed Check or while checking, found as fo-cui’s shape (self) with its Add an offer or as the called pair (called, preferred), a cloud renderer alone or a platform nobody renders on comfyui with none, each finding logged, a running server ready, a starting one not, a server a saved offer names stopped with its offer listed, a cloud plug-in never offered —; a place with nothing to share; the editor’s way not ready disabled, the 8 GB way’s own resolutions alone, the name made from them, the price refused until given, Save writing one offer under a fresh UUID at 0.02; Edit keeping the id and writing 0.2; Enable changing that field alone; a refused write said in the dialog; a busy answer asked once more; Published following Lending.published; no Add or Edit where nothing renders or the place is not ready; turning an offer to published asking for the device’s name first, a cancel leaving it unpublished, nothing asked to turn one off or to edit one enabled; the tree and the editor fitting at 375 and 700 px, light and dark; shareServed — a running Fast server not running a saved Quality offer, one holding its stack or naming none running it —, and under a ready place whose server holds another stack No running server holds its stack, nothing more under a stopped place, at 375 and 700 px, light and dark; Published, no longer on this computer: only a published offer whose plug-in is not installed listed, Withdraw unpublishing it once and dropping the row, a refusal keeping it with its code, the website’s lending-unavailable said and not taken for signed out, a sign-out on the tab clearing the list, at 375 and 700 px, light and dark | | packages/filmopen_render/test/lending_route_test.dart | the route a lent job runs on (§6.11): the plug-in’s own candidate for this computer, the running session’s for a server, the stack set; none for a starting server or another GPU offer; the running session the first of its provider and offer that runs; a share only on a server holding its stack, a server naming none serving any and an ask with no stack finding any; lendingMatch‘s three outcomes | | test/gpu_badge_test.dart | the rail’s GPU badge and two lines on the whole app (§9.7a): the count of this app’s servers that may cost, not a found one, its node holding the count, the sentence and the two lines in the button’s tooltip after GPU, the lines naming the oldest running server, all within the 64 px rail; a press on it opening GPU; following two stops, gone at none while a found server’s lines stay; with nothing and the card never read, not detected with the room of two lines and the NVIDIA-only sentence; a long provider name one line, ellipsised, as tall as its state | | packages/filmopen_render_ui/test/gpu_status_test.dart | GPU’s two lines (§9.7a): each row of the owner’s order, each class before the next, an ended server no option; a card that could not be read claiming nothing — a remote offer shows, else not detected, never none; a failed lending read unknown; among servers, an unconfirmed old one before a newly starting one, unconfirmed whatever the phase, active, ready, unsure, starting, stopping in order, a running server missing from its list unsure and an unanswered create starting, waiting for a GPU ranked as a start, the oldest first; the local plug-in’s active job — its own route or a caller’s, no destination or a local one, never a server’s, a lent one, another plug-in’s, one over or waiting to be taken in —, ready and never read; a card’s short name; the lent eligibility as the render dialog decides; every read logging its offers as returned and each one’s eligibility, a read changing nothing still logging, a refusal and a late read failed, nothing read without a sharing plug-in; the provider logging gpu.status on a change of answer and not on a redraw, a cached offer judged again when its plug-in is turned off while another sharing plug-in stays on (no new read, the change logged once), an older read landing after a newer failed one dropped (still unknown), reading the offers once a sharing plug-in loads and on arriving at GPU, and a running unheld server past its deadline with its provider off unconfirmed; a sign-in reads the offers once (signIn), loading, a second authenticated snapshot and a sign-out reading nothing; the usable offers are those the ribbon counts, judged again when the plug-ins change, and logged; a sign-out lets them go at once and drops a read still under way; a sign-in read refused device-not-admitted read once more when the device’s registration lands (deviceAdmitted), a funding change before the refusal, before the registration or after the next read reading nothing | | test/activity_sign_in_test.dart | on the whole application, on Share: a row’s sign-in waiting inline, with its Cancel, at 375 and 700 px, no dialog; Cancel sending no action and a consent after it signing nobody in; Back changing nothing, and a consent that answers sending the action; Share’s Cancel stopping the wait the card started and the card’s stopping Share’s. The held-send fixture exposes an empty arrival stream | | test/sharing_startup_test.dart | the whole application and General Settings construct Sharing without any device credential read; the application sync factory, binding and lazy target resolver reconcile an unshared film without reading credentials | | packages/filmopen_l10n/test/sharing_words_test.dart | the counts in the singular (sharingSendCounts); every Sharing sentence and interpolation, the refusals and the step under way among them | | packages/filmopen_l10n/test/activity_words_test.dart | a full Drive and a changed upload position said as tried again while the sync tries, and asking for Retry once the send needs a person; Activity’s section, empty-state and action sentences; every code a send can carry — a full Google Drive’s among them — with a sentence of its own, read for a send only; a send’s name taken in the target’s words and an addition’s in the film’s; the sync’s unavailable, busy and signInNeeded in an addition’s words for an addition; unknown and retired codes falling back to the phase’s sentence — a send’s for a send — without showing the code; the sync’s unreachable said as unavailable is | | packages/filmopen_l10n/test/sync_labels_test.dart | every send and receive code mapped, with exact new sentences, conflict actions and receive-count plurals; direction-specific invalid-transfer and phase fallbacks, shared target and hold sentences unchanged, mismatch retry versus attention words, paused/stopping/cancelled/waiting states preserved, and additions retaining their own words; both no-copy completion sentences applied only to a done receiving job, with unknown markers ignored; FilmOpen Cloud’s codes, noBalance and corrupt honest in each phase, the account’s sign-in sentence on a cloud film and Google’s elsewhere; noToken reads as a refusal | | packages/filmopen_automation/test/settings_page_test.dart | Settings’ pages as set_tab finds them below 700 px of window (§9.4): at 532 px set_tab usage is not_found at once, the pull-down of pages never opened, Usage being no page of Settings | | packages/filmopen_automation/test/scroll_test.dart | vertical semantics scrolling (§4.3): lazy and disabled targets down and back up without activation; zero actions for an existing target; wrong direction, action budget and missing target termination; tree/page scope separation; ambiguous lists refused before moving; horizontal wrappers ignored | | packages/filmopen_automation/test/settle_test.dart | the agent host’s settle on one clock, frames pumped by the real time passed (§4.3): a tap beside an indeterminate spinner returns well under one cap, both its waits ending stable and logged (agent.settle, agent.settled with their fields); a 200 ms slide whose semantics leave at its start, as the drawer’s, finished; set_theme finished, a colour that follows the theme with an animation of its own included, ending idle; beside a spinner a tab slide and a lazy scroll still waited for | | test/agent_host_test.dart (the picker’s answer) | pick_files on the agent build’s host (§4.3): a relative path, a missing file and a folder refused bad_args / paths and logged agent.pickFiles.refused {path, reason}, nothing held; a picture held, then replaced by a cancel, logged agent.pickFiles {paths, count, replaced}; the answer taken once, null after | | test/agent_mouse_test.dart | the agent’s mouse on the whole app (§4.3), at 1200 px: click in the real tree — plain marks the anchor, shift the range, control adds a row, logged agent.click {id, keys, x, y, ms} and agent.keys.up {reason: done}; on the Script page’s Contents a click marks and stays on the page, a second plain click beyond the double-click time opens nothing, shift marks the range; a key another input holds refused as keyHeld and left held; a row not on screen answered false, no key pressed, logged agent.mouse.notFound {reason: absent}; drag at the upper and lower of a scene placing the row before and after it, logged agent.drag {place, steps, x0, y0, x1, y1, ms}; three marked scenes and a fourth dragged at a folder’s centre moving into it in the tree’s order with one publication, the marks cleared; a drag to a row not on screen not_found naming it, nothing pressed; a drag from a row scrolled out of the tree but still inside the window (thirty scenes, scene 1 to scene 24) not_found naming the source, logged agent.mouse.notFound {reason: hidden | outsideScrollArea}, nothing pressed, nothing moved; a drag from the row just above the tree’s list, shown flush with its top and pressed in the tree’s own drag-scroll zone, driven at 16 ms frames so the tree scrolls under the pointer, refused / targetMoved before the release, logged agent.drag.targetMoved {dy}, the pointer cancelled, nothing moved | | test/agent_scroll_test.dart | the real Settings General list at 375 and 700 px: a control initially absent is built by scrolling, then the handle is reached again above; no Flutter exception | | scripts/tests/test_scroll_reach.py | runner reachability: exact visible identifiers, hidden targets, down then up only after not_found, scoped tree reach, no activation, and failures instead of below-fold skips; a built control its own scope leaves hidden looked for again in the page’s list — an entity’s body, or the tree for a tree row — since Flutter’s jump to a control can leave it reading as hidden on screen, and a refusal or an explicit scope never widened | | scripts/tests/test_replay_clock.py | the replay’s comparison, the clock aside: the header’s created and updated and every picked_at and set_at, and a visited compared by its epochs and not its instants, a look at another epoch or none being a difference | | test/settings_tabs_test.dart | Settings’ three pages on the whole app (§9.4): wide, a list beside the page with no tab bar and nothing to expand, General first and chosen with how keys are kept, without text model, speech service or a key box; Text and Speech service on Models, without opening the store; Configure on the speech service opening its provider’s page under Plugins, or the list alone where the provider is not installed; no Provider keys, no Usage, and back; the semantics’ tabs naming the page shown; a page asked for from elsewhere, the list following; a tap through the semantics on a page’s tab opening it, as set_tab does; narrow, an ordinary labelled pull-down above the page with the same three and no tab bar, a click anywhere on it opening its menu and choosing nothing, the menu choosing Plugins, and its value read as the state’s tab; a resize across 700 px keeping the page chosen and what was typed on it; General’s list the scrollable holding its cards; Settings opening on General again after it was left on Plugins; Language reading English, held, drawn as the microphone’s pull-down is, its tooltip saying that other languages return after development and a press opening nothing; a Spanish preference an earlier build left in the store before the app starts read as stored, kept in the store and the app reading English, and a Spanish system language reading English; every page at 375, 532, 700 and 1200 px, light and dark; at 375 and 700 px, light and dark, the username box refusing ab and -abc with the username’s rule, wrapped, the last valid username staying in effect, and a 32-character one taken; a page’s name wrapping inside its row, never cut; Export encoder at 700 and 1200 px, light and dark: Automatic until Software only is chosen and stored, its helper wrapped, nothing overflowing; a choice the store refuses said under the card as holding for this session only; General’s cards rebuilt for the settings they show — verbose logs rebuilding the log’s card and not General’s list, the identity, export encoder or library card, the theme rebuilding General’s list; the Development card shown only in a build with development mode; at 700 px, a write of development mode’s switch the store refuses said under its card, the switch holding for the session | | packages/filmopen_format/test/money_test.dart | money as exact decimals (§6.7): a JSON number read exactly from its text, exponents included, and nothing else taken for one; amounts rounded half away from zero to twelve places; a cost at the catalogue’s price times its units; a reported cost below zero or with more than twelve places being no provider cost; a money object with a sign, an exponent, other than twelve places, another scale or no basis being none | | packages/filmopen_format/test/catalogue_entry_test.dart | the catalogue entry reader (Project Specification §14.7): an entry’s id, kind and access rows with their prices; an access row without model_id or with it null kept, marked or unmarked, and a misread ID left out with wrongType; two prices for one unit, or two rows on one platform, read as no answer rather than a guess; an entry that is not JSON, not an object, names a field twice or lacks its id, kind or access, not read; the bundled live-transcription entry read at OpenAI | | packages/filmopen_format/test/catalogue_entry_test.dart (placeholders) | an access row’s placeholders read, absent where the row names none, and one that is not text reported wrongType with the row still read | | packages/filmopen_format/test/catalogue_test.dart | the one catalogue reader (§6.7, §6.11): the listings, every platform file pending or not, and each entry once in the index’s order; what cannot be read or used a problem with a code, and a read that threw with its message; an unreadable index an empty catalogue with the one problem; an index that is not an object said so; entry issues retained by safe code and field beside unusable, a wrong-typed price leaving its entry readable; the bundled catalogue reading Kimi K3 and DeepSeek V4.1 Flash as OpenRouter text models | | packages/filmopen_state/test/catalogue_provider_test.dart | the catalogue’s read as an operation (§6.11): its start, each file that could not be read with the bundle’s own reason, and catalogue.read with the listings, the counts and the elapsed time, an index the bundle cannot give included | | packages/filmopen_format/test/catalogue_members_test.dart | an access row’s render and a price’s match (Project Specification §14.7) decoded, render false where absent, and a wrong type of either reported as an issue, granting no admission and no price | | packages/filmopen_format/test/match_price_test.dart | pricePer: a match a textual subset of the call’s settings; a miss unknown, never the least; prices without match priced as before, by the least; used images at the single matching price, a miss or several matches unknown, legacy megapixels and resolution prose unchanged; the bundled Atlas Cloud rows — Seedance’s first frame sent as image, a clip priced by its resolution at the platform’s default sound, a resolution no price names unknown, a row priced only at 480p giving no 1080p estimate, and Wan 2.6 priced at 720p and 1080p and at no other resolution | | packages/filmopen_format/test/voice_samples_test.dart | a character’s voice of §9.1: a sample’s binding read with a platform and ids of the grammar and written back with what it has, one of another shape none; the active binding per platform, the pointer to a live sample — kept when archived — and one naming no live voice sample ignored, never another in its place; the previews waiting and an id only ever a preview’s; keeping a voice writing the sample’s id, the active binding, the pointer and words on its entry and legacy character field, with no prompt, in one change, and refused, the document as it was, where no live sample is named, neither a readable binding nor a provider is given, or the voice is of another shape; deleting the sample clearing the pointer, an emptied voice going, archiving keeping it; uploaded samples kept with a provider and no preview id, A/B words kept separate and unknown words never borrowed, existing provenance preserved, entry text/binding round-tripped; and copy-left carrying whole new samples with their words, preserving held entries’ own words, and carrying the pointer with the media card where the left holds the sample, or the copy brings it, and leaving it as it was where the left holds it deleted, elsewhere or its voice is of another shape | | packages/filmopen_format/test/reference_analysis_test.dart | what a description writes into a character (A.1): a picture’s leaves trimmed, a null, an empty text or an empty list telling nothing; anything named beside the leaves — a name, an age, an outfit, a binding, a relation — refusing it at its path; a value of another type, a text too long or with a control character refusing the whole description; the clothing seen joining the notes as a paragraph, never default_outfit, and once; a recording’s leaves, pitch and pace as the vocabulary’s tokens, the binding and the pointer kept; Spanish words taken as they are and a token in their language refused; applied into a copy all or none, saying which leaves’ values changed and none where the file says it already, a leaf that would take away what the file holds refusing them all; the most recent upload by its import’s record, the last taken in first within one, of two in one second the later record by its id, whatever order the tiles stand in, never a render’s take, a sound, a file placed by hand, a deleted or archived one, or one whose record is gone or says no time. A leaf beside the projection’s — a name, an age, a binding, a dotted key, a null extra — refusing the whole description at its path. | | packages/filmopen_format/test/usage_record_test.dart | the usage record of §6.7, version 2: a started record; a later record naming the first in ref and repeating its fields, while v, id, at, status, ref, app and error are its own; a record version 2 does not allow refused as the app builds it; a cost written with its basis beside it, the money’s own where the writer names none, and a started record with none; a cost nobody knows kept with its units and no cost, repeated by the next record and replaced by a cost found later with its own basis; a basis that is not its cost’s, an unknown basis with a cost or with no units, and a basis with no cost each refused as built; a line with a cost and no basis, or a basis that is not its cost’s, skipped by its field, and a version 1 line skipped with its chain; a call not yet ended carrying a cost with its basis but never an unknown one; an unknown cost read by the units its line wrote though this reader knows none of their names, written back and carried on by the next record; a record’s time kept after the chain’s latest, even under a clock that does not move; ids as random version 4 UUIDs in lower case; a line that is not a complete record skipped with its reason, and fields a reader does not know kept; a record of a version this reader does not know naming its chain, which is skipped whole; a record’s JSON read back as written; a call nothing prices starting with no estimate — written and read so, a later record keeping it — counted as a cost nobody knows while it runs and once it ends with its units, never as money, and a call not ended never given the unknown basis; a call on credit ended charged with its operations, or pending naming the operation it waits for, both round-tripping; pending without an operation, and charged or operations off filmopen.ai, refused; a malformed operation skipped as operations | | packages/filmopen_format/test/prompt_context_test.dart | shared prompt resolution (§6.11): speakers absent from cast receive default outfits; cast outfit wins; empty cast epoch uses scene epoch; characters resolve their default outfit and outfits their wearer at their own epoch, with reference reasons/outcomes | | packages/filmopen_format/test/visual_style_test.dart | a film’s visual treatment (§5, the Project Specification §8.7, A.11): the leaves a reader takes of a profile — absent ones, a value of another shape and a token of no vocabulary left out, a palette taken whole and lowercased or, with a colour of another form or nine colours, not at all; the one prompt composition, the entity’s words first, either alone where the other is empty, the primary leaves between them as Camera: … in their order and in English, a blank one and a leaf no prompt names adding nothing; the primary five read as a person’s words, an f-stop none of the older scale’s; a description retaining them through the shared bounded text rules, each primary leaf tested for null/blank, the 4,000-character boundary, wrong type and control characters; what a description writes, all or none — a null or an empty palette telling nothing, a token of no vocabulary, too many colours, one not #rrggbb, a text too long or with a control character, or a value of another type refusing it with its path; the preset a text leaf, trimmed, no Style’s, never composed into a prompt; a description’s preset, of any shape, never written: a leaf beside the treatment’s, a preset included, refusing it at its path. | | packages/filmopen_format/test/usage_totals_test.dart | the chains and totals of §6.7: each chain counted once, by its counted record, as its status says; the counted record the one with the latest at, and on a tie the greater id; a correction carrying the counted record’s status never reopening a call; records whose first record is missing counted as one chain, in the month of the earliest; a chain counted in the month of its first record; a chain holding a record of an unknown version left out whole; months newest first, then platforms and currencies in order; a call whose cost is unknown counted apart as a number of calls — a paid call that then failed among them — its chain counting no money, and never as spent or pending; one with no estimate joining its month’s line for the platform rather than making a line of its own | | packages/filmopen_store/test/usage_log_test.dart | the usage log on disk (§6.7): two processes appending under the lock, leaving 400 distinct records, no broken line and one device id; a write waiting for a lock another process holds, and giving up after its time with lock_timeout; a last line cut short getting a line feed before the next record, and skipped and reported once; a record of an unknown version leaving its whole chain out, reported once; device.json made once, its id kept by every log of the folder, and made again, through a rename, only when it holds no valid one; a lock file that cannot be opened failing at once as io; a folder with no usage yet reading as none; a later record retried until it is written, and a log unavailable altogether giving up; no log in use until an entrypoint installs one | | packages/filmopen_store/test/visual_style_test.dart | what applies to an entity of a film read as the app reads it (§5, the Project Specification §8.7): the project’s, then each folder’s from the outermost in, leaf by leaf, a list replacing a list whole, with the document each leaf came from; a folder’s own last; the folders the viewer’s, a fork of a season they picked passing on its own, official for another viewer and for nobody; a character outside the script taking the project’s; a project file taking its own, whichever version is in use, and inheriting from nothing; a leaf removed from a folder or emptied being the parent’s again; a scene’s Style through the leaves it shares, its lut never a leaf; a scene listed twice, or under a folder listed twice or under itself, taking no folder’s, and saying so; the primary leaves inherited as any leaf, a Style passing none of them, and the prompt naming each as it applies; the preset inherited from the project with its stem as source, a folder’s own overriding it, a scene’s Style bringing none | | packages/filmopen_dictation/test/transcriber_io_test.dart | the device’s WebSocket against servers of the test’s own on the loopback (§9.6): a handshake answered with a redirect not followed, ending as its status, the key reaching only the server asked; an upgraded handshake carrying messages both ways; a server that is not there being a connection that did not open, logged at the handshake with its URL, header names, error, code and operation, never a header value. | | packages/filmopen_dictation/test/openai_transcriber_test.dart | a close under way ending the session without a code, even when the connection then fails or the time for accepting runs out; OpenAI’s live transcription over a StreamChannelController (§9.6): the session message exactly as §9.6 gives it, with turn detection off, pinned whole; a commit and a clear sent only while the session is accepted and open; a turn taken, a turn that could not be transcribed and an empty commit refused as the session’s events, and other errors after acceptance ignored, each failure logged with the platform’s words; a session turned down carrying the platform’s type, code, field and message as they came; text by turn, a completion replacing its own turn and no other; a refused handshake, a connection that never opens and a session turned down, each ending before it opened; a connection that drops after it opened ending the session with its minutes counted; a session never accepted giving up after its time; no transcriber until an entrypoint installs one; the scripted transcriber answering frames with turns, and a commit with the turn in progress, or with a refusal where there is none The upgrade carries exactly the headers it is given and none of its own; the socket’s opening and its first event logged by the operation, a type the parser does not know as it came; an unexpected failure at the connection and on the stream logged by its stage, type and text. | | packages/filmopen_dictation/test/xai_transcriber_test.dart | xAI’s live transcription over a StreamChannelController (§9.6): the session asked for in the URL and the key only in the header; raw frames; text sent whole, a locked chunk in front of words that can change, and an utterance’s end under both readings of xAI’s pages, neither repeating nor losing words; a wait of its own for each commit, two at once, a finalize left unanswered and the platform’s own end; audio in flight when an end arrives; refusals, time-outs and drops, a refusal carrying the platform’s message for the log; an error in an open session logged with its message and changing nothing; an unexpected failure at the connection and on the stream logged by its stage, type and text. The upgrade carries exactly the headers it is given and none of its own. | | packages/filmopen_dictation/test/xai_settle_test.dart | the real DictationController on the real XaiTranscriber and a platform of the test’s own: a pause, then more words and Apply before the first answer is back, and settle waits for both turns’ words | | packages/filmopen_dictation/test/dictation_engine_test.dart | the speech services (§9.6): xAI’s setup out of the bundled catalogue, refused as OpenAI’s is; a slot of the app’s for every engine’s platform; the device’s transcriber telling an engine by its endpoint’s host; the choice Settings keeps, Grok only where no choice exists, unknown choices refusing and remaining exact, deciding the setup The website’s transcription pass-through speaks OpenAI’s messages by name. | | packages/filmopen_dictation/test/dictation_engine_card_test.dart | the Speech service card on Models: at 700/1200 px, light/dark, the copied API-key route, OpenAI-credit fallback without changing the selected engine, platform-wide own funding refused as a substitute for the fixed API key, and no credential read; each service by platform, model and price, the words as read; choosing one; 375, 532 and 700 px, light and dark; at 700 px beside Settings’ rail and sidebar (a 339 px box) and at 532 px beside nothing (a 460 px box), the selected label shown whole, its glyphs inside the box, and the open menu’s row neither left of the box nor wider than it; Configure under the pull-down opening the selected service’s provider page (fo-xai, then fo-openai once chosen) and changing no choice; nothing drawn where its served selection has no alternative; inline dictation on xAI reading fo-xai’s key, and its records naming xAI’s platform, entry, model and price | | packages/filmopen_dictation/test/dictation_service_test.dart | Grok default and explicit services retain one validated tooltip/card, exact endpoint and protocol, distinct fake app credential and Usage chain identity through final commit, the call’s values logged without its key and OpenAI’s session.update logged as sent; unknown/malformed nonempty choices retain their exact engine in route start/refusal logs; those choices, missing/pending/unknown-status listings and zero/one alternatives refuse without credentials, audio, connection or Usage; explicit repair, same-count availability refresh, pending catalogue without stale tooltip, safe catalogue failure, unknown and previously unavailable repair during loading/error, captured pending/active identity, known and unknown selection changes back to the original identifier, an initially unknown press refusing after a concurrent Settings repair, and real keyboard confirmation or dismissal, outside tap and arrow-toggle label restoration without a preference write, each restoration logged once, at the menu’s close (dictation.serviceMenu). | | packages/filmopen_dictation/test/speech_gate_test.dart | turns decided on the device (§9.6): a frame’s level as the root of its samples’ mean square; quiet committing nothing and cleared every ten seconds; speech, then 0.8 s of quiet, committed once; a click cleared and a two-frame name kept; a pause under 0.8 s keeping the turn; talk without a pause committed at 30 s and going on in a new turn; speech already under way when the gate starts heard as speech and committed, held or paused, with the room kept under its softest syllable; a voice with a narrow range heard through a minute without a pause; an even sound that stops committed, as a cough is; a steady hum learned within seconds, the turn it made meanwhile cleared as noise, and a voice above it committed, while in a quiet room the same level is speech; a microphone that hisses after a quiet one committing nothing; digital silence not making every sound speech; the turn in progress where the audio stops committed, cleared — too short, or as even as a tone — or nothing, and a reset forgetting it | | packages/filmopen_dictation/test/dictation_controller_test.dart | the session controller on the fakes (§9.6): the chain — started with a one-minute estimate and the key’s last four, running after each full minute, succeeded with six-place minutes, every later record naming the first; no key, a stored value too short or not JSON, and an unusable store, starting nothing; a refused microphone costing nothing; a refused session ending failed with its code and no cost; a dropped connection; a microphone failing while recording; Stop and Resume in one chain; Stop answering at once, and a session ending while the microphone stops keeping its end; a second Resume starting no second microphone; a session closed before it was accepted ending canceled with no cost, and one lost unaccepted with no reason ending failed connection; a close while the key, the microphone or the first record is on its way stopping it there, logging nothing, and nothing starting after it; a microphone chosen while listening taking over at once, and one chosen while stopped or while the session opens recording from the next start; Resume doing nothing while a session ends; a close while the log answers turning the microphone off at once; the app’s exit ending a dictation still listening and waiting for its last record, even from a platform that never answers the close; a platform file that takes its key other than as a bearer token refused; five minutes without speech, then a new chain with the text kept; the limit’s warning and end; an unwritable log stopping everything before anything is sent; the device deciding the turns: speech then quiet committed once and the quiet after it cleared, and nothing committed before the session opens; nothing committed or cleared once a session has ended, even with speech in progress; Stop committing the turn in progress, and settle waiting for its final text, at most three seconds, and not waiting again for what got no answer; a refused commit and a turn that could not be transcribed waiting for nothing, and no turn waiting past its session’s end; speech the device hears keeping a session open past five minutes, with a turn committed every 30 s of talk, and quiet ending it; a session turned down logging the platform’s codes, field and message; the key in no record and no log line, and the log saying, in numbers, how the device heard each session, each line counting only its own; the minutes’ arithmetic; the setup read from the bundled catalogue, refusing an endpoint off OpenAI’s hosts, one that is not wss, one with anything before the host, an entry with no price for a minute, and a missing model_id with the safe model refusal logged; the speech provider (§6.7) — with only an obsolete filmopen/app/openai record the press asks for fo-openai’s key and sends nothing, a key under filmopen/fo-openai/openai serving it; a provider missing, off, not allowed, not runnable or misdeclared refused as provider before the key is read, and one turned off during the read refused before the microphone On FilmOpen credit, with no key (§6.6): OpenAI’s protocol at the portal endpoint with the portal’s headers and a fresh v4 operation; the record filmopen.ai with no key, its running records with no cost and the unknown basis, the live cost null; the operation ended once, then its receipt read once, its cents the last record’s cost, unknown without one; credit 401, 402, 403 and 503 refused as credit_ws_<n>, the 401’s credential let go with nothing sent again, the others ended and read once; no credit no_key as before, a Grok without the OpenAI setup never asked; Grok chosen with no key and credit running on OpenAI’s setup at the portal, its records OpenAI’s, dictation.funding reason: fallback, selected: xai, a Grok key still Grok’s with no credit asked, and no credit no_key with the account’s reason; an End outlasting the close: the microphone off at once, the close bounded, the exit waiting for the one terminal record, a second close repeating nothing; an open that throws logged at the open; every line after the funding naming the operation, none a token; the level rising with a loud voice against a quiet room, falling in the quiet after it and 0 once capture stops, never logged per frame.; on credit the receipt’s cents charged with the operation, an unsettled read pending naming it | | packages/filmopen_dictation/test/dictation_ownership_test.dart | Fresh microphone ownership for dictation and commentary, refusal without competing audio or Usage, release only after physical stop, pending start and Resume cleanup, reentrant acquisition/audio/capture/session callbacks, duplicate operations, a failed or timed-out stop logged with its error and releasing the owner once without another terminal Usage record, the next Resume acquiring afresh, close() answering false after such a stop and true after a clean one, bounded Close with a slow physical stop, device changes, Close before the credential stage preventing the app credential read, and no post-close Usage access or credential/Usage-gate waits. | | packages/filmopen_dictation/test/dictation_recovery_test.dart | Transcript insertion and terminal Usage complete once while a slow stop is released at its limit, the microphone then saying the failure in the error colour. Gated physical start after field departure restores editing without a late write or session; unexpected start errors are observed on mounted and departed fields, the mounted one answered with the microphone-failure sentence. | | packages/filmopen_dictation/test/dictation_stretches_test.dart | a dictation’s cut, its commits and its stretches (§9.6), what a recording’s commentary is built on, every commit answered exactly once, in the order sent, with the words that ended there. cut: in speech, one commit sent and counted, the microphone staying on and the next frame beginning the next turn, its words the stretch; in silence nothing committed and the quiet cleared at every cut, though the log’s count of the device’s own clears of quiet stays at none; while connecting, stopped, ended or failed, once close() has begun, and from a listener of the count while it is raised, nothing sent. Stretches: the count rising when a commit is sent, before any answer; every commit given in the order sent, a text that came early waiting for those before it; a refused commit, a turn that could not be transcribed, and the commits a connection leaves unanswered when it ends given with nothing, and none after; settle giving what is owed before it returns, a late answer adding no stretch though the controller still takes its text; a stretch’s words trimmed, and a commit’s own words following the platform’s with one space; a second final text for one turn adding nothing, given or waiting. Turns of the platform’s own: one ended by itself with no commit waiting a stretch of its own and counted, one ended while a commit waited that commit’s words, and one with no words while nothing waits no stretch and not counted; with xAI, whose words come as its own turns, each commit given the words it ended. Across connections: the count going on after a Resume, a new connection’s turns never taken for an ended one’s commits, and a commit left unnamed when its connection ended no later one’s; a commit the platform never answers leaving the later stretches one early, a gap of the transcribers, which leave unanswered a commit an error of another kind stands for; a controller disposed without a close ending its stretches once it has given them all | | packages/filmopen_dictation/test/dictation_inline_test.dart | Captured inline insertion and range replacement through plain and observable editable targets; the target’s dictation.target lines — start, finish and commit of an insertion, the refusal and cancel of an edited box, a press on a read-only box refused — by code, box and elapsed time, the words the end’s (dictation.ended {text}); revised partial captions with actual semantics and no plain controller writes; one final commit, empty-final cancellation, external edits and late events, removal during setup or speech, duplicate stop, final semantics-frame privacy gate, room refusal; editable grapheme limits, read-only and source invalidation, controller/target replacement and restoration beneath an observing ancestor; protection of a renamed provisional semantics value through its restoration frame; failed setup, throwing or rejecting partials and source invalidation during publication; progressive long-caption wrapping at 700/1200 px; page message and dialog-local Open keys, one repair door per dialog, next-attempt cleanup and 532/700 px geometry; unchanged direct applyDictation spacing, room and formatter rules at the caret; a key kept only under filmopen/openai not looked for; the repair door labelled Open <provider> opening the provider’s page under Plugins (openPlugin), and a provider turned off refused before the microphone with the one sentence and the door, in a dialog and on a page, the choice of service kept On FilmOpen credit a refused session, 401, 402, 403 or 503, says its status, with no door to a key and no message. | | packages/filmopen_dictation/test/dictation_press_test.dart | Primary down starts immediately; short clicks toggle and held releases commit once, including pending setup; pointer cancellation and extra pointers; actual semantics activation without a duplicate; primary blue during pending Usage, delayed finish, concurrent cancellation and delayed device-start shutdown; stopping state and cleanup-completed shortcut tooltip; simultaneous pointer/key press ownership; Tab skips microphones; early Ctrl+Shift+Space dispatch, repeats, released modifiers, changed focus and target, ordinary Space and hardware observer visibility; the microphone a square stop while it records, its ring’s width following the voice’s level, back to the microphone with no ring after. | | packages/filmopen_dictation/test/dictation_visibility_test.dart | Retained fields cancel on rail navigation, covering routes, hidden pages and retained animated Visibility, identifier replacement and entity-tab transitions, ending audio and removing every caption; a refused tab transition keeps dictation. | | packages/filmopen_dictation/test/dictation_settings_card_test.dart | Settings → General → Dictation (§9.4, §9.6), the one place the recording microphone is chosen: the system’s microphone to begin with and the system asked nothing until the pull-down opens; the pull-down listing the system’s microphone and every one offered, a choice kept with its name, shown, and logged with its id and name; a microphone no longer offered checked as the system’s, the choice kept, and a second press while it opens opening no second menu; the menu opening at the pull-down, never at the card’s far corner; a microphone chosen with no name kept said as The microphone you chose, never by its id, and named again once the pull-down finds it offered; the pull-down named Microphone to a screen reader and one width whatever the name; no hold-switch checkbox, because click and hold are always available; nothing where no microphone is shown | | packages/filmopen_platform/test/device_audio_source_io_test.dart | Actual RecordAudioSource and unchanged record wrapper over a memory RecordPlatform: shared shutdown future, source-error cleanup and delayed first consumer, source failure during an externally requested Stop preserving its next deliberate retry, native Stop/disposal failures and deliberate recovery, concurrent and synchronous reentrant Stops, post-success no-op, first source code retained, normal trailing PCM, failure logs by their stable code with the native reason, and no unhandled future errors. | | packages/filmopen_platform/test/audio_source_test.dart | the microphone seam (§9.6): a frame is 100 ms of 24 kHz mono PCM16, 4,800 bytes; no microphone until an entrypoint installs one; the fake source’s two devices, the one a recording asked for kept and a device no longer offered falling back to the default; a fake recording giving a frame per interval until it is stopped, stopping twice harmless, silent unless told how loud each frame is, and then a square wave of that loudness; a microphone that cannot start saying why, once; a recording failing as a microphone taken away does; the framer cutting chunks of any size into 100 ms frames, keeping its own copies and passing errors on | | packages/filmopen_platform/test/webrtc_audio_peer_test.dart | the native WebRTC audio seam on injected SDK backends: inert construction, permission before peer creation, refusal without a peer, late permission after Close fenced until ownership drains, one audio transceiver, offer and answer ordering, exact device resolution, input-intent races, late native resources, bounded caller waits, ownership held until original disposal finishes before close, and a text frame past the old 1 MiB passing both ways. These fakes do not establish physical microphone release, selected-device capture, unplug detection or audible playback. | | packages/filmopen_platform/test/webrtc_audio_backend_test.dart | the pinned SDK’s method-channel boundary: Android software processing is selected before peer creation, native capture options retain processing flags and the chosen source without mutating caller constraints, and Windows initialization and capture constraints remain unchanged. Default and selected microphones are covered without recording audio. | | packages/filmopen_platform/test/app_paths_test.dart | the folder doors on a desktop: reports, jobs and sync on one base, reports created and sync not, each logging app.folder with the folder, the variable that chose it and the time, and a reports folder that cannot be made logging app.folder.failed with its error before it fails; the cleanup of earlier sample folders logging its start, the folder kept in use, each folder named before its removal and its outcome with its time — one the system refuses at warning with its path and message, the new folder still made — and its counts and time; the person names the folder, a file can be shown, and the two answers are one decision; the journal path uses the platform’s report location without creating it, and the web stub refuses a durable folder; a developer’s line that cannot be written logged developerLog.appendFailed with its path and reason and answered as a failure, the next line still written | | packages/filmopen_platform/test/incoming_links_test.dart | the link door: nothing installed answers nothing; the memory door answers its initial link to every caller and delivers what it is handed |

Where a test lives: with the code it proves — dart test in the pure packages, flutter test inside a Flutter package — unless it pumps the whole application, in which case it stays in the root test/; scripts/test_all.sh (or test_all.ps1) with no argument runs every suite. The gate on a Linux box is scripts/gate.sh: under one flock per box (FILMOPEN_GATE_LOCK, by default /tmp/filmopen-gate.lock), so that two gates never run their suites at once, it runs flutter pub get, flutter analyze, scripts/check_document_keys.py (zero offences), scripts/package_digest.py with the package pages then clean in git status, the scripts’ unit tests (python3 -m unittest discover -s scripts/tests), scripts/test_all.sh with the selection it is given — --full, --core or --tests FILE, one of which, or --no-suite to skip the suites, is required — and, once per --walk WxH and per walk: size of the selection’s lists not given already, the agent walk on Linux with an empty keys folder and no Xvfb or flutter run left after it; each command’s output goes to its own file under --log (by default a new folder under ~/gate-logs/; a folder that already holds a run’s evidence is refused, and nothing is written before the lock is held), a lock flock could not take runs no check, a git status that fails is not clean pages, a leftover process is logged by its pid and executable name only, and scripts/gate_summary.py ends the run with every command’s exit code, the suites’ counts read from each suite’s terminal record — a suite without one fails by name — the selection, and gate: PASS or gate: FAIL; each command’s elapsed seconds are on the console. Widget tests load projects in setUpAll because file IO does not complete inside a widget test’s fake-async zone. Tree rows draw label and detail as one rich text; match them with find.text('label detail', findRichText: true).

flutter analyze and flutter test must both be clean before a commit. Tests that need dart:io import the _io file directly (log_file_io.dart), because the analyzer resolves a conditional export to its stub.

The sync restart suite preserves closed-film checkpoints; the state adapter tests distinguish an open film without a target from closed/loading/other films without consulting its target. Payload and target tests verify bounded opaque payload identities and canonical folder hashing; target-transition tests separately pin hashed payload identities and the original identities retained in place keys.

Drive authentication lifecycle regressions in drive_auth_test.dart hold credential writes and refresh replies across cancellation, sign-out and a newer sign-in. The account tests prove a stale sign-in cannot overwrite the current signed-in hint.

The assistant suites run the host’s fixture catalog package and test-only provider adapters in native QuickJS, with invented credentials and HTTP stand-ins. They cover the catalog’s choices and offers, the opening’s context and bounds, each turn’s one bounded call and its Usage settled once, cancellation, staleness, the finalizer’s proposal, and logs that carry the text as it is and never the stored key; assistant_retained_test.dart holds the final payload to the catalogue’s output bound and one POST on the selected model and endpoint, writes a provider’s lines and missing strings under an assistant binding, and proves Apply’s fork of another author’s version in use. The four catalog, action, retained and voice-action harnesses normalize fixture-relative separators to forward slashes on every platform. They establish protocol behavior rather than live model quality or speech conversation support.

The voice suites exercise both exact realtime configurations, streamed PCM, device-position truncation, late events, device and transport errors, pending-start and pending-stop cleanup, deduplicated Usage and a cap given to a session without real credentials. Live-caption cases cover cumulative corrections, fragment appends, final-text protection and retained incomplete text. WebRTC cases instead prove one direct multipart signaling request with initial turn detection disabled, the configured semantic VAD and far-field noise filter with PCM/Grok settings preserved, turn diagnostics that carry the person’s words, the answer and the provider’s error whole and drop unknown events, preservation of early data-channel events, native mute and End, integrated caption identities, no PCM or second socket, and speaking state independent of generation completion. Failed signaling closes the peer without retry or exposing provider error text. Pricing fixtures cover exact modality/cache rates, missing and contradictory usage, session-time versus cleanup time and outstanding responses. Widget cases exercise each caption state at 700 px in light and dark themes. The agent build’s assistant fixture alone redirects application folders and reopens an absolute Windows preference filename, with MemoryCredentialStore and StubKeyVerifier; the product uses normal application state and native device credentials. The standalone Windows Media Foundation test (test_native/synopsis_voice_audio/README.md gives its commands) converts synthetic 44.1 kHz and 48 kHz stereo WAV files into 24 kHz mono PCM and checks frame count, frequency, amplitude and invalid input. Those checks do not establish live microphone, speaker, provider access or conversational quality. Only a person’s Start gesture in the product on a device can perform that acceptance.

Conversation suite	Behavior covered
`packages/filmopen_state/test/assistant_test.dart`	The assistant preference defaults without persisting; the text-model setting stores only the id, decodes legacy routes by model, preserves an unknown saved model, serializes writes, clears physically across restart and logs raw old/new values, reason, outcome, time and error message. The session over a scripted backend: frozen context, thirty model turns and Finish costing none, a context and a follow-up over 128 KiB sent whole with their size logged, blank and concurrent sends refused, the target an entity and a field with the old readers derived, the turn naming no retired protocol, a frozen source current while its file’s text is unchanged, the backend’s proposal id reaching the dialog, cancellation and staleness rejecting late answers, a backend’s throw failing the turn with `assistant.turn.failed` and its message, refunds only for an unadmitted turn, safe codes with no retry; the select/clear logging cases above; the history its record keeps (§7.4): the person’s words, a turn’s tool exchange and the assistant’s words in order with their `at`, the request to the host unchanged, a copy handed out; a turn failed with no words and one stopped after its tool keeping the exchange that ran
`packages/filmopen_state/test/assistant_voice_test.dart`	The voice service’s `note` is inert by default and reaches a service that writes it (§6.11a).
`packages/filmopen_state/test/project_log_test.dart`	the controller’s lines: `project.open`, `project.opened` (no name, the selected stem), `project.refresh`, `project.versionChosen` and `project.closed` with exact maps; a failed open as `project.openFailed {source, type, error}`; an outfit collision retried with the character and the error’s message; a pick failing after official as `pick.setFailed {target, type, error}`, the partial success kept; the folder and the stems as they are
`packages/filmopen_state/test/drafts_changes_test.dart`	The open drafts’ change stream (added, moved, removed — a second remove silent), `openIn`, and `writesSettled` fired once when the last tracked write ends with `writesPending` following the set.
`packages/filmopen_state/test/leaving_test.dart`	The binding’s wakes (`formLeft`, `formMoved`, `writesSettled`, a film without a target skipped), the foreground (coalesced lift after the binding’s own settle, a failed settle keeping the deferral, restore and one reconcile on return, a return before the settle lifting nothing), `transferring` and `unsent` from stand-in views, a real engine, and their films; `prepareLeaving` settling, lifting, reconciling strictly and waiting for document sends in flight only, a retry wait pending, a slow send pending at the budget’s end, one budget across stages, a slow resume bounded, a throwing lift answered at its stage, undo, an undo or a timeout during the settle never lifting, an undo before or during the wait answering incomplete, refused drafts, a film without a target; Close project bounded and preparing the leaving before the page closes; a switch, a created project and a screenplay import preparing the leaving before the source changes, a refused leaving stopping each with the film kept, a failed read-back preparing nothing, a superseded open undoing its leaving only while it is its own; over a real service, a form removed or moved whose last write is slow sent once with its final bytes, a send waiting for another form’s write going when it ends, a document skipped at submission submitted after it, the open form’s document sent on leaving, an inventory failure and a superseded pass making the leaving incomplete; over a real service, a change through `patchEntity`: a patched document goes while its form stays open, released and woken; queued behind another document; a parked `formOpen` wait resumed; held by a write in flight; typing after it dropped (`written`) before the typed write and held until the form is left, a superseded re-read included; an epoch declared on the project’s open form dropping its release; unchanged and rejected patches releasing nothing; a refused patch’s log carrying its stem and its code and no error object; `textChanged`, `closed` and `noTarget`; and a screenplay import’s log — its start with the name, path and parent, each stage and what it imported, a second import refused after its start is logged, a reader’s refusal with its code, reason and stage, a written folder that will not read back with the open’s cause; an unlisted target’s leaving answers the error’s code, not its stage, and carries the folder’s documents not agreed (`LeavingResult.local`), the manifest among them; its stages in order — settle, local, lift, reconcile, wait — the local comparison after the drafts and before the target, and read again once the wait ended, so the form the leaving sent is not listed; the slow last write entered in the controller’s record as the writer does
`packages/filmopen_state/test/media_availability_test.dart`	`MediaAvailability.ensure`: local at once; fetched following the job through a retry; failed with its code; `notAvailable`; a film no longer bound is never retargeted; the copy stops at the first failure; `backgroundPrepared` fires only for the current preparation `SceneMedia.ready`: a scene’s remote media asked for together, another scene’s left remote, the timeline built at once holding the clip and the music; a failed medium answered by name and code; nothing remote, nothing asked;
`packages/filmopen_state/test/sync_host_test.dart`	the transfer host’s driver (§6.14): idle shows nothing; an open form on a synced film shows at `inactive`, uncounted; held until the current preparation’s notice — a final write, an inventory still listed, a preparation with nothing to send, and an obsolete preparation’s completion releasing nothing; counted transfers update on a count change or a 5 % step, a retry wait still counted, none left hides; a job held for a sign-in is not counted; `resumed` hides; the platform’s timeout hides and is logged, its own stop afterwards not a second; a film with no target shows nothing; a failed start logged once, not retried; a platform without a host says so once; a failure the service reports after its request was accepted is logged with its stage, type and message and nothing follows it; a stop the activity reports is logged with its reason; exactly 5 points updates
`packages/filmopen_state/test/account_names_test.dart`	The account’s names (§6.6): read once per account keyed by its id; signing in sets the primary where the username is not the account’s, keeps one that is (its workspace too), sets nothing for an empty list or a failed read; the same account published again neither re-reads nor discards; another account or a sign-out clears and a late answer is stale; a refusing draft leaves the username; a pull-down’s choice goes through the one transition; an account’s leaving supersedes its pending change, signing out or switching while a draft holds it; the id never in the snapshot’s public form; never a name in the log.
`packages/filmopen_assistant_ui/test/assistant_widgets_test.dart`	Use the LLM: with enabled, selected Let the AI assistant decide first; local Qwen offered, model-id save and clear without a call, own-model override note absent; removed saved model guidance, usable models enabled and unavailable models disabled with reasons, non-text omitted unless saved; bounded scrolling menu, refused row not chosen, 700/1200 light/dark without overflow; each offer refusal has its sentence; the route chooser at 700/1200 px, light/dark lists Automatic and the decided provider’s routes, saves credit and its provider preference, clears the route while keeping that preference, retains an unavailable choice for clearing, and reports a failed save inline with the committed field value
`packages/filmopen_assistant_ui/test/synopsis_round_trip_test.dart`	The voice conversation’s Apply (§6.11a, §6.18), the one road left that proposes: a scripted session standing for the host and a real proposal planned by the exchange from the last user turn against a tiny in-memory film, applied through the real `applyImportProposal`; a place left during Finish, under review or during Apply, and the review’s log lines; an Apply that throws logged with its stage, type and message
`packages/filmopen_assistant_ui/test/assistant_dock_test.dart`	the dock (§9.1, §9.3): a full-height panel from 1000 px of window at the window’s end and a portrait at the upper right below it, its slide-out from the right closed by the scrim, each change logged as `assistant.panel`; nothing overflowing with the keyboard up; a drag on the divider resizing the panel within its minimum and its share of the window, the width remembered and logged at the drag’s end; crossing the breakpoint with the slide-out open and a chip chosen closing the slide-out and keeping the choice and the page; a live dictation ended by the slide-out’s close, its scrim and the system’s back, the microphone released, a late word reaching nothing, the chat and the text typed before it kept and shown again on reopening; on the synopsis the four groups in the owner’s order, a heading not said twice, the overview headed Overview beside the project rail, Activity’s rail action alone on Activity; the header and the picker by portrait and name, a disabled chip or assistant with its reason; the chat opening in the dock, dictated words shown in its reply box as they are spoken with no caption, kept there at Stop and sent by Send, the person’s edit keeping the box as they left it, a stale chat removing the live words, Close before Stop writing nothing to the closed chat and releasing the microphone, the slide-out widened to the dock before Stop putting back the box after the frame with no locked-tree error, held chats: an open answered after a move held and shown, a late open from a film since left released, and one answered while its film’s `closeAll` waits on another chat’s tool work, or while another film loads in its place, released with it (no chat held or live after), a move while an open is under way keeping both, overlapping opens both held and the one asked last shown whatever order they answer, a move of every kind ending none, two chats held across a move and shown by the switcher with their unsent text, the same action on two entities named apart in the switcher, by the entity’s name in the film open, else its id, a close of the chat not shown leaving the one shown and the X of the one shown showing none, a viewer’s change keeping the text with Send disabled, the dock’s going ending all; the move at a chat’s first change to its record for the chat shown from its gesture’s place, and none for a person’s move since, another rail or another chat shown, logged `session.moved` with why; a chat’s record opened showing its chat, an archived one none; a refused or failed open said in the dock, another assistant leaving the chats held; the conversation offered where the voices are shared; the three bands at 375, 700, 1000 and 1200 px with thirty turns — the actions in view above the transcript, the transcript scrolling, the box pinned, a reader scrolled up not moved by a new turn, a reply over several lines followed through the busy line, the box in view with the keyboard up —, the chat’s X ending it and logged with its cause, the conversation then saying what would fill it, the chat off the screen at once and its transport released only once the session’s close ends, a close begun on the ledger for `reviewed` or `film_changed` with no move ending the chat for `closing` (the quit’s keeps it, the next row) with one `session.close.start`, the dock’s own joining it, and a close the dock began itself noticed by no `session.closing`, a change the session could not record said in the chat in light and dark, `assistant.hide` closing the panel only; that empty conversation not overflowing a 300 px window, docked or in the slide-out; the composer — the box growing to eight lines then scrolling, the buttons under its last line, fewer lines at 375 px with the keyboard up or a 500 px window, the one button as Conversation, Send and a square Stop that cancels, Send greyed with its reason where no conversation is offered, a locked box keeping its text with no conversation, an over-long reply refused before the transport and logged `refused` with its code, each press and outcome logged, a Send’s with the message, a completed chat with the box empty still offering the conversation; set in Roboto, a field action with Apply refusing a too-large reply at 375 × 500 and at 375 × 800 with the keyboard up, and a chat without Apply refusing one or with a turn under way at 375 × 400, nothing overflowing and the box, Send or Stop and Apply in view; the microphone focusing the reply box, and a desktop click on it keeping that focus; the reply box’s microphone a square stop while it records; a chip lacking a key saying so, readiness for the selected action, otherwise the first ready funded route or credential refusal, and Add a key opening Settings → Plugins on the provider’s page, the slide-out closed first, logged; at 375, 700 and 1200 px an offer on credit giving the row Signed in, using FilmOpen credit., the selected funded route taking precedence over an unrelated missing key; the slide-out’s close a right arrow; the reply that streams, at 375, 700 and 1200 px in light and dark: no bubble before the first words, then one `assistant.partial` bubble above the busy line growing with each partial and followed to the transcript’s end while the transcript’s list is not rebuilt, a reader who scrolled up left where they are; gone with the turn, the finished message showing what the person saw; nothing overflowing. A form section’s group after the field’s, headed by the section’s title. The shortcut (§6.11a): an icon’s press opening the slide-out and choosing the chip as a chip press would, noted with `opened`; docked, nothing opening; an action not offered or offered disabled refused with its reason, the panel opened; no assistant active refused as such; a chip’s press said for the icons and not run again; a Send’s press logged with the message sent, a thrown open and a portrait that does not decode with their type and message; the conversation disabled away from the chat’s own page, saying why, `conversation.offer` logged at each change; Ask opening ready with no turn sent, noted `assistant.turn.notStarted`, its first call the question sent through the box with the film’s context, while another action still starts; a chat opened on Activity moving to the Project rail at its first change The note at 700 and 1200 px, light and dark: under the busy line, quiet, two lines at most, gone when cleared and with the turn, one `assistant.dock` line per change; `cutOff`’s sentence; a provider’s words after the code’s sentence, gone after Stop; a chat’s record headed Chat, a render batch’s Render batch; a chat whose record cannot be written at its opening not started, the dock saying so, `session.open` `unrecorded`; words whose record cannot be written not sent, the chat saying so, the words back in the box, `assistant.composer.restore` logged; words refused while newer ones were typed put back before them, neither lost; a close begun while the opening’s record is written starting nothing, `session.open` `closing`, the record closed by that close; the same with the opening’s write failing, disposed once and no refusal said. A change the model sent said not applied with its paths, then corrected, at 375 and 700 px.; a session that `asks` shows the dock’s question with no model call (`assistant.turn.asked`, reason `noSummary`) and sends the person’s answer as turn 1, the question before it At 375 and 700 px the seconds the turn has run show beside the busy line, `m:ss`, advancing with no note at all, counted from the session’s `turnStartedAt`, and go with the turn.; at 700 px a turn refused before it left for want of a key reads Not sent, never an unknown outcome, and Open Settings opens the provider’s page; Thinking… N s counting a silent call from its own start — 0 before the first call, the call’s seconds beside the turn’s, a dock rebuilt across the breakpoint counting on —, Waiting for the assistant… once the call has reasoned, the reasoning kept into the next call, the last landed create of this chat alone (not another chat’s, not a person’s) under the busy line, all gone with the turn and with a stopped one, one `busy.line` per change, light and dark
`packages/filmopen_assistant_ui/test/assistant_dock_test.dart` (the activity indicator)	chat A running while chat B is shown, at 1200 and 700 px, light and dark — A’s line and the references’ lines in the fixed header, kept with no chat shown, gone when all have finished, `assistant.activity.changed` at transitions only; at 1200 px: the header’s Stop ends A’s turn though B is shown and asks the engine to stop, logged requested and signalled, hidden once everything is stopping, and a second Stop does not stop a turn again; at 1200×800 and 700×800, 47 lines with nothing overflowing, the first line, the brain and Stop in view and the last reached by scrolling, Stop still in view; a turn that starts and ends before any frame logged both ways, `source: chats`; reduced motion stands the brain still; an unconfirmed stop stays, unpulsed, with its reason; every render job (§6.15), at 1200×800 and 700×800, light and dark: a render queued and one working with no chat — two lines (Waiting to render…, Rendering…), the brain and Stop, gone when they end; an Auto-generate line and its own job one line, `assistant.activity.dedup` logged; a reference and a sheet of one stem two identifiers (`<stem>.<place>`), the sheet’s, a first frame’s and a clip’s named with their group’s label; Stop asks the engine, then each job that offers Stop and is not Auto-generate’s, the jobs’ lines in `stop.requested` and each job’s `stop.outcome`, a job without stop not counted and one stopping read Stopping…; an unconfirmed job said with its reason, unpulsed, not stoppable, its Dismiss sending dismiss (never stop), a refusal said on the line, which stays, and asked again; Auto-generate’s unconfirmed line keeping its job’s Dismiss; the box reads Auto-generate pictures; at 1200×800, light and dark, the box’s local-route line scrolled to, and the band’s last chip at its end, lie whole inside the band; a call that answered tool calls alone reads Waiting for the assistant… while its tools run and Thinking… N s as the next call starts, `busy.line` at each change
`packages/filmopen_assistant_ui/test/assistant_dock_test.dart` (the quit)	an exit with a chat open, its exit observer heard before the chat’s text boxes and frames drawn before the dispatch goes on: the quit closes the session (`session.ended {reason: quit}`), the panel stays mounted (`session.closing {cause: quit, kept: true}`, no `session.ended` of the dock), and no listener is called after its dispose (§7, §7.4)
`packages/filmopen_picker/test/catalog_test.dart`	Schema-1 catalog resolution, file order, refusal codes and locations, cross-category ids, missing strings, choice parsing and the staged stock catalog.
`packages/filmopen_picker/test/picture_test.dart`	Deferred package and mocked HTTPS reads, encoded bounds and signatures, seam/status refusals, timeout, exception identity, safe logs and all stock thumbnails.
`packages/filmopen_picker/test/sources_test.dart`	Enabled target filtering, continued discovery after refused or failed catalogs, locale, counters, no picture reads and failures’ messages and missing-string keys logged as they are.
`packages/filmopen_picker/test/prompt_test.dart`	Localized prompt lookup, agreed missing cases returning null, refused catalogs and unexpected reads throwing, stage logs with the prompt, the stored reference and the error’s message as they are.
`packages/filmopen_picker/test/field_test.dart`	The closed control: its own choice before the inherited one and the helper only for the latter; Select Style for none, a missing source or entry and a malformed reference, each logged, a reference that is no catalog token logged as stored with its reason `malformed`; held with its tooltip where no source answers; locked; reread on the runtime’s changes, a slow earlier read never overwriting a later one; refused, failed and undecodable thumbnails; nothing written on building, rereading or disposing.
`packages/filmopen_picker/test/popup_test.dart`	The popup through the closed control: two builders’ sources and categories, the chosen item’s category first and its tile selected; the open category’s thumbnails only, held while open, one failure sparing the rest, no log line per good tile; a pick by tile; the close button and Escape answering nothing; Tab, Enter, the arrows and Escape as Flutter gives them; no overflow at 360 and 1200 px, light and dark.
`packages/filmopen_picker/test/full_view_test.dart`	The full view from a tile’s icon: the thumbnail, then the full picture; refused, undecodable and absent full pictures; Copy confirmed only once the clipboard takes the prompt, a failing clipboard confirming nothing, no prompt in the log; Use this answering the item and Close returning to the popup; no overflow at 360 px.
`packages/filmopen_state/test/assistant_catalog_test.dart`	the catalog reader (format 1, §6.11a) over the example catalog: the file’s members as written, the always action offered anywhere, Activity’s with its context, the project rail’s scope, the `pj` section’s pattern in file order, the synopsis field action with its finalize, models, and a hooks key refused as unknown, a `ch` action’s `this` needing a character page; a pattern’s path admitted where the exchange’s field-path grammar parses it with lower-case keys and filter keys (`cast[].character`, `blocks[].dialogue`, a filter’s value as written), an upper-case or malformed one refused `badValue`; a prompt and a finalize past the old 16 KiB read whole; a catalog past the old 128 KiB read and its bad JSON still `notJson`, 33 paths in an export line read and an empty list refused, nine models read on an action and in the catalog’s defaults; each refusal by its code and location. A form section’s action (`formSections`) read beside the fields with no finalize, offered on each of its fields after the field’s own, with no field named, and not on another form section; refused as a field’s would be — the plug-ins’ documented location `formSections#1[0].export`, a finalize out of place, an unknown key, an entity token out of place, an id used twice, a bad id, a value that is no list — and under a section that is no entity type an unknown key.; an action’s `effort` is `low`, `medium` or `high`, another word `badValue`, a number `badType`; `asks` a non-empty text
`packages/filmopen_state/test/assistant_where_test.dart`	where the person is (§6.11a): rail, section, entity and project derived from the app’s state; a field of the version the tabs show held, a hidden or stale form ignored and logged; another version or another tab clearing the field; an epoch overview with no tabs and no field; the rail leaving the project clearing the field and keeping the tab; the project closing or changing clearing the field and keeping the version the tabs show, whose field is admitted again until the tabs go, every line naming that version (`shown`); `stillAt`, whether a conversation’s place is still the person’s; `stillOnPage`, a text chat’s page — kept on the version written, opened, and on another field, ended by another rail or entity; `shownStem`, the version the tabs show where the selection names none. A form section’s chat kept as a page chat is; a pending set’s page reported as section `batch` with its type and no entity, the pending comp and the pending queue different places; the overview of a project with a version in use is that version’s page (`pj`), logged with the project key, the entity, the field, `landing`, `landingStem` and cause `landing`; with none it stays the overview; a chat’s record names its set type (`record`); each change logs the place whole
`packages/filmopen_text_ui/test/prose_editor_suffix_test.dart`	the prose editor’s suffix on a read-only box (§9.3): drawn as its builder gives it, the builder told the box is read-only; a null suffix leaving the decoration as it is, read-only or not.
`packages/filmopen_forms/test/assistant_shortcut_test.dart`	the AI icon as an action’s shortcut (§6.11a, §9.3) on the project form with a catalog of the test’s: at 375, 700 and 1200 px in light and dark, after the synopsis box’s microphone where the field has an action of its own, before the Synopsis title where the form section has one, one icon per place (the first action), none on a field without one; a tap holding the field, or the section’s first field, and pressing the action with its origin, logged with nothing of the form’s text; a View form with both icons and no microphone, the field’s at the microphone’s place, a read-only box without an action reserving no suffix room; the tooltip from the package’s strings, else the id; no icon where the assistant is unavailable or its catalog not loaded, and the icons appearing as the catalog loads; the pulse on the icon’s own tap and on its chip’s press, the other icons still.
`packages/filmopen_forms/test/assistant_where_field_test.dart`	a form’s field published to the dock (§6.11a): focus moving outside the form keeping it; a View character’s hair chat-only where scalar and applicable where the appearance is absent; Compare publishing nothing; a field going taking back its own publication after the frame; the scope going with the form leaving nothing to clear; a prompt inside the media card, the innermost field winning: in Edit by tap and by keyboard from General into the prompt and on to a media control, which publishes the media card though it kept the focus, the panel keeping the last field; in View by tap.
`packages/filmopen_browser/test/entity_tabs_settled_test.dart`	`EntityTabs.onSettled` (§9.3), which the dock’s place reads: the first tab after the first frame and an accepted tap, never a blocked one; an intercepted tap only once answered; a replaced id list reporting its fallback; another set of tabs renewing the controller, logged `tabs.controller.start` and `tabs.controller {outcome: renewed, ms}`; another version in the same tabs once; going reporting null after the frame.
`packages/filmopen_exchange/test/pattern_test.dart`	a catalog action’s export pattern (§6.18): every character and location as summary and the project as overview; `this` whole with the characters as summary; the `this` family selecting what the matching named scopes select; siblings without the input; a refusal by a fixed code and a safe token; the pattern registered as no scope.
`packages/filmopen_plugin_host/test/assistant_catalog_host_test.dart`	the host’s catalog assistants (§6.11a): both loading, then ready with catalog and portrait; a library fo-assist an ordinary tool plug-in; a package without `capabilities.ai`, a catalog path outside `assets/` or a bad catalog refused by its code and location while the others load, the refusal logging the value written there (a declared path that is no string as written) and a bad catalog’s bytes and text whole, a read its path and text whole; a portrait over 256 KiB or not an image left out; a reload with the same hash reading nothing; Settings overriding action preferences, action/catalogue/fallback order, preferred model retained through provider ties (text preference, stock, tag), generic reachability, no reachable model, ordered trials and reasons; one row per enabled-provider model, local included, a funded ordinary text provider selectable globally while assistant admission still refuses its missing bound; keyless local opening, server/path/model binding and changed-server staleness; missing-key diagnostic provider retained for repair; credit questions cached per platform, changes published, pending questions awaited at opening and failures logged with cause; no assistant text-picker default or its events; idle calls decide nothing, the first completion decides once, route evidence folded into one line and inventory decisions logged only on change; an LLM writer preferring the second of two reachable models listed with it and its rate from the chosen platform’s row and the call using it; writer token estimates quoted with both input and output prices, and null for a reachable model without a rate, the frozen `llm` in `plugins.choice`; a row with no plain price (OpenRouter’s) giving the lowest per unit with `rateFrom: lowest`, a plain one `rateFrom: plain`, none where nothing is reachable (`noPlugin`, `rateFrom: none`); a change of Use the LLM: told as the host’s change and logged `plugins.llm.setting`, the same setting changing nothing; an accepted writer decision refusing changed model, rate or quote before any writer arguments or HTTP request, both records and route logged, matched/name-only/no-accepted calls retained; an OpenRouter provider with no model list offering Kimi K3 and DeepSeek V4.1 Flash in the text-model list. The inventory logs every text entry: one no enabled provider serves as `noRoute`, with each declining text provider and its reason (`notNamed`, `noRow`), the choices unchanged.
`packages/filmopen_plugin_host/test/assistant_action_test.dart`	an action’s chat through the real host on fixture packages and HTTP stand-ins (§6.11a): the opening — Settings overriding the action’s preferred models and the catalog’s, the one context object (`film` lean with every id and no bookkeeping, the index merged into the action’s selection, a registered scope’s too; the page’s entity once at its working version — or as the form open on it holds it, whatever its version —, by the action’s line or its summary without notes, negative prompts or media, left out where deleted, unfocused off the Project rail or without an entity; `focus` with the field’s read paths, and `values` where the form shows other than the chosen focus snapshot — unsaved typing, the person’s version in use beside their draft, a composite field on a group page; the field’s value once otherwise), the full export retained and an import planned on it noting `changed_since_export`, the selection, export, override, focus and retain lines, the preamble without the tools’ writing rules, a chat with no Apply and its catalog’s `finalize` logged ignored, a field’s action offered disabled `noTools` on a provider without tools and ready on one with them, each refusal with its code and stage, an activity past the old 32 KiB opened whole, an Apply answer past the old 16 KiB proposed whole, a Settings change making the session stale —; the turns — the request’s order and its output bound, one POST a model call, the ledger settled once on every outcome —; and the tools loop — `assistant.open` logging their `toolsBytes`, a table past the old 32 KiB opening and posted, the commands frozen at the opening, a tool call run through the registry as `caller: text` and its output sent back, nineteen answers asking tools then words in twenty calls, all offered tools, seven answers asking tools then words in eight calls, nine calls all running in order, each output sent back, one tool refused with one detail across three answers, a success between, ending `toolStuck` once the third answer’s calls have all run, the answered calls kept; three calls refused alike and a fourth that succeeds in one answer all run, are sent back and counted once, the turn going on; distinct details in four answers never stopping it; and a fresh turn’s two refusals and a correction going on, a field chat writing its field with `update-entity`, outliving its form and writing again, while a conversation’s form going makes it stale; an unknown alias, a 17 KiB output sent whole, a cancel or a close stopping the loop, the turn’s exchange kept, the `text.tools` line as the provider gave it, and the stored key in no log line, and every line carrying its values — the system and user messages, the messages each call sent, the reply, the tool arguments, a 17 KiB tool output whole as sent, the route, the session id as it is, a failure’s message, a turn’s request size whole with its messages —; an action opened on credit with no key stored; the wait measured (`FILMOPEN_MEASURE=1` prints it): five cold and five warm openings, each with its first turn on a delayed in-process client, every stage of the opening and the HTTP door’s three moments logged with `ms`, the catalog read once per runtime and never on a warm opening; the film index leaving a deleted character out and `assistant.open`’s `film` counting it, never naming it; an opening failure’s `at` naming the host’s frame; the stream (§6.11a), on a fixture provider that pushes partials and answers whole: every call asking for a stream; text, a tool, text keeping both segments in the display and the pre-tool words once in the next request; a whole answer with a tool then a streamed one; the final text winning, `partialsMatched` false; a refused answer’s final text kept off the display, what it pushed kept as shown; Stop after a completed tool keeping the exchange and its indices over two later turns; Stop mid-call on credit asking one End, `stopped`, while the session is already idle and the End held, and on the person’s own key none; `assistant.turn.first`, `assistant.turn.stopped` and the stream fields logged, the stored key in none; the context’s `fields` — the focused character’s form for an action exporting it, with the preamble’s words on writing them, a named scope’s (`project_overview`) of the types its own selection holds, none for a chat without tools on the project, every type a command writes (`fieldMapTypes`) for a chat or an exporting action with tools — and `fieldTypes` and `scopeTypes` logged; an empty last answer after tools that all succeeded ending `ok` with Done. under the words shown, `emptyAfterTools` logged, and after a refused or a failed tool (`toolFailed` logged) or as the first answer, `noWords`. Notes through the real engine: shown, replaced, cleared by the words and at once by Stop, outliving their call and gone with the turn, a failed call’s included, one past 128 KiB shown whole, a tool’s note and a bare Thinking… leaving the note as it stood, a tool note logged by its command’s name and another note shown as it came, each logged as received and shown with its kind, never in a message or a request; three calls with reasoning only on the second, a tool’s note after it: the sentence standing into the third call, each call’s start stamped and logged, `heardCall` naming the second; reasoning then a refused tool’s announcement, the sentence standing into the next call; Stop while a tool runs clearing the kept reasoning before the tool ends, logged `stop`; Stop during a program’s handover of a whole answer clearing it before the handover ends; an answer cut off runs none of its calls and ends `cutOff`, the earlier tool standing, each call settled once. With tools, `fields` for every type a command writes, and the sentence on `metadata`; the fields sentence telling the model to say a change is made only after its tool call succeeded; with tools the opening carries no `fields`, its preamble names `update-entity`’s description, the guide once in the request, `bytesBy` by part; an action’s `effort` sent as `reasoning: {effort}` on the turn and Apply where the route maps it (`effortFrom: action`), none where it does not (`unmapped`) or the action names none (`none`); an action that `asks` gets its question on a project with neither logline nor synopsis — the open form’s draft where it holds one, else the open chat’s latest version, else the file in use — and none where one is present or the action names none; an emptied open form over a file with a synopsis does not ask, and the model reads the file’s synopsis beside the draft’s other fields (`assistant.open.summary` `inUse`, `draft-empty`); over an unpicked AI round it reads the round’s, its other fields too, with a form open or none (`chat`, `draft-empty` or `no-form`); each model call’s `finish` logged as its answer gave it, null where none; Write the Synopsis’s lines carry an episode’s `kind` and `notes` and a scene’s `notes`; each model call’s `bytesBy` measured as it is sent, the second’s history holding the tool exchange; a key the store no longer holds refused before sending: the turn reads `notSentNoKey`, nothing is sent, `assistant.notSent` logged with the refusal’s code, reason and stage; a call that answered tool calls alone is heard as it returns — `heardCall == call` while its tool runs, its post-call `assistant.turn.stage` line carrying `heard`
`packages/filmopen_plugin_host/test/assistant_action_test.dart`, `packages/filmopen_assistant_ui/test/assistant_dock_test.dart`, `assistant_widgets_test.dart`, `test/settings_models_test.dart`, `packages/filmopen_render_ui/test/auto_references_test.dart` (what will pay, shown)	the Text row follows the chosen model (§6.11a): a program chosen on one plug-in and a model only another serves — Kimi K3 on OpenRouter — reads the other’s FilmOpen credit, `honoured: automatic`, its one candidate, the decision’s `tried[].preference {provider, route, reason: doesNotServe, model}` logged whole; a model the first serves reads its chosen route again, kept as stored; an open chat keeps the route it opened on: chosen credit, then Codex chosen, the session still holds credit and its turn goes to the portal; the dock still says credit while the chat is shown, a new chat says Codex, each change logged `assistant.readiness.shown` with its source (`held`, `offer`); the chip says its route before it is pressed; at 375 px with the dock closed, a field’s AI icon on a credit action opens the slide-out at its chip, OpenAI / FilmOpen credit in view, and starts nothing until the chip is pressed, and on a key route starts at once; docked with the options scrolled past it, the credit action’s chip is brought into view, each logged `assistant.dock {shortcut, …, outcome: revealed
`packages/filmopen_plugin_host/test/provider_tool_turn_test.dart`	the assistant’s tool turn through the real host on the shipped `fo-openai` and `fo-xai` (§6.11a), loaded from the staged stock (`plugins/stock.json`, failing with the staging command where it is missing) as the host installs it at a start, against an in-process stand-in answering the shared stream vectors with the fixture’s function names bound to the aliases offered: words and two tool calls, both fixture commands run once with their arguments, the second request carrying the words, the two `function_call` items and their two `function_call_output` items under the same `call_id`s with Terra’s `reasoning: {effort: 'none'}`, then the final words — on `fo-xai` the chat-completions form, an assistant message with the words and both `tool_calls` and a `tool` message per call under its `tool_call_id` —; the same turn answered whole, with no partial and no stream read; the output bound equal to the host’s on both requests; each call’s reported usage on its own ledger record; Stop while a read waits, the read refused `cancelled` and nothing retried; on `fo-openai`, a reply cut at `max_output_tokens` ending the turn `cutOff`, its words kept as shown, with the `openai.responses.incomplete` line; the turn’s, the tools’, the `text.tools` and the stream’s lines logged, none carrying the stored key ; each call handed to the registry with the chat’s id and the assistant’s (§7.4); the tool call in flight the backend’s `inFlight` until it ends; a request of the phase `summary` refused `request` as any unknown phase, no model call, its refusal logged A context refusal of the real OpenAI and xAI adapters reads in the provider’s own words, one request, logged whole; a malformed call, alone or between two valid ones, on fo-openai and fo-xai: answered `bad-call` with the parse error, nothing dispatched, its neighbours run, the next request carrying its text as sent and the error, `argumentsErrors` on the decode line, one succeeded ledger record per model call; the reply carrying the turn’s exchange as the host keeps it, into the session’s history, `assistant.turn`’s `exchange`; a stop before any tool keeping none; a streamed answer on `fo-xai` and `fo-openai` reaching the real ledger with its cited id seen — xAI’s provider cost recorded, OpenAI’s request recorded — and an id no stream held left unknown with `usage.receiptUnseen`
`packages/filmopen_plugin_host/test/codex_models_test.dart`	every OpenAI text model Codex serves runs on Codex: the shipped `fo-openai`, from the staged stock, offers each of the catalogue’s OpenAI text entries it names (GPT-5.6 Terra, GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Luna, GPT-6 Sol, GPT-5.5) with OpenAI / Codex program among each one’s Text row routes; chosen there, a turn on each starts the configured `codex` program — an offline stand-in run by Node — on the entry’s own model, Codex’s `model/list` read once, and `plugins.llm.decided` and `complete.init` name the route and the model asked and answered. POSIX only.
`packages/filmopen_plugin_host/test/run_offer_test.dart`	A granted wall replaces the base up to thirty minutes, ordinary walls only shorten, and `noWall` overrides both for completion while preserving the other limits; three nested completions each log a null wall with reason and elapsed milliseconds; per-completion `llms` preserve the call default, Settings overrides, malformed lists send nothing, and actual model/provider replace provider claims; checked workflow JSON/refusals and role calls; declared arguments beneath caller fields/focus, step model/rate and Settings reason, exact ended-ledger USD spend, known zero/unknown cost, preserved failure words, logged unexpected stage/cause; the same sleeping function through a granted step and an ordinary action, with whole event values pinned; `decideStep`’s quote, the step’s estimate at the decided model’s rate (three calls of 20,000 in and 6,000 out at $2/$10 is $0.30), carried by `runOffer`’s model and logged with the estimate, and null without an estimate or without a reachable model; an offer answering `{state: 'failed', message}` at the top level (Script Aid Lite’s shape) fails in those words, logged in `plugins.workflow.run.done`; one answering `{state: 'refused', code, message, usage, cost}` after a completion (the live check’s `invalid_model_answer`) is refused with that code and message whole, its spend still reported and `answerState` logged; The ended ledger remains the source of the exact spend and zero/unknown summary regressions; funded action-frame correlation is covered by the host runtime cases.
`packages/filmopen_plugin_host/test/spend_ceiling_test.dart`	Whole UTF-8 request JSON including schema text; exact equality, spent and in-flight bounds; unconditional/highest conditional prices, unknown rates and invalid output limits; known USD cost or conservative unknown/non-USD/failed cost; four simultaneous completions, sequential actual costs, throw/refusal cleanup, fifth-slot admission and no-ceiling behavior; a writer that names no `max_tokens` — without a ceiling the catalogue’s `max_output_tokens` on the request sent, none without a catalogue maximum, a writer’s own number untouched, under a ceiling the most the remainder buys with the same params priced and sent and one token more refused `over`, the catalogue maximum where the money buys more, the ceiling’s number alone with no catalogue maximum, the input and one token unaffordable refused `over` with nothing sent, reservations in flight leaving less — and `maxTokensFrom` logged; an unknown model with no output limit refused with the ceiling and sent without one; real-JavaScript workflow refusal reaching the writer, preserved actual spend, invalid/unparsable ceiling refusal, and full decision diagnostics; the ledger’s first refusal kept (reason, worst case, ceiling) and none on admission; an uncaught refusal before any request answers `refused/ceiling`, `over`, the exact worst case and known zero spend, with no request sent.
`packages/filmopen_plugin_host/test/assistant_policy_test.dart`	twenty completes each admitting one POST, repeated POSTs refused; the catalogue’s output maximum the only bound admitted, none admitting none; tools admitted at complete where the host offers them, of any size (past the old 32 KiB), a `tools` that is not a list refused, `tool_choice` auto or none; a request of any size admitted at complete and HTTP dispatch; object body, frozen key/model/path/output bound and one POST retained, rejected requests consuming none; frame-bound reads, missing/pending/ended streams refused before transport; partial text/phase, partials past 128 KiB together shown whole, cancellation and staleness; provider log lines written whole; completion options used as supplied, their model and valid `llms` ignored by the frozen policy, with its actual model/provider returned; binding refusals logged with their clause and value; a keyless local request bound to the named server, path and service model, wrong bindings refused and the second POST blocked; a `reasoning` admitted only as the frozen `{effort}`, and none where none is
`packages/filmopen_plugin_host/test/assistant_note_test.dart`	the host’s text service writing the dock’s lines to the app’s log, a failure as a warning (§6.11a).
`packages/filmopen_plugin_host/test/assistant_voice_action_test.dart`	an action’s conversation (§6.11a): a no-field action on OpenAI with its own instructions and its context as text; a route the assistant does not offer refused; a field action’s finalize; an incomplete or empty transcript a code of its own; the speech provider holding the session; a talk-only conversation not reading the Settings text model; a session whose binding changed ending stale; beside a text provider with tools, Grok’s voice opening keeps no pointer to tools it is not given (`guide: context`) and on a character’s page carries that type’s field block, OpenAI’s points at them and carries the guide once (`guide: tools`)
`packages/filmopen_forms/test/project_synopsis_assistant_test.dart`	The synopsis on the forms (§6.11a): no assistant control (no stars, no `.assistant` identifier) on the project’s, a folder’s or a scene’s synopsis in Edit or View, at 375, 700 and 1200 px in light and dark; the microphone bound where the field is writable and absent where locked; focus in Edit or a tap in View publishing the field to the dock with its stem, pair id, apply path and draft, frozen in View; the Title publishing Title; Compare offering and publishing nothing. The retired field assistant’s control (filled stars, `.assistant`) stays gone; the AI icon of §6.11a is `assistant_shortcut_test.dart`’s.
`packages/filmopen_plugin_host/test/native_conversation_finalize_test.dart`	The voice road’s finalizer (§6.11a) over the fake-backed native session: a finished conversation finalized once with its frozen transcript, a second Finish answering the first; a session never started ending on Finish with the operation cancelled and no finalizer; Close cancelling it and a later Finish finalizing nothing; End without Finish cancelling it, and the cap’s end, a Finish of its own, cancelling nothing and leaving the person’s Finish to finalize once; disposing the session telling the host once; the overlay’s package, with no finalizer, finishing as before
`packages/filmopen_plugin_host/test/realtime_session_test.dart`	The voice session on both providers’ exact configurations: inert until Start and one opening response; WebRTC’s one connection, integrated captions and native mute; Grok’s PCM with device-position truncation; OpenAI’s one connection on either transport, logged before its key is used; caption replacement and incomplete input; Mute, End and Close owning pending devices and sockets; deduplicated Usage with unknown totals kept unknown; response completion leaves playback speaking until its position drains, with listening observed within a bounded yielding wait; what the session sends is the binding’s model (the endpoint, the first Usage record) and voice (the configuration), per provider; the records labelled `conversation`/`conversation` and `conversation-captions`/`analysis`, and an old record with the experimental labels still read; no cap by default, as the app makes the session, `voice.start` logging `cap_ms: none`; a cap given finishing the session through Finish at the cap and not before, logged as `voice.cap`; an idle session telling its listeners once a second, and Grok’s playback poll telling them when the phase turns to listening, a failed position read logged with its error and ending as `voicePlayback`; its transcript kept and no second session without a gesture, a Finish under way at the cap left the person’s; device and provider failures closing without retry or provider text.; on credit the receipt’s cents `charged` with the operation, an unsettled read `pending` naming it, a Close while the start is answered too
`packages/filmopen_plugin_host/test/realtime_transcript_test.dart`	The voice transcript: Grok’s cumulative captions and OpenAI’s deltas giving the same snapshots, a final input resisting late updates, interrupted output kept, and a 101st short caption and captions past 128 KiB kept.
`packages/filmopen_plugin_host/test/realtime_io_test.dart`	The voice WebSocket of the PCM route against loopback servers of the test’s own: a handshake answered with a redirect is not followed, the key reaches only the server asked and no log line, and the failure is logged with its error (`voice.socket.failed`); an upgraded handshake carries events both ways and is logged open (`voice.socket.open`); a server’s close is logged with its code and reason (`voice.socket.closed`) and a frame that is not an event with its text (`voice.socket.refused`); a frame past the old 1 MiB is read whole.
`packages/filmopen_plugin_host/test/realtime_webrtc_test.dart`	OpenAI’s WebRTC signaling: a refused microphone sends nothing; one fixed multipart SDP request carrying the bound model, keeping early channel events; an HTTP failure or a timeout ending the peer without echo, retry or a late answer; invalid channel data answered as a safe connection error and logged with its text and error, a message the channel cannot send likewise (`voice.wire.failed`); an HTTP failure logging the provider’s answer whole, a body that cannot be read with its error, an answer that is not UTF-8 failing at `accept`; the request logged whole before its credential is added, the offer’s and the answer’s SDP whole, a failed cleanup with its error, and no key, bearer or portal token in any line.
`packages/filmopen_plugin_host/test/realtime_pricing_test.dart`	Voice cost estimates in exact decimals: the six pinned rates by modality and cache, missing or contradictory usage keeping the price unknown, cached counts bounded by input, repeated responses summing without drift, and Grok’s session time and text items.
`test/synopsis_preferences_test.dart`	The explicit isolated preference filename the agent build’s assistant fixture uses on Windows: preferences written to and reopened from that file only.
`test_native/synopsis_voice_audio`	A standalone Windows Media Foundation check, run by hand: synthetic 44.1 kHz and 48 kHz stereo WAV converted to 24 kHz mono PCM, frame count, frequency, amplitude and invalid input checked.
`packages/filmopen_plugin_host/test/assistant_voice_platform_test.dart`	Windows advertises both voice routes, Android and Linux only OpenAI, and other devices none. An Android Grok request for a catalog action is refused before context, credentials or audio are accessed. The key read on the gesture decides the funding: own key for a well-formed record, else `needsKey` (missing), `keyInvalid` (not JSON, the wrong shape, a short key) or `unknown` (an unreadable store), and a provider plug-in not ready `notConfigured` before the store is read and again after it — one turned off while the key is read funds nothing (§6.7); the four refusals are four codes, `provider` among them. The key is fo-openai’s (`filmopen/fo-openai/openai`), read through a host runtime holding the two fixture providers; only an obsolete `filmopen/app/<platform>` record is no key; the funding is the plug-in’s (`fo-openai`) while the route keeps its platform. The binding’s `audioFormat` names what `configure` sends: PCM at 24 kHz for Grok, nothing configured for WebRTC, the voices `eve` and `marin`.
`packages/filmopen_assistant_ui/test/assistant_voice_widgets_test.dart`	An OpenAI-only device preselects OpenAI (the speech service’s Grok default having no route there), says so, and writes nothing back; a Grok the host starts as OpenAI on credit shows OpenAI and its billing line. A device with no route disables Start and explains the limitation. A Start the key’s store refuses shows the state’s own sentence (no key yet; not valid; couldn’t be read) and opens no session. No cap of the app’s: no cap line before Start, no warning and no limit-reached sentence, and past the old 15 minutes the conversation running on with Finish still offered. The target line and what Apply would do read inertly before Start, none disabling Start with its reason; Finish’s outcomes — an incomplete transcript, `nothing`, a replacement too long, a plug-in’s code — said once, Finish spent; Close and Escape waiting while the finalizer runs, Close saying why, also after a Finish whose release failed, the release sentence shown; a pick moved before Start starting nothing and showing the session’s sentence; a person’s End spending Finish.
`packages/filmopen_plugin_host/test/realtime_session_test.dart` (the owner and the adapter)	the one microphone owner (§6.11, §7.2): a started session holds `assistant` and dictation’s acquire answers occupied; Start held by a field is refused with `mic_busy` naming it before a connection, a device or a Usage record is touched, on both routes; End awaits a slow release before it gives back the owner and the slot, and a failed release — the capture’s, or the native peer’s own `cleanupFailed` — is logged with its error (`voice.release.failed`, then `voice.released` naming it) and gives them back too, the session ending in `voiceRelease` with `released` false and End answering not ready; the turn events of either route log the person’s words, the answer and the provider’s error whole and `voice.released` the messages, the fixture key in no line; `NativeConversationSession` types the session — binding, snapshot states, caption revisions by turn with their finality, the Usage chain, one Start per session, mute, interrupt’s single cancel, finish’s frozen transcript, End idempotent, every operation closed after Close; a refused Start is not ready, a short key unfunded with `needsKey`
`packages/filmopen_plugin_host/test/realtime_session_test.dart` (Finish)	Finish’s drain (§6.11, §7.2), on the scripted transport: input disabled, one commit, one cancel while a response is in progress and none without, a final arriving in time, a committed acknowledgement not ending the drain early, an empty refusal ending it early with nothing pending and not with an earlier caption pending, an automatic acknowledgement and its caption after Finish admitted while a new turn’s start is dropped, a late `speech_stopped` leaving the phase finishing, the timeout labelling a partial caption, Finish’s commit owing no response (the last record priced), a response and its output after Finish dropped while its Usage counts, an unrelated error ending as usual, Close and End racing the drain winning at once with one End, a stalled input stop not holding Finish past its bound, Finish before ready and Grok’s Finish as End
`packages/filmopen_plugin_host/test/assistant_voice_platform_test.dart` (the door)	the one install is the native door: support follows the platform, an unreadied binding answers not ready and finishes closed
`packages/filmopen_assistant_ui/test/assistant_voice_widgets_test.dart` (Finish, the refusal)	Finish shows its status, disables Mute, End and Finish, keeps Close, freezes the transcript with Needs finalization and Partial transcript; Close during the drain ends at once; a Start refused by the arbiter names the holder in the shared sentence, lights Start again, keeps Finish disabled and shows no Needs finalization; the saved Speech service’s route preselected, an unknown or routeless one preselecting nothing with its line and the controls’ tooltip. The dialog’s own refusals (a pick moved, the microphone busy) and failures (open, End, Mute, the release) write their lines through `note` by stage and code, each with the whole error; a session’s failure stays on screen after a late clean-up clears it, written once.
`packages/filmopen_assistant_ui/test/assistant_voice_captures_test.dart`	pictures of the six states a Linux agent build cannot reach — refused, running, a conversation past the old 15 minutes, finishing, frozen, a long conversation ended — at 1200 and 700 px, light and dark, where `FILMOPEN_CAPTURES` names a folder; skipped elsewhere
`packages/filmopen_plugin_host/test/realtime_session_test.dart` (the drain’s accounting, the view, a held Start)	a response created during the drain whose Usage never arrives keeps the total unknown; a response created during the drain while the input shutdown is held is cancelled once, whichever path reaches it first; the host freeing its slot detaches the view without closing it — Finish stays finished or timed out, End completed, Close racing Finish closed; Close winning a held preparation makes Start answer closed
`packages/filmopen_l10n/test/labels_dictation_test.dart`, `packages/filmopen_dictation/test/dictation_ownership_test.dart` (the assistant owner)	the occupied sentence names the assistant’s conversation; a field and the commentary are refused with `mic_busy` naming `assistant` while a conversation holds the microphone, without a device, a Usage record or a session
`packages/filmopen_plugin_host/test/realtime_webrtc_test.dart` (on credit)	the conversation’s start on credit (§6.11a), on a stand-in peer and a `MockClient` portal: the same multipart `sdp` and `session` as on a key, to `https://<kFilmOpenDomain>/v1/portal/realtime`, with no redirect, the seam’s account bearer and portal token unchanged beside `X-FilmOpen-Operation` and no other header, a 200 and a 201 answer’s raw SDP accepted; a 402, 409, 503, 400 with an unsafe code and 302 refused as `voiceStartRefused:<code>` (the contract’s `{error, says}` envelope’s `error`, `unknown` for an unsafe or non-string one, `status-<n>` where there is none) after the peer’s cleanup, the body whole in the refusal’s line; a 401 `bad-portal-token` letting the credential go once with nothing sent again; no portal headers `credentials` with nothing sent; every stage’s line — `voice.offer.made`, `voice.start.request`, `voice.start.sent`, `voice.start.answered`, `voice.first_event`, `voice.connection` — with the operation or `route: direct` and its milliseconds on both roads, and one line for a refusal; no key, bearer, token or instructions in any line
`packages/filmopen_plugin_host/test/realtime_session_test.dart` (on credit)	the session on credit (§6.11a, §6.7): no key read; every record `filmopen.ai` with no key and no captions record; Finish, End, Close, a disconnect after the open, and End and Finish overlapping each ending the operation once after the wire has closed and reading one receipt, its cents the terminal cost (USD, reported); a Close while the start is answered still ending it once, also with the real connector holding its 201 while the peer closes; the receipt logged whole — `received` or `none`, its settlement and its cents — and a failed End and a failed receipt each with the error whole; the turn and Finish lines with the operation and the gesture’s milliseconds, a failed stop with its error; a refused start keeping its code, ending nothing and read as not ready; a priced `response.done` before End keeping its units with no cost and the unknown basis, and no receipt leaving the cost unknown; `voice.stop`, `voice.end` and `voice.receipt` with the operation and milliseconds and no key or instructions; on the own key nothing ended or read of the portal and `voice.stop` with `route: direct`
`packages/filmopen_plugin_host/test/assistant_voice_platform_test.dart` (credit)	with no key, OpenAI on a native peer asks the funding seam and takes its credit with no key, and so does a Grok where OpenAI’s peer would carry the call (`fallback`); no peer, and no credit, stay `needsKey`; each decision logs `voice.funding` with its provider, the selected one, its outcome and reason
`packages/filmopen_plugin_host/test/media_out_test.dart`, `first_frame_test.dart` (media on demand groups)	The plug-in host downloads a granted reference and a render’s first frame before reading them, and refuses with the download’s code
`packages/filmopen_assistant_ui/test/assistant_voice_widgets_test.dart` (credit)	at 375 and 700 px in both themes, OpenAI’s billing line says its key, else the FilmOpen credit, pays, captions included, with no BYOK sentence (Grok keeps the BYOK one), and `voiceStartRefused:insufficient-funds` reads FilmOpen could not start the conversation (insufficient-funds).
`packages/filmopen_platform/test/webrtc_audio_peer_test.dart` (native states)	every native peer, ICE and data-channel transition forwarded as a `state` observation by its name (`ice:checking`, `peer:connecting`, `peer:connected`, `channel:open`, `channel:closed`), the failure and closed events as before, the ICE callback released with the peer
`packages/filmopen_platform/test/webrtc_audio_peer_test.dart`, `webrtc_audio_backend_test.dart`, `packages/filmopen_plugin_host/test/realtime_webrtc_test.dart`, `realtime_session_test.dart` (what the microphone and the session do)	the capture and the configuration logged (§6.11a): each capture stage in order with the processing requested and the form; at `enabled` the track’s settings as it reports them, `unknown` for a track that reports none, and a failure’s native text; an acquisition and an attachment failure name their stage, category and type; the form `optional` on Android and `top-level` on Linux and Windows beside the adapter’s output; `voice.capture` under the correlation, a failure at warning, never failing the wire; the configure carries eagerness `low` and the app’s language, and `voice.session.config` logs the `session.update` it sent whole; an `error` logs the provider’s error whole; `voice.provider` names the language.
`packages/filmopen_plugin_host/test/realtime_session_test.dart` (the operations log)	every voice operation logged (§6.11a): Mute and Unmute with the requested and the resulting state, each step, what the capture did and the elapsed time, an ignored one with its reason; a Mute the native peer refuses with its original error where it is caught, ending as `voiceMicrophone`; a failed response’s `status_details` and the provider’s error whole on either provider, its id, status and usage in the turn line; each step of Start with its values and decision on both transports, the key by source and length alone, and a step failing after End; every failure that ends the session — a microphone that does not start, a refused connection, the wire’s error and close, the capture’s error, an event that does not parse — with where, its code and the original error; every Usage record with its status, units and the values its cost was decided on; Finish’s start, the decision that makes it End and its outcome with the time; End’s time and each release’s outcome and time, a failed one’s too, and an interruption’s truncation; no key in any line.
`packages/filmopen_plugin_host/test/voice_tools_test.dart`	the voice session’s tool table (§6.11a): an alias `c<index>_<name>` round-trips to its command; a 48-character name under a long source gives an alias of at most 64 characters of `[a-zA-Z0-9_-]`; a description is whole (2,000 characters kept); 70 commands give 70 tools and a table past the old 32 KiB is whole, nothing dropped; `session` and `operation` are absent from the declared properties and `required`; OpenAI’s `session.update` carries the tools and Grok’s none; a session logs `voice.tools.declared {count, bytes}` and no `voice.toolsTruncated`, a Grok session `voice.tools.unsupported` once; `voice.session.config` carries the `session.update` whole, once, its tools as sent — the alias, the description uncut and the schema without the control fields — and never the key. A write tool’s content declared as announced, its change views whole.
`packages/filmopen_plugin_host/test/voice_tool_turn_test.dart`	the voice session’s tool turns (§6.11a), through the fake wire: one call’s output then one `response.create` after `response.done`; two calls in one response, the second arriving after the first finished, and one `response.create` after the seal; `response.done` before and after a slow call, one `response.create` either way after the output; a tool-only response; the phase thinking while a sealed turn’s call runs and listening after an interrupted turn, but thinking while a later turn’s call still runs when an interrupted one settles; a `failed` or `incomplete` `response.done` after a tool’s output sealing nothing, with no second `response.create` and its Usage recorded; a slow command while 100 audio and usage events pass, none dropped and no backlog; an unknown alias and non-object arguments answering `bad-call` undispatched; a repeated call id running its effect once, another call id running again; speech after admission (no output, no `response.create`, the answer kept in the ledger) and before admission (refused by the guard); explicit interrupt after admission, and before a call arrives for its response; a turn sealed with its call pending, then speech or interrupt, admitted or not; Finish while a call waits; a response interrupted before its first call; End mid-call sending nothing after it; a read-only `builtin/navigate` through the `JsonShape` validator without control fields; a result past the old 16 KiB sent whole, with no `too-large`; the walk-through from the project’s synopsis — `builtin/export` `scene_dialogue` answering its document, `builtin/navigate` moving the page with an observation of caller `voice`, an effectful command running once under its controls; a call’s provider call and response ids, its arguments and its output logged whole on its lines, and a result past the old 16 KiB logged whole; a command’s refusal reaching the tool’s outcome as the code it refused with, declared or not, as the registry records it
`packages/filmopen_platform/test/background_transfers_test.dart`	the transfer host’s seam (§6.14): the web stub and a non-Android platform answer `notSupported`; the channel carries `show`, `update`, `hide` with their texts and counts and answers what the activity answers; a refusal answers `failed` with its code, logged `sync.host.callFailed` with the platform’s message after `sync.host.call` with what was sent, and a missing handler `failed: missingPlugin`; the service’s reports (started, a failure after the request was answered with its type and message, the timeout, a stop with its reason) arrive as events
The Linux voice checks cover an inert native factory, OpenAI-only host admission, unsupported macOS/iOS routes and unchanged desktop audio constraints with default and selected input. Native desktop probes and physical microphone, speaker and cleanup acceptance complement fixture tests; a generated SDP offer does not establish capture or audible playback.

The screenplay-import checks are:

Test	Rule
`packages/filmopen_fdx/test/converter_test.dart`	The recognised times of a heading, read from the right after a spaced dash or a period followed by a space, an unknown tail kept in the location; scene boundaries and preamble, literal speech, whole-name mentions, UUID production tags, outline/act hierarchy, title-page separation, unknown metadata, parallel speech, unsafe/duplicate IDs, explicit cue aliases, scene-metadata cast targeting, broken occurrence references, malformed XML and forbidden character references, Unicode and whitespace boundaries, late identity conflicts, processing instructions, nonregular files and bounded file decoding; a screenplay imported under a 32-character username, whose allocated epoch has 34 characters; SmartType declarations, with an id or without, latent until a cue, prose, a heading or a resource’s description promotes them, a description kept, a tag taken only at promotion, two of one name ambiguous, a repeated declaration merged, never promoted by a transition, and a description’s mention promoting one without breaking the walk; every trailing bracketed cue group a delivery in the source’s spelling, a bracket-only cue dropped as furniture; a cue, its parentheticals and its speech one block, an orphan cue in the speech’s shape, a blank paragraph no block and consuming nothing held, a held cue kept in its scene at a heading, an outline level, an End of Act and the end, an absorbed cue’s production tags kept; SceneProperties attributes kept in provenance; each `import.decision` kind’s line with its values — every entity, scene and folder with what created it, a remapped source ID, an ambiguous name —, `import.time` at info with its position, and the per-kind counts on `import.converted`; the mention pattern built once per conversion, after the cues, with every character’s aliases on `import.mentions`; each reader refusal — a DTD, a forbidden character raw, as a reference or in an attribute, a nesting too deep, too many events, a text over the bound, malformed XML, another root or document type, a second `Content`, no words — made in the one pass with its reason on `import.fdx.refused`, and a read’s events and depth on `import.fdx`.
`packages/filmopen_store/test/imported_project_test.dart`	Validation before writes, author and identity checks, rollback with its trail logged, a failed removal logged by its path and reason with the original failure the answer, existing-source refusal, concurrent fresh folders, unsafe paths, and a reserved folder that cannot be removed logged by its path.
`packages/filmopen_store/test/app_log_digest_test.dart`	`AppLog.digestOf`: the first 12 hexadecimal characters of the UTF-8 value’s SHA-256, pinned by three values the sync’s path digest also gives; stable; two values two digests
`packages/filmopen_store/test/writer_log_test.dart`	the writer’s and the template’s lines name the username, tag, stem, path and epoch as they are: a project created, a character, an outfit, an epoch declared, a save, a fork, a pick, a version made at an epoch, official set and cleared and a take deleted, every captured line serialized whole; `writer.start`, the success line’s `ms`, `writer.refused {stage: check, code, reason, error}` for a changed tag (`tag`) and an undeclared epoch (`epoch.notDeclared`); the reason telling an empty name from an over-long version label and an invalid tag from an undeclared epoch, and each argument check of the create, outfit and at-epoch paths its own label; `writer.failed {stage: write, code: writeFailed, type, error}` for a throwing write; a pick failing after a create as `pick.setFailed {target, type, error}`; an outfit collision with its group and its epoch; `createAtEpoch`’s source unreadable (`sourceUnreadable`, its type and message) and changed (`sourceChanged`), each before the same `StaleFileException` and each with the key, the target and the source epoch; a copy whose write fails logging what it was asked to write — the key, the target, the source epoch and version, the stem, the path and the whole document — beside the source’s message, and `writer.start` naming them; a fork whose source cannot be read `ForkSourceUnreadableException` with `fork.readSource {stage, type, error}`, a changed source still the plain `StaleFileException`; a save refused at its check or as stale naming its stem, its path and the values it was asked to change; a manifest update whose write fails naming the manifest it tried to write
`packages/filmopen_store/test/writer_written_test.dart`	`ProjectWriter.written` (§7.4): null before a write, then the document a save, a create and a fork wrote, as on disk, the fork’s answer unchanged; nothing after a refused save
`packages/filmopen_store/test/loader_log_test.dart`	the loader’s lines: an unreadable library as `library.unavailable {path, type, error}`, `project.loaded` with the project’s and the library’s folders and `ms`, a warning’s path as it is; a load without a library keeps the null, an unavailable library logged by its folder; `project.load.start` before `project.loaded`, and a failed project listing logged as `project.load.failed` with its stage, type, error and `ms` before it reaches the caller; an unreadable document as `project.document.skipped` at debug with its stage, path, type and error
`packages/filmopen_store/test/loader_decode_test.dart`	the loader decodes each document once (its read path calls `decodeDocument` alone, no `jsonDecode`, and a load reads each document once, counted by the source); a load reads its documents concurrently, `readsAtOnce` (64) in flight at most, and indexes all 150 of them; an array, null, scalar or array-of-objects root is `notJsonObject`, malformed JSON `invalidJson` with the decoder’s message, an escaped or nested duplicate key `duplicateKey` with the key, a valid document loads
`packages/filmopen_store/test/set_loader_test.dart`	the loader’s sets (§6; Project Specification §12.7): a `cp`, an `as` and a queue `rd` filed as sets with their text, an older `rd` still a batch, an unreadable record reported as `invalidJson`; each record’s read logged — its start, what it read (its `created`, its items as written and their count, `next_item`) and where it filed it and why, or its failure with the stage; a changed item and swapped `created` dates read differently in the log — a set at info and a plain batch at debug, and `project.loaded` counting the sets
`packages/filmopen_store/test/project_bootstrap_test.dart`	The bootstrap makes the folder, `media/` and `thumbnails/` and writes only the manifest; refuses a folder that holds files and a tag that is no segment; takes back a folder it made and empties one the person had; `verifiedManifest`’s length, MD5, absent-MD5 and not-text cases; the tag and the path in each line of the log, a failure with its message. An unlistable destination fails at the logged `check` stage without a take-back; the bootstrap’s step lines; the manifest check’s start and `ms`.
`packages/filmopen_format/test/uuid_tags_test.dart`	UUID tag positions, including take sources, without relaxing author/epoch/batch grammar.
`packages/filmopen_fdx/test/fountain_test.dart`	Fountain’s elements, title with emphasis stripped and continuation joined, cue, parenthetical, literal dialogue and dual exchange, a cue folded into its speech’s block and starting at the cue’s line, a scene’s opening row logged at info with the scene it opened, blank-line boundaries and boneyards, sections, synopsis and first-line provenance, the screenplay evidence a heading or a cue with speech gives, a headingless script of one speaker on the phone or of twenty one-line speakers read, and unrecognised text refused.
`packages/filmopen_fdx/test/import_file_test.dart`	Content signatures decide the format, decoded XML included; a renamed Windows-1252 FDX imports; corrupt ZIP and empty RTF refuse, and that refusal and an unexpected conversion failure replay their ordered events, stage, cause and stack; an imported file’s `import.decision` lines reach the app log at info with their values and position, every block emitted with its words and a synopsis with where it went, and `import.converted` counts them by kind; a file whose read the platform refuses logs `import.readFailed` with its path, cause, stage and elapsed time before the unchanged `read_failed` / `filesystem_error`.
`packages/filmopen_fdx/test/readers_test.dart`	The FDX reader keeps typed words, scene number, dual group and source paragraph.
`packages/filmopen_fdx/test/pdf_text_test.dart`	PDFium’s text: Courier rows and runs split across relative thresholds, measured from the page’s logged median box on each platform, origins and top baselines kept, generated spaces and line ends, an image-only page textless, sequential fresh isolates.
`packages/filmopen_fdx/test/layout_test.dart`	Relative margins and speech offsets, numbered headings before dual lanes, furniture and omitted-scene removal (`OMITTED`, `OMITTED 32*`, `Omitted 25-A` with their numbers, logged `omitted_skipped`), prose beside a revision number kept as action (logged `heading_refused`), action boundaries, page title material and first-row provenance; paragraph readers may disable action joining without changing PDF’s default.
`packages/filmopen_fdx/test/pdf_import.dart`, `pdf_open.dart`, `pdf_repairs.dart` (registered only by `pdf_text_test.dart`)	PDF import through one converter; title and opening-row provenance, image-only/prose refusals and the exact 200-character boundary; a headingless PDF with a speaker per speech refused as `unreadable_text` with its `speaker_counted` lines and counts, and one whose speaker changes only the delivery read; typed native open reasons (a truncated header’s detail code PDFium’s own, an encrypted one `FPDF_ERR_PASSWORD`); eight punctuation repairs with real curly punctuation preserved, and PDFium’s marked hyphens.
`packages/filmopen_fdx/test/office_test.dart`	Generated original Fade In, DOCX and RTF fixtures: typed styles and unknown elements, separate title pages, style-name/ID and indent paths, action paragraph boundaries, explicit pages and run/tab words, excluded Word containers, Unicode/ANSI escapes and skipped RTF destinations, scoped indents, last paragraph, prose/corrupt/unbalanced refusals and samples; ordinary and Unix-symlink ZIP members bounded before inflation; structured elapsed reader events and provenance; a cue and its parenthetical folded into the speech’s block; a headingless DOCX with a speaker per speech read, since the unreadable-text guard is for PDF only.
`test/pdfium_license_test.dart`	PDFium and its upstream notices on the licence page.
`test/media3_license_test.dart`	AndroidX Media3 and its Apache-2.0 notice on the licence page, logged `licence.media3.start` and `.ok`.
`packages/filmopen_engine_android/test/android_engine_test.dart`	The Android engine’s Dart half on a mocked channel: the handle on every command and an event channel per session, a seek completing with its own record, a displaced seek naming itself, a superseded scrub, an older revision dropped, native timestamps read as the nearest frame and a seek sent as the last whole millisecond at or before the frame’s native timestamp (frames 2, 37, 119; frame 2000 at 24000/1001), the same-frame answer restating the earlier record, a native failure answering every pending call, the clip and sound shapes, dispose before prepare, the clock bracket naming its source, platform and reason, and the clock never going back.
`packages/filmopen_engine_android/test/scene_test.dart`	A scene’s compile decided in Dart: the trims, the held last frame, a hold under one frame no hold with the trim kept within the file, and 4.980 s clips in 5.000 s blocks holding the dropped 60 ms at the third and owing again after it, the picture never a frame short, every lane padded to the duration (leading, middle, trailing gaps), own sound a speech lane, the gains, each video or audio source probed once and no still probed, `replaceTimeline`’s target.
`packages/filmopen_engine_android/test/subtitle_test.dart`	Each subtitle’s first and last frame and its half-frame window at 24/1 and 24000/1001 with Media3’s truncated timestamps, adjacent and one-frame subtitles, a subtitle with no frames sent as none, the text verbatim split at each newline convention, an unknown family drawn in Noto Sans.
`scripts/tests/test_walk_clip.py`, `scripts/tests/test_walk_dock.py`	The walk’s helpers: the generated clip and its log, the screenshots’ whole diagnostics, 4e’s replay and its end settling before it compares, 4f opening the dock only where its picture is absent.
`test/flutter_error_log_test.dart`	a Flutter error report written to the log (`flutter.error`) with its library, its message and the report’s context (§12)
`test/real_files_guard_test.dart`	no root test writes the person’s log or preferences (§12): `test/flutter_test_config.dart` gives every root test file a temporary log folder; the app started as the root tests start it writes its log there, the folders printed, the real log and preferences unchanged
`test/subtitle_fonts_test.dart`	the subtitles’ fonts (§19.2): Noto Sans and Noto Serif, regular and bold, bundled under `assets/fonts/` as TrueType files, and their OFL on the licence page; on Linux with libmpv alone in the bundle, the FreeType notice naming HarfBuzz, FriBidi, Fontconfig, libpng and zlib with their licences’ texts
`test/import_script_dialog_test.dart`	Import Script… in the menu, the desktop-only message where no file can be chosen and its log, the picker’s types, typed paths, injected Browse and its logged outcomes, cancel, inline error and retry, the not-a-screenplay sentence on prose, a Fountain file imported and opened, duplicate submission, destination availability, the import’s name, path and format in the log, and layout at 375, 532, 700 and 1200 pixels in light and dark.
`test/share_sign_in_test.dart`	on the whole application, on Share: a cloud film’s row asking for the account, its popup on Settings saying why, Google not asked, no Google wording, and the action sent once the account is signed in; Cancel ending the account’s wait though a Drive film was opened meanwhile, whose row asks Google; a sign-in not come within 30 s answering false; a Drive film’s row running Google’s sign-in as before with the account not opened; an unexpected failure logged with its type and its message and nothing sent; each trail logged; a sign-in published through `accountSnapshotProvider` alone ending the account’s wait and sending the action
`test/new_project_dialog_test.dart`	the new-project dialog in the whole app (§9.2): Login / Signup from the dialog opening the account’s popup on Settings with its reason, the account’s source replaced and signed in meanwhile removing both sign-in buttons, Create landing on the Project page with the new version on Edit; the same through a partial result’s Open the project
`test/render_input_fetch_test.dart`	The copy to a folder downloads the film’s media first, its log naming the parent and the folder before anything can fail, the folder made, and the destination as it is, a refused copy’s failure naming them too, and refuses on a failure; a mention’s picture never downloads
`test/exit_question_test.dart`	the window’s exit question on the desktop (§6.14), decided from the leaving: counted files asked after the preparation and before the tasks, Keep open undoing the leaving (the form’s send deferred again) and a second close asking again, Close anyway running the tasks; nothing pending, the jobs ended, no question and no Saving changes…; only an open form the leaving saved, no question; a draft not written, Close anyway?; a slow leaving showing Saving changes… (`exit.saving`) after 300 ms and closing it when it ends; Android never asked; the dialog at 700 px in light and dark without overflow; a film with no target is never asked; the question says the sync’s own reason (§6.14): a sign-in (a strict pass’s `signInNeeded`, a send held for one) the sign-in words, never offline nor the next time you open it; any other reason the neutral words; the offline words only for `unreachable`, the network’s code, and a target missing or not found (`unavailable`) the neutral ones; only uploads ask — any upload not yet done whatever its phase (a media upload waiting to retry, or held for a sign-in in the sign-in words, asks with nothing else waiting), one in flight named with its progress, a send pending, or a document differing from the ledger, each differing file listed under the sentence with its count; signed out or offline with the folder equal to the ledger, or with only a fetch under way, no question and `nothing-local` logged with the code; an inventory slower than the budget, a download in flight and the folder as agreed, no question; a complete leaving with a document still differing asks; the question shown and its answer logged with the same facts of the leaving, the paths included; with `FILMOPEN_CAPTURES` set, pictures of each sentence at 1200 px, light and dark
`test/exit_order_test.dart`	on a desktop target with a Material harness, answering Close anyway to a send held for a sign-in: the open film settles and sends before the exit tasks; a slow settle within the 3 s leaving leaves the tasks the rest of the one 10 s budget; a settle that never ends is waited for 3 s, then the person is asked
`test/assistant_session_exit_test.dart`	the quit with a chat’s recorded session (§7.4): the exit tasks close its `as` record — `status: closed`, `ended`, the items’ summary — inside the exit’s 10 s, no model asked; the same with a person’s close already running over a tool call that outlives the exit, held to the quit’s deadline
`test/open_project_test.dart`	A FilmOpen Cloud record opened on a fresh device over the real account provider (the token through `AccountAccess`), the documents counted down in the tree’s header, media left available; a remembered folder opened directly; a stale local folder updated without sending, its arrival waited for in the log — the fetch of that path done and the film published with the change — never by reading the file the sync replaces, which on Windows refuses the rename; the header’s mixed, blocked and Stop snapshots; an open that did not open said inline; the access seam installed lazily and put back. The dialog held against its barrier and Back while a record opens; an unexpected throw in a local open said by its type and logged at its stage with the folder and the message; a Drive record matched to a remembered folder only by folder id and tag; the header’s mixed active-and-blocked lines and a log line with `ms` per count change. Signed out, Login / Signup is held while a folder opens, so no control closes the dialog mid-open; the held read’s failure is then said inline and logged at the open.
`test/bootstrap_privacy_test.dart`	A bootstrap and open with a private username, tag and folder log the tag and the folder as they are, and never the token.
`test/settings_username_test.dart`	Settings → Identity signed in (§9.4): a pull-down of the names at 1200 and 700 px, light and dark, no box to type in, no Display name; a choice is the username; a failed read shown read-only with its code and Retry; no name yet shown read-only with the primary’s claim; a draft’s refusal said with Try again; a workspace kept at sign-in and dropped by a choice; signing out reopens the box on the username in effect; signed out the box as before.
`test/patch_release_test.dart`	over the real `DraftSaver`, `saveEntity` and sync service (§7.5): typing saved before a patch’s gesture publishes (its `beforePublish` seam, asserted to have run) is not released (`overtaken`): absent from the target while the form stays open, sent once it is left; a patch released after its gesture publishes sends while its form stays open, the send already parked for the form included
`packages/filmopen_ui/test/dashed_border_test.dart`	`AppColors.prototype` in both brightnesses; the dashed border as one stroke in its colour and width, dashes of 6 px every 10 px round the rectangle, a short last dash left a gap; repainted only when what it draws changes
`packages/filmopen_media_ui/test/media_tile_test.dart` (the border)	each state’s border at 700 px in light and dark from the values handed in — unreviewed orange dashed, outdated red, final green, draft green dashed, prototype blue, unknown with a retained stage and an upload the 1 px outline; the precedence unknown, unreviewed, outdated, the stage (outdated put over unreviewed fails it); the tooltip’s first span the status box — the caller’s own state, or one the tile builds from its stage with no reason — wearing the tile’s border, the outdated line next under an unreviewed box, no stage, Unreviewed or Outdated word in the lines after it, no box where nothing is said; the label led by the same word and sentence; the tooltip kept out of the semantics, the note’s words and the disabled reason in the tile’s semantics node instead; the box’s dashed and solid borders
`packages/filmopen_media_ui/test/media_state_test.dart`	`mediaStateOf`: the outdated sentence from the first change — the holder’s type (the document where none is named), a block, the covered blocks, a source named through `nameOf` or not, the stage — in an image’s, a clip’s, a sound’s and a file’s word; unreviewed with the outdated line next; current, a stage alone, unknown, no stage (Nothing has changed since it was added); nothing said, no state; the precedence over one table of fixtures (unknown moved below unreviewed fails it)
`packages/filmopen_media_ui/test/media_viewer_state_test.dart`	the viewer’s status box directly under the title, the outdated line next, the kind and size after; `media.viewer.open` carrying the state’s `status` and `reason` codes; no state given, no box and no status
`packages/filmopen_media_ui/test/provenance_test.dart` (`factLines`)	an entry’s length and size said with no record, facts agreeing with the record said once, the record’s said where they disagree, the disagreement’s own line beside them, a still’s 0 ms said, a size half known and nothing known said not at all
`packages/filmopen_media_ui/test/media_on_demand_test.dart`	The tile’s cloud mark, tooltip and ring, never downloading; the viewer’s Downloading… with progress, the file after, the failure sentence with its code, the path in its log
`packages/filmopen_insertion_ui/test/media_place_test.dart` (the batch’s frame, Pick, archive and trash)	at 375, 700 and 1200 px in light and dark, the unreviewed renders of one batch inside one orange dashed frame, each tile’s side clear, New once on the frame and still in each tile’s label, nothing overflowing, `media.batch.shown` naming the batch’s entries; the frame lasting while any waits, with no New once looked at; Pick removing `unreviewed` and writing `kept_at` (UTC to the second) in one edit through the page’s door, nothing else of the entry or the document moved, the picked tile leaving the frame with its check green and the lit check changing nothing, no check on an upload or a render reviewed without `kept_at`, the `.start` and `.drafted` lines with the flags before and after; archive on an unreviewed render, a reviewed one, an upload and, as unarchive, an archived entry, archiving deciding nothing of the review; trash on an unreviewed render alone, flagging it deleted without a question and asking the page’s delete door, the record kept, `.done` saying the door returned and naming `write.deleteTake` for the outcome; the page’s delete failing logged `.failed` and said under the tiles, and, failing after the element moved to another place, said nowhere and logged with its own place; a frame logged again when archiving one of three and unarchiving it brings it back as it was; Pick on an outdated render turning it red, Outdated and picked, no longer Unreviewed; the menu without Keep, Reject, Archive or Unarchive, Delete on all but an unreviewed render; a place that may not be written framing its batches with none of the three controls; the unreviewed-and-outdated tile’s label the unreviewed box, then The character changed after the image was generated; the viewer opening on the tile’s own state by a tap and by Open
`packages/filmopen_browser/test/takes_tab_test.dart` (the border)	the placements read once per tab by take (`takePlacements`), under either spelling, a repeat counted, a deleted entry, another extension and a block without an id not; a take placed once in the version shown wearing that placement’s review and status and its record’s stage; placed twice or nowhere its record’s stage alone, no status, no review, and Placement status unavailable; placed once, the viewer opening on the tile’s own state, naming the character; placed nowhere, the stage-only sentence in the tile and the viewer
`packages/filmopen_forms/test/media_card_test.dart` (the border)	keeping carries the preview batch’s model; a loose preview’s record stage and the status the draft gives it, nothing to review, its lines; a voice sample’s tile wearing its entry’s stage and review and its outdated status; each opening the viewer on the tile’s own state
`packages/filmopen_insertion_ui/test/media_place_test.dart` (an action’s own access)	an injected action that decides its own access (`gatedByEntityAccess` false) not refused by a version the film no longer holds, and its own refusal said under its name
`packages/filmopen_insertion_ui/test/media_place_test.dart` (Render from this take)	the item offered on a render’s take where Render applies, not on an import’s, running Render from the take at the place; dimmed with Render’s reason where it may not run, and absent without Render; Render at final resolution after it on a take asked at Draft alone, continuing at Final, dimmed with the same reason, absent on a Prototype or Final take and an import
`packages/filmopen_render_ui/test/render_dialog_test.dart` (a render continued from a take)	the record’s model on the route of the tag its version stem names, whatever the version, with its way and values; the recorded prompt and negative prompt whole and no treatment; the take’s seed, else the one sent unless the record says `seed_applied: false` (an applied seed is recorded by the key’s absence), else none; the stage; the request carrying `from`; the record’s model offered no more opening as new with the prompt, the seed, the stage and `from` kept; the recorded first frame kept and the take itself never one (K4); no style read again, the recorded prompt holding its words; a take continued kept at the place its record names, the record’s request as the writer writes it and the loader reads it — one recorded on this computer, naming none, staying here though a ready server of the same route comes first, one recorded on a server returning there
`packages/filmopen_render_ui/test/render_action_test.dart` (from a take)	`continueFrom` opening the dialog at the captured place naming the take, and the forced stage where one is given; an action that continues nothing answering null
`packages/filmopen_render_ui/test/render_dialog_test.dart` (a take rendered at final resolution)	refused in the body before composing or asking the picker at an outfit’s sheets and a block’s clips; the picker’s accepted Final row alone, the record’s prompt whole and no style read; no model chosen where the picker names none, fails or names a route not offered; the recorded first frame and references sent, never the first picture or the current favourite; each refusal by its code; a model changed by hand clearing or setting it; the logs carrying the take’s render id as the record holds it, whatever its shape, else the record’s stem
`packages/filmopen_media/test/media_provenance_test.dart` (`from`)	the take’s record, item, request and top container, `seed_applied` and `stack`, as the record holds them; none for an upload or an import
`packages/filmopen_media/test/media_fetch_test.dart`	The media store downloads a remote file before `open`/`read`, never before `exists`/`length`, and fails with the download’s code
`packages/filmopen_render_ui/test/render_dialog_test.dart` (first frames)	a frame’s tile wearing its record’s stage alone, an unreviewed entry’s review and status never handed; an upload no stage
`packages/filmopen_format/test/money_test.dart` (`ceilTo`)	`ExactDecimal.ceilTo` rounds the magnitude away from zero, exactly, keeping the sign: `0.0004`, `0.001` and the money scale’s smallest amount to `0.001`, `0.0037` to `0.004`, `0.0099` to `0.010`, a negative, zero, a value with fewer places only rescaled, a negative count of places refused
`packages/filmopen_l10n/test/amount_text_test.dart`	`amountText` (§9.5), every branch: zero, the sub-cent amounts with their one raised digit (`$0.00¹` … `$0.00⁹`), `0.0099` as `$0.01`, a cent and more to the cent half away from zero, an amount with more places than the money scale, negatives below and above a cent with a true minus, another currency by its code, the Spanish decimal mark; `signedMoneyText` to the cent with its sign before the mark
`packages/filmopen_keys/test/usage_tab_test.dart` (under a cent)	a use costing less than a cent reads `$0.00⁴` in its line and in the month’s total, never zero (§9.5)
`packages/filmopen_forms/test/script_editor_test.dart`, `prompt_sections_test.dart` (the block’s clip prompt)	a shown Clip place under the block’s clip Prompt card, above its take; a block holding no clip shows neither until Add a place… → Clip, the frames still always shown, while a block with a stored `prompts.clip` and no take shows its Clip place, its drawing logging nothing; Generate on it writes the block’s `prompts.clip`, the writer asked `clip` with the block alone, no covered blocks and no tokens, `prompt.generate.tokens {kind: clip}`; a block without a take, Add a place… → Clip, then Generate on three paths — a mouse click with the focus where the menu left it; a mouse click after a click in the prompt’s positive box; the button given the focus and Enter pressed — each written with no take, the project re-read, the card collapsed, the block still open on its Clip place, and on the second path closed and opened again with its Clip place there (§9.3)
`packages/filmopen_render_ui/test/render_dialog_test.dart` (the span’s prompt, the bound)	a clip of one block hands its writer none covered, a clip over three the later two in order; discovery, price and Generate asked for the entry chosen — never its way — and the new one after a change; the words as sent above the way’s `max_characters` hold Render with `render.prompt.length.refused` and `render.prompt.length {outcome: refused}`, a way’s own bound in place of the entry’s (`ok`), none stated `unbounded`, then sent whole, the words in `render.prompt.length` and, once assembled, `render.prompt.final` (§9.3)
`packages/filmopen_render_ui/test/render_preparation_test.dart` (the bound)	`renderPromptBound`: the root’s, an unknown way’s the root’s, a way’s in its place, none stated; `renderPromptChars` counting code points; a command’s words as sent above the bound: not ready, `prompt-too-long`, `render.prompt.length` with its `ref` and `render.prepare {stage: prompt, ok: false}`, within it sent whole (§6.15)
`packages/filmopen_state/test/workflow_scope_test.dart`	what a Workflow focus gathers (§7): at the project every scene in the walk, a cycle, a second listing and a deleted folder left out and its scene walked in its place; a character at each occurrence epoch — a speaker at the scene’s, a cast entry at its own — with its outfits at that epoch, a fallen-back epoch marked as a use of the stem shown first, its outfits those at the occurrence epoch; a location at its `location_epoch`, a prop as a tag and as `{prop, epoch}`; an unresolved cast tag skipped `noEntity`, an explicit cast epoch with no version skipped `noEpoch` while the same character at an implicit epoch falls back, in either walking order; the answer’s nested lists immutable; a folder and a scene each answering only what is beneath them in scenes and props, the inventory after the walk; a character the viewer picked shown as picked, though the official scene would read official; a throw logged `workflow.scope.failed` and thrown on; every character and location of the project after the walk — one used only in another folder listed without the mark, one in no scene with it, `used` and `added` logged; a recycled group absent, a version deleted at one epoch skipped there and listed at the other, a deleted version a scene names, prop included, claiming no row; an implicit fallback counted at the version it resolves to, an explicit epoch with no version counted nowhere and logged; a speaker outside the focus and outside every cast at that epoch counted; a recycled scene version counted; a version a fallback already shows adding no second row, skipped `alreadyShown`, unless it brings outfits; usage resolved for the viewer; a library group listed only where a scene uses it, else skipped `library`; props not added; the provider gathering once per snapshot and focus, again after a write and for another viewer, and null for a stem the project does not hold.
`packages/filmopen_account/test/provider_funding_test.dart` (HTTP scopes)	every platform offered the funded HTTP scope without a local provider list, xAI, Atlas Cloud and Salad reaching the portal through stand-ins; the scope on the decision and session lines, own keys still first (§6.6)
`packages/filmopen_plugin_host/test/http_door_test.dart` (pass targets)	base-origin and listed other-host targets sent to the corresponding pass path, path and query retained and logged whole; an unlisted host refused before credentials or transport (§6.6, §6.11)
`packages/filmopen_plugin_host/test/server_binding_test.dart` (gateway credit)	a keyless funded Salad server’s HTTP, two collects and output download on the pass-through with portal headers and the job’s one UUID from its 32 hex digits, plus a UUID-form job’s identity preserved in the failed-download test; the keyed route unchanged; no credit refused no-key and no credential not-funded without sending; running-server readiness on credit and noKey without it; credential-free no-gateway and not-listed paths logged as info routes with road none, throwing refusals as warnings, route diagnostics and no credential in logs (§6.11)
`packages/filmopen_plugin_host/test/http_door_test.dart` (gateway upload), `packages/filmopen_plugin_host/test/server_binding_test.dart` (download diagnostics)	16 MiB of upload media plus framing sent and an encoded body over 17 MiB refused before transport, bytes, limit and refusal logged; a successful download’s status, byte count and milliseconds, and a refused gateway output’s status, refusal code, operation state, whole text and milliseconds, no retry or success line; a failed transport and a stopped download log their phase, cause and elapsed time, with no late success on Stop (§6.11)
`packages/filmopen_plugin_host/test/match_price_test.dart` (bundled Z-Image)	the bundled Atlas Cloud image price read as USD 0.015 and fal’s megapixel price retained at USD 0.005 (§6.7)
`packages/filmopen_forms/test/block_media_places_test.dart`	a block’s places outside the script editor: `groups` null draws the Script page’s places — the frames, what the block holds, Add a place… — and logs no `media.block.places`; given, exactly those places, empty or not, a held group not named left out, no Add a place… even read-only, and `media.block.places` with the stem, the block, the groups and those shown
`packages/filmopen_forms/test/script_editor_test.dart` (the menu’s log)	Add a place…’s `block.place.opened`, `.chosen` and `.cancelled` name the scene’s stem, the block and the groups offered by name, the chosen group, and the elapsed time
`packages/filmopen_forms/test/embedded_form_test.dart`	`MediaFormCard`: a character’s, an outfit’s, a location’s and a prop’s card draw only their named places, each under its Prompt card (the character’s voice too), no loose preview, logging `workflow.form.start` and `workflow.form.built`; a throw choosing the type’s form logged `workflow.form.failed` with its stage and time and rethrown; a scene’s card each block’s First frames, Last frames and Clip, Speech only where it has a speaker, no Add a place…, and none for an id the scene gives twice; two failed cards on one page each with its own `<stem>.draft.discard`; a clean card disposed when scrolled out of a `ListView.builder` and a dirty one kept alive, then gone once written; a card scrolled away while saving whose write fails stale, kept alive and found again on the same draft with `<stem>.draft.discard`, for a character and a scene; a read-only card with no status and no keep-alive
`packages/filmopen_insertion_ui/test/media_place_test.dart` (the checkbox)	under a `PlaceSelection` an offered place leads its title with a checkbox labelled by the title, each tap toggling the set and logging `workflow.select.start` with the selection before it, then `workflow.select` with the place, the key, the stem, the group, the value and the selection; a toggle that throws logs `workflow.select.failed` with the selection it attempted and its time, and rethrows; a place not offered, an offered place that is not editable, and a place with no selection above it draw none

The state project_test.dart suite also verifies that imported characters and unassigned outfits may share plain or dotted tags without colliding in the tree, and that an unassigned outfit keeps the two warnings of any undotted outfit. converter_test.dart also verifies that an imported project’s one epoch is its owner’s <owner>-1 with next_epoch 2; open_settles_first_test.dart that an import waits for the film’s queued writes and is refused as drafts_unsaved at their limit; reference_codec_test.dart and create_outfit_test.dart that a UUID tag is read and encoded whole in a mention and takes an outfit, an ordinary segment still bounded at 32.

Test	What it verifies
`packages/filmopen_render_ui/test/render_preparation_test.dart` (saved words)	Bulk preparation refuses missing saved words before picker, writer or options; clips ask i2v with a first frame else t2v, retain saved clip words, and explicit words win (§6.15).
`packages/filmopen_render_ui/test/first_frames_test.dart`, `render_preparation_test.dart`, `render_dialog_test.dart` (clip preparation)	Shared choices obey way, mappings, favourites and spans; missing required inputs refuse with codes; preparation sends the chosen first frame and the dialog retains personal/recorded choices, logging each chosen and excluded reference (§6.15).
`packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_dialog_test.dart` (speech)	Speech and audition text use the kept voice on its platform despite the picker platform, carry the voice ID and catalogue character estimate, and refuse a missing voice before options (§6.15).
`packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_dialog_test.dart` (outfit preparation)	Bulk outfit sheets retain wearer-first picture numbering, both source snapshots and missing-wearer refusal before options; the dialog retains its draft, freshness and reference-bound behavior (§6.15).
`packages/filmopen_render_ui/test/render_queue_test.dart` (selected pass)	Only chosen items submit, other items stay byte-for-byte untouched and pending; a selection already taken writes nothing; a later ordinary pass submits the rest (§6.15).
`test/queue_composition_test.dart`, `packages/filmopen_state/test/queue_runner_test.dart` (preparation seam)	Ready and unavailable preparations retain route, model, platform, known or unknown cost and frozen item; null preparation answers no-route; backend is read from the current manager per call; selected submission crosses the seam (§6.15). The check before writing (§9.3): an outfit sheet with no pictures `referencesBelow` where its model has a minimum, the same outfit with an inspiration ready with nothing prepared and logged `wordsDecide`, a place with no tokens that can run ready with no item, a clip prepared on the stand-in word though the film has pictures.
`packages/filmopen_render_ui/test/render_preparation_test.dart` (outfit kind)	A resolved outfit sheet asks the picker for i2i with or without picture tokens, opens the i2i model with wearer-first inputs, and logs kind, outfit reason and supplied ref (§6.15).
`test/workflow_tab_test.dart` (the frozen heading)	At 1200×800 px on a film of three epochs: the tab’s top names no entity; scrolled within Mia’s card, Mia at 1990 is drawn at the list’s top; within Zed’s, Zed at 1990 replaces it; the Locations heading at the top clears it; a scene’s card names the scene; scrolled back up, Mia again. A film of 100 scenes of three blocks each mounts no card at the top and two halfway down, where the heading names Scene 50.
`test/workflow_tab_test.dart` (the media sections)	On a scene, a folder and the Script page, a live change of theme, both ways, repaints a section heading and a row heading in the new theme’s colour. On three epochs with a fallback, a version used at two later epochs, an outfit named differently at two epochs, Bob’s prop and a scene giving a block id twice: at the project, a folder and a scene, each section’s lines in order (a folder’s and a scene’s own scenes and props only, the project’s other characters and locations after the walk’s), a fallback saying which version it shows, a later use of a version a heading with no card, Bob’s card not writable; the Characters, Locations and Props empty states, Characters’ with and without a plug-in chosen and after its read failed; a character and a location in no scene marked Not in any scene, nothing checked; the character under its title, offered, taken by Select all and logged `inScene: false`, one a scene uses logged `true`, an outfit’s row carrying no such key; a row kept for its outfits at its version’s own epoch reading its plain title, and a walked one without outfits still reading Kai at 1990 — uses Kai at 1990; `workflow.places.shown` once per scope; a failed card keeping its saver and its `<stem>.draft.discard` when a plug-in chosen adds steps above it; two uses of one version at two epochs keyed apart and found at their own lines before and after; the places offered equal to the editable places the cards draw, with each decision logged; Select all and Select none per section, logged; the selection dropped and logged when another focus is opened; nothing overflowing at 700 and 375 px, light and dark
`test/workflow_tab_test.dart` (Render)	With a stand-in queue runner: Render counts the checked places and is disabled with its reason while none is; the places prepared are the cards’ own targets, accepted kinds included, for a place not built and a voice sample, in the sections’ order; two presses while preparing start one press, Render says why it waits, and a second confirmation adds nothing; a checked place that left the scope under the same focus stays checked, is said no longer here and is never prepared; a draft that cannot be written stops the press with its own error before anything is prepared; the summary sums the known costs, lists an unknown price apart and the skipped places in words, and Cancel adds nothing; a skip with no words names where they are written, at a voice sample, a block’s voice line and any other place, its code unchanged in the log; nothing ready disables the confirmation; Render adds only the ready items and submits exactly their numbers, an item already waiting not among them, and Open opens that record; a pass that answered clears the places it took, the places skipped in preparation staying checked and counted by Render, as does a place checked while the pass runs, logged `workflow.render.cleared`; a pass answered `busy` or `film-changed` is said in the queue’s words, claiming nothing sent or not, every place still checked; a cancelled summary leaves every place checked; a pass that throws is logged with its stage and said as a failure, every place still checked; at 700 and 375 px, light and dark, Render is on screen and the summary fits; at 1200, 700, 532 and 375 px its rectangle stands below the list’s and clear of it, 20 px from the right, nothing overflowing.
`test/workflow_tab_test.dart` (the Generate box)	With a stand-in Smart and Basic: the prompts summary before any `buildPrompt`, Cancel making no call and leaving the boxes, Write answering once and asking Smart per ticked place in order with its pair and the decision offered, its words saved as its own; Basic asked unagreed where Smart has no model, is no stock writer or is not `fo-prompts`, and named free in the render summary; a null quote reading price unknown and still asking first; two models a line each; a paid failure and a changed decision skipped, with no Basic and nothing prepared; a writer gone by its write refused unasked; the button’s Writing prompts 1 of 2… with the first answer held; the tab left during an answer, a `credit` refusal, a throw and a save with no form open, each stopping the pass and said in a message; the box’s tooltip naming both writers. With a stand-in Basic writer: the box’s default per state on every picture and clip place and none on a voice sample or a read-only card; a choice logged, held across a relayout and dropped back at its default; the overrides reset with the selection; the box beneath the title on a narrow card; each place reading checked written then prepared, one outside the built rows, a current one left unless ticked, a tick spent once written; a neighbour still current after a write; no writer asked where Basic is absent, is no template or is no stock writer; the draft gone, replaced or refused at each wait with nothing written elsewhere; words typed during the ask, positive or negative, kept, and words saved meanwhile with no draft; no draft: the original untouched, the prompt current, a moved file refused; a card written collapsing unless its text field has focus. The check before writing: a place it refuses out of the prompts summary, not written, not prepared again, its box kept and its reason in the render summary; every place refused, no prompts summary and no call; each of the five reasons only words can settle still written and prepared again; the tab gone during the check, nothing agreed or written and the left-out places told; a changed decision, whether the writer has gone or the host refuses it, read in the summary as a sentence, its code unchanged in the log.
`test/workflow_tab_test.dart` (the clip that waits)	With a stand-in queue runner and Basic, over a scene of two blocks: a clip whose block’s first frame is in the same press asks no writer and neither preparation door, is not queued and stays checked, while the other block’s clip with its frame landed is prepared; the summary shows the waiting line, `workflow.render.summary` lists it under `pending` and `workflow.generate.decided` says `first-frame-pending`; after its frame lands the next press prepares it; a clip with a frame already waits when that frame is regenerated in the same press.
`test/folder_working_list_test.dart`	A folder’s page on the version in use with the viewer’s assistant draft holding two scenes: its Script tab and its Workflow tab read the draft’s list, the scope offering both scenes’ block places, the outline lines naming `source`, `rows` and the list’s file; a version the script does not draw reads its own outline, followed into its subfolders; a scene the script read in an earlier folder is not read again.
`test/session_page_test.dart` (a scene item’s block media)	At 1200 and 700 px, light and dark: the place holding an entry, no prompt editor, no write door, a bare block drawing nothing; a block whose only frame was deleted draws no place; a clip landing appears without reopening the page, `session.item.media` once per change.
`packages/filmopen_forms/test/embedded_form_test.dart` (`sceneBlockMedia`)	Over a scene of three blocks with a first frame and a clip each: `prompts: false` mounts no `ProseEditor` and no prompt identifier, `prompts: true` both; the Workflow card still mounts its prompts and says so in `workflow.form.built`.
`test/workflow_tab_test.dart` (Render’s Open)	Open on the result after another film was opened — while the pass ran, and once the message is shown — is refused, said and logged with the film, and opens nothing; the success logs its film, record, outcome and time; the preparation’s known codes (`referencesBelow`, `referencesAbove`, `busy`, `no-last-frame`, `no-voice-line`, …) read as sentences, never as their code.
`packages/filmopen_forms/test/character_birth_date_test.dart`	year/month/full-date entry fills the Age box and draft, a month past 12 refused inline; an opened matching birth date does not lock Age; a session fill locks in the theme color, kept and clearing unlock; malformed text stays inline without a draft change, and View suppresses editing errors; a four-digit Age entry seeds Birth date and Age, and a kept year retains its error/text while restoring draft age; fill decision logging
`packages/filmopen_forms/test/clipboard_asks_form_test.dart`	a character’s form in Edit at 1200 px over a platform whose clipboard holds text (§4.2): without the clipboard asks every field’s ask goes out, through them the build’s asks are one native ask, and typing’s rebuilds, which ask again per field, at most one native ask a frame

The browser landing tests also pin a supplied parent id moving to its picked author while showing an older picked stem, an exact pinned scene, comparison-pair preservation, single-author project root highlighting, initial project-version landing, and a read-only chooser’s exact session choice without a commentary write. Navigation log assertions retain the requested node and resolved stem/node, reason and elapsed time. A whole single-epoch character still exposes New outfit.

The project-page warning tests mount the actual detail pane, check the initially folded complete count and diagnostic text on a read-only project version, the zero-warning message, and the empty-folder diagnostics landing. They assert the fold gesture’s state, full diagnostic text and elapsed time, and retain narrow light/dark layout checks.

The numbered project and character plans assert that a sole author leaves no author children under the project or epoch, then navigate to an exact older or newer stem for the existing fork, official, pick and comparison checks. The outfit plan reaches New outfit through the whole-character epoch overview. Desktop and drawer acceptance walks cover the same tree and project landing.

Tests	Credit behavior
`packages/filmopen_account/test/account_portal_test.dart`, `account_balance_test.dart`, `account_funded_test.dart`, `packages/filmopen_plugin_host/test/http_door_test.dart`	Session after 25 seconds, cancellation of bearer, acquisition, balance, receipt and End; no dispatch after Stop.
`packages/filmopen_plugin_host/test/assistant_policy_test.dart`, `usage_chain_test.dart`, `assistant_action_test.dart`	Three distinct operations with sessions prepared for calls two and three; a prepared operation still in flight logs prepared true and ready false; a Stop-triggered End receives no cancelled abort and precedes the stopped call’s receipt; Stop during call two preserves call one’s late charged successor and the closing balance refresh; durable pending before continuation and late charged amendment; writing tools exclude session while the external command survives.
`packages/filmopen_assistant_ui/test/assistant_dock_test.dart`, `assistant_widgets_test.dart`, `packages/filmopen_keys/test/provider_keys_tab_test.dart`	Credit and empty-keyring presentation at 700 px in light/dark; credit-covered partial loss preserves confirmed recovery and the shown log in Settings and the dock; selected route readiness; three admission messages and ordinary continuation through Try again.

The program door has these focused tests, beside the ordinary plug-in suites.

Tests	Program behavior
xAI video: `packages/filmopen_plugin_host/test/marked_rows_test.dart`	The xAI first-frame video catalogue’s marked rows admit only the video entry with upload, all three variants decode without issues with Lite first, and five seconds of Lite at 720p costs USD 0.15.
`filmopen-plugins/tests/xai-video.test.mjs`, `filmopen-plugins/tests/xai-render.test.mjs`	The API checks own/funded key requests and embedding, the durable fence/readback and replay, preserved admission/HTTP refusals, one GET per poll, completed MP4, reported or estimated billing, failed/expired charges, honest unknown cancellation and per-choice duration/resolution pricing; its README check keeps those rules documented. The program’s clip cases check the frozen first frame, `reference_to_video` profile, native duration/resolution options, MP4 path staging and exact ZDR/API-choice refusal with whole-word logging and no automatic fallback.
`packages/filmopen_plugin_host/test/program_media_test.dart`	Program admission is independent of render marks and upload permission, bounded by declared kinds, optional models and configuration; real unmarked xAI image rows offer only the program. Every program reference and first frame is frozen with the known MIME extension and immutable bytes, with absolute paths on call inputs alone; key calls retain only their first reference and expose no path.
`packages/filmopen_plugin_host/test/media_back_test.dart`, `packages/filmopen_render_ui/test/render_offers_test.dart`	Program-only path staging checks exclusive input form, absolute/readable files, MIME/role, inherited authorization and ended callers; a large MP4 has no new output cap. Inline stage start logs omit encoded bytes while completion retains MIME, length and handle. MIME extensions work through path lookup, open, read and release, a kept picture survives sweep, and legacy extensionless files remain readable. The two real xAI image entries intersect API ratios with the six program choices, retaining auto and refusing unsupported values.
`packages/filmopen_render_ui/test/render_dialog_test.dart`, `packages/filmopen_render_ui/test/render_preparation_test.dart`, `packages/filmopen_render_ui/test/auto_references_test.dart`	The dialog and Auto-generate route line name the program candidate’s setting label before rendering, without a subscription or free-use claim, and the route log carries that same funding label. Grok Build and Codex share the sentence; ordinary local routes retain their local price.
`filmopen-plugins/tests/xai-grok.test.mjs` (tool-less writer)	An image-prompt writer’s completion, with tools absent or empty, succeeds where the assistant-only relay would be refused: process start requests no tools, the session has no MCP server and its inline profile has an empty tool list. The whole prompt, terminal text and native usage remain intact, the owned process stops, and the decision and session logs name the absence of tools. These fixtures prove the mapping for the nested prompt-writer scenario, not a signed-in model turn.
`filmopen-plugins/tests/xai-render.test.mjs`	Scripted ACP proves fresh private cwd and the two-image-tool profile, logging a bundled non-image tool’s start/completion with its name, retained kind and whole input/output while only images are staged, text generation, ordered editing paths, path staging of every completed image, native tokens and account without billing, and options without a process. Failed tools retain words and usage, other finishes/no image/process exit/staging failure answer honestly, owned lanes stop while busy foreign lanes remain, and extra images, missing usage and a refused stop retain their prescribed results. Unsupported image filename extensions name `grok-image`; host staging refusals preserve their code and name the returned path and host reason, logged with the original error. These fixtures prove the protocol mapping, not a live Grok image.
`packages/filmopen_plugins/test/program_setting_test.dart`, `packages/filmopen_plugin_host/test/program_path_test.dart`	Program settings are machine-only, refuse defaults and entity scope, resolve executable names without extensions, and name their number of copies in `parallel`. Discovery checks executable files and Windows PATHEXT, including a command shim.
`packages/filmopen_plugins_ui/test/program_box_test.dart`, `packages/filmopen_forms/test/plugin_sections_test.dart`	Consent names every program and its access. Discovery needs explicit acceptance; typing saves another path, an invalid stored executable is said, and project forms exclude program settings.
`packages/filmopen_plugin_host/test/plugin_log_test.dart`	Every process door without the capability is refused before dispatch, with its full arguments, reason, code and elapsed time logged.
`packages/filmopen_plugin_host/test/parallel_program_calls_test.dart`, `run_exposed_test.dart`	Chat and render on a program whose number of copies is above 0 overlap in both orders, their slot rows carrying the number, and preserve separate storage keys. Other routes retain serial ownership and wait/timeout behavior, all roots keep the five-slot bound, and admission logs retain one identity through waits, refusals and release. Disable stops both lanes with honest failures and prevents a start after the Usage await.
`packages/filmopen_plugin_host/test/program_copies_test.dart`	The number a program’s `parallel` names, as the host reads it and logs it; the program’s render capacity from it; its edit stopping the program’s lanes; a program without one serial across tool rounds; at 0 a same-setting picture waits outside runner slots, succeeds after chat continuation stops the process, or cancels without stopping the chat; at three copies it overlaps with a logged no-wait decision.
`packages/filmopen_plugin_host/test/process_door_test.dart`	At 0 copies a Check that starts with its frame’s operation and only receives owns the single process from the start, so cancelling the call stops it (`ownerEnded`) and the next Check starts afresh. Exchange survives fresh JavaScript calls; first-send ownership, busy refusal, release, whole lines, stderr, exit codes, stable default and explicit working folders, cancellation, an exited root’s inherited pipes and owned-child shutdown are checked. An owned-process wait spans chat traffic and ends on process stop or waiter cancellation, leaving chat ownership intact on cancellation; absent, exited and unowned processes are immediately free. A foreign-owner stop refuses busy without damaging owner traffic; own, unnamed and unowned stops still work, with complete decision/outcome logs. Linux preserves spaces and ampersands; the named Windows command-shim case checks spaces in its path and argument.
`packages/filmopen_plugin_host/test/host_runtime_test.dart`, `packages/filmopen_plugin_host/test/lifecycle_test.dart`	Disable, failed switch writes, hung calls, program-setting edits and exit stop owned processes. A concurrent unrelated setting edit survives shutdown.
`packages/filmopen_plugin_host/test/contract_test.dart`	Completion operations come from the assistant or caller frame. A frame ending done, failed or stopped stops its remaining owners across provider tags, and a subsequent start has no stale queue. The frozen bridge and definition expose all five process doors.
`packages/filmopen_plugin_host/test/assistant_action_test.dart`	Stop during receive, between calls and during finalization hands over once on a fresh ledger; failed, refused and stale turns also hand over. Missing, throwing or wall-expired interrupts stop owned work. A cleanup fault still clears the existing active control. A fake clock past ten minutes leaves completion waiting, and Stop still ends it.
`packages/filmopen_js/test/engine_test.dart`, `packages/filmopen_plugin_host/test/run_offer_test.dart`, `dev_run_test.dart`	Null wall keeps long sleeps cancellable. Ordinary, nested and both developer-mode completions have no wall, log that choice and preserve other limits; the explicit flag overrides requested and granted walls.
`packages/filmopen_plugin_host/test/reference_test.dart`, `packages/filmopen_plugins/test/contract_test.dart`	Generated types and reference match the pinned revision-one definition. The author guide explicitly lists each built process door and agrees with its arguments.

Signed-in routes

Tests	Behavior
`packages/filmopen_plugin_host/test/provider_tool_turn_test.dart`, `packages/filmopen_format/test/platform_file_test.dart`	The real bundled OpenAI plug-in completes a tool turn with an in-memory ChatGPT credential: instructions and additional tools, streamed HTTP without system input or output cap, calls and outputs replayed, and terminal plan Usage with tokens and no USD. The catalogue case pins dynamic ChatGPT plan registration, identity and plan scopes, persistent-host parameter, resource on authorization and both token grants, discovered endpoints and issuer, plan label and absent output cap, while preserving API-key authentication and the existing API host and credential paths.
`packages/filmopen_plugin_host/test/sign_in_door_test.dart`, `packages/filmopen_js/test/engine_test.dart`, `packages/filmopen_plugin_host/test/media_out_test.dart`	Loopback PKCE, state, nonce, issuer, audience, expiry, required scope including an omitted identical scope response, client/account continuity, storage refusal, revocation and sign-out queued during refresh are checked with mock endpoints. Only slot identifiers cross the JavaScript sign-in bridge. Expired OAuth refreshes before HTTP; a 4xx refusal except 429 clears both records without dispatch, while transient failures keep them. Browser refusal leaves no unhandled callback error, store reasons are logged, the ledger names the slot, and Stop cancels embedded HTTP preflight without a late write. Ordinary refused request arguments are logged and host-added bearers are absent.
`packages/filmopen_plugins/test/plugin_manifest_test.dart`, `packages/filmopen_format/test/platform_file_test.dart`	A sibling OAuth block preserves key authentication, requires each field, secure endpoints and a boolean output-cap choice. A manifest slot defaults to key authentication, accepts OAuth and refuses an unknown authentication kind.
`packages/filmopen_state/test/plugin_key_slot_test.dart`, `packages/filmopen_plugin_host/test/assistant_action_test.dart`	Slot views preserve authentication/account/expiry on one platform. Route precedence is signed-in, program, manifest-ordered copied keys, then credit; OAuth omits its output cap and a rejected signed-in turn never attempts the stored API key.
`packages/filmopen_plugin_host/test/usage_chain_test.dart`, `assistant_action_test.dart`, `packages/filmopen_format/test/usage_record_test.dart`, `packages/filmopen_keys/test/usage_tab_test.dart`	Plan/local records round-trip labels, retain tokens and refuse prices or credit operations. Real local assistant completions and tool continuations each end their own chain; HTTP500 ends failed without cost/basis. Stopped program turns record completion and fresh handover separately, including handover tokens/account label. Usage reads the route before cost or totals, including started local records.
`packages/filmopen_plugin_host/test/sign_in_door_test.dart`, `packages/filmopen_format/test/platform_file_test.dart`	One installation UUIDv4 survives sign-out and later doors; authorize/token placeholders use the bare UUID. Optional string token parameters accompany exchange and refresh. Concurrent expired calls make one serialized refresh; queued sign-out revokes and clears the refreshed credential.
`packages/filmopen_plugin_host/test/sign_in_door_test.dart`, `packages/filmopen_format/test/platform_file_test.dart`	Grok’s declared callback path survives an unrelated favicon request and private-network preflight with the exact CORS headers. Missing token fields are identified without credentials; metadata failures retain their cause and stack; revocation logs before sending. The root callback remains the default.
`filmopen-plugins/tests/xai-text.test.mjs`, `xai-image.test.mjs`, `xai-video.test.mjs`, `xai-render.test.mjs`	Signed-in text and Check retain the selected slot and provider refusal words; a metadata-door failure logs start, cause and terminal refusal. Image generation and one or multiple reference edits preserve bodies, ordered embeds, staged inline bytes, enum defaults and provider cost; a key image route sends nothing. Video submit, pending, completion and durable replay keep the same signed-in slot, while explicit program rendering remains available.
`packages/filmopen_plugin_host/test/render_backend_test.dart`, `assistant_action_test.dart`, `contract_test.dart`; `packages/filmopen_render_ui/test/render_preparation_test.dart`, `render_dialog_test.dart`, `auto_references_test.dart`; `packages/filmopen_state/test/route_words_test.dart`; `test/settings_models_test.dart`	Declared plan kinds admit unmarked image rows with the selected OAuth slot, unknown quote, billing capacity and no credit fallback. Required media keeps the upload gate. Programs are manual and last; Automatic skips them while explicit choices remain honoured. Route rows expose image support, Usage names the saved account, and Settings, the dialog and Auto-generate use plan wording without a free-use claim.
`packages/filmopen_keys/test/provider_keys_tab_test.dart`, `packages/filmopen_plugin_host/test/assistant_action_test.dart`, `packages/filmopen_plugin_host/test/program_path_test.dart`, `packages/filmopen_plugins_ui/test/program_box_test.dart`	OAuth cards include sign-in-only own platforms and invoke declared slot doors without actions or credential reads, show signed-in metadata and identical never-signed-in/cleared states. The terminal refresh refusal remains visible while the session becomes stale and refuses further sends. An isolated agent fixture may seed account/expiry metadata for signed-in captures; ordinary builds still ignore such preference seeds. Normal owned replies hand over as unreleased. Program labels avoid duplicate discovery and consent owns its label placeholder.
`packages/filmopen_assistant_ui/test/assistant_dock_test.dart`, `packages/filmopen_plugins_ui/test/plugin_check_test.dart`, `packages/filmopen_plugin_host/test/plugin_views_test.dart`	Dock/page readiness uses the shared plug-in / origin words from the decided route, with the exact OAuth slot label or program, copied key, credit or local origin. A frozen opening refusal names its rejected identity after settings change; a page’s unavailable choice replaces credit-ready wording; at 700/1200 px in light/dark, a non-preferred stale page clears only its own route with Use Automatic, while the preferred page uses Models. Usage fragments stay unchanged. The page receives the host route decision; a remote text platform with a configured server does not become local in the page.
`packages/filmopen_state/test/provider_funding_test.dart`, `packages/filmopen_account/test/provider_funding_test.dart` (credit readiness)	The inert query answers false; stored API and OAuth slots leave credit-only readiness independent of credentials and HTTP, ordinary funding stays own-key-first, unavailable account/device/balance states refuse with their logged reasons, and an unexpected metadata failure is logged and propagated.
`packages/filmopen_plugin_host/test/assistant_action_test.dart`, `packages/filmopen_plugin_host/test/http_door_test.dart` (explicit completion routes)	A chosen program wins beside a signed-in slot; credit with a stored API or OAuth key reaches the portal without reading credentials; a pinned key cannot spend credit. The first explicit-credit answer uses the existing opening wait and then runs on credit; refresh keeps the previous route without an extra publication or repeated-positive notification, and a false answer refuses the next opening. Automatic completions without funding still run in common and developer admission. Cleared programs and disabled chosen providers refuse before code or requests, unrelated stale choices do not block, and Automatic retains the provider preference and existing platform-wide own-key behavior. Route choices log the original and saved identity, candidates, publication and elapsed time.
`packages/filmopen_state/test/route_words_test.dart`, `packages/filmopen_plugin_host/test/render_backend_test.dart`, `prompt_writers_test.dart`, `packages/filmopen_render_ui/test/auto_references_test.dart`	Origins name the exact program beside a signed-in slot, key, credit, local or selected destination. Render candidates preserve decided funding through relabelling, and writer origins travel outside the unchanged model/quote tuple. Auto-generate retains writer estimates and picture prices beside their decided origins.
`packages/filmopen_plugin_host/test/assistant_action_test.dart` (a chosen route that is unavailable)	the refusal per model (§6.11a): Codex’s program chosen on OpenAI and cleared, Kimi K3 decided on the OpenRouter plug-in’s credit with `doesNotServe` and no `routeUnavailable`; Terra, which OpenAI serves, refused `routeUnavailable` with the model and `enabled` on its `tried` row; the chosen plug-in off refuses a served model and sets an unserved one aside
`packages/filmopen_plugin_host/test/assistant_action_test.dart` (group `routes`), `plugin_views_test.dart`, `comfy_platform_test.dart` (Check’s route)	every route a plug-in runs on (§6.11): program, sign-in, key and credit in the owner’s order while Automatic still takes the sign-in; credit `notSignedIn` signed out beside a stored key, `noCredit` at a zero balance, the change alone publishing and logged with `why` and `whyBefore`; nothing stored, each row’s reason; a render-only model plug-in on fal listing the key of the platform plug-in it calls and credit, image only, its credit asked at the first read and following the account; the rows kept through every publication of an Off; a model plug-in rendering through the local platform plug-in it calls ready on that plug-in’s server, named `via`; the summary carrying the callback’s rows
`packages/filmopen_plugins_ui/test/plugin_check_test.dart` (the routes)	Check’s route rows (§9.4) at 700 and 1200 px, light and dark: four rows with their ✓/✗ marks and colours, origins, what each makes and the red reasons; a render-only plug-in’s (image only) rows, This computer and a reason with no words of its own
`packages/filmopen_plugins_ui/test/plugins_tab_test.dart` (a number out of range), `packages/filmopen_render/test/lending_route_test.dart` (a program lent), `test/settings_models_test.dart` (the folded row, the Model field)	a number below `min` or above `max` said under its box, nothing saved, logged `plugins.settingBox.refused` with its reason, both ends kept, the refused text kept through a stored change; a program candidate lent keeps its program; a lent offer ahead of a keyless local route reads this computer, both fundings logged `folded`; at 700 px, light and dark, a model not ready here holding its name alone in the field (measured) and saying so under it

Claude on a key and on Claude Code

Tests (in filmopen-plugins) Behavior

tests/anthropic.test.mjs The Messages API streamed against stand-ins shaped from Anthropic’s reference, not recordings of a live request: text, thinking as notes, a tool call and its result, max_tokens with tools a cut-off, a 400 and a 529 honest failures, the bill from the row’s prices.

tests/anthropic-program.test.mjs The person’s Claude Code against the lines the CLI itself sent (tests/fixtures/anthropic/claude-code.json, from Claude Code 2.1.300): the flags and the grant, a tool call matched by the CLI’s own id and answered once on the running process, one model message’s tool calls yielded together, usage per message summed to the result, a resumed turn and a resume after a Stop, Stop with a call unanswered and Stop mid-text settling the stream’s tokens, Stop during a tool-less call ending its program with nothing to settle, not signed in, an exit mid-turn.

Tests (in `filmopen-plugins`)	Behavior
`tests/anthropic.test.mjs`	The Messages API streamed against stand-ins shaped from Anthropic’s reference, not recordings of a live request: text, thinking as notes, a tool call and its result, `max_tokens` with tools a cut-off, a 400 and a 529 honest failures, the bill from the row’s prices.
`tests/anthropic-program.test.mjs`	The person’s Claude Code against the lines the CLI itself sent (`tests/fixtures/anthropic/claude-code.json`, from Claude Code 2.1.300): the flags and the grant, a tool call matched by the CLI’s own id and answered once on the running process, one model message’s tool calls yielded together, usage per message summed to the result, a resumed turn and a resume after a Stop, Stop with a call unanswered and Stop mid-text settling the stream’s tokens, Stop during a tool-less call ending its program with nothing to settle, not signed in, an exit mid-turn.

OpenAI reference renders

Tests	Behavior
`packages/filmopen_plugin_host/test/marked_rows_test.dart`, `render_backend_test.dart`, `program_media_test.dart`	Both GPT Image image-edit rows are marked; configured Codex is ordered before the key. OpenAI edits without a saved key remain unavailable on credit with `creditNeedsInlineMedia`, while text-to-image credit and stored-key edits keep their funding. Program inputs expose each frozen reference path.
`filmopen-plugins/tests/openai-render.test.mjs`, `openai-provenance.test.mjs`	Ordered reference embeds use the catalogue member and edit endpoint; unsupported inputs refuse before dispatch; changed references cannot replay a job. Text-only HTTP bodies remain identical. Admission refusals preserve host words, including the media bound, without Usage or a resend.
`filmopen-plugins/tests/codex.test.mjs`, `openai-render.test.mjs`	Codex declares both image kinds; edits append ordered staged localImage inputs after the reference-aware text, while text-only turns remain unchanged. Missing paths and other inputs refuse before starting a process; start logs include kind and references without grants.
`filmopen-plugins/tests/model-picker.test.mjs`, `packages/filmopen_render_ui/test/render_preparation_test.dart`	Every reference-edit stage selects OpenAI GPT Image with its expected variant and quality; other kind/stage rows remain unchanged. The picker opens on Codex where configured, else the key; an unavailable OpenAI key retains its route instead of silently selecting a ready fal candidate.