Lolly Beta
Launch App

Proof cases

This chapter is a draft for review, dated 2026-09-24.

This chapter lists the cases the document model must be proved against. Each case is a paper example now and an executable fixture later (plan section 17). None of them is built.

The order of work matters. The plan's section 18 places these cases before any shared type is frozen, so a case that fails is a reason to change the model rather than the fixture. No type is added to packages/core and no schema to schemas/ in this wave.

What a fixture must state is specified in Conformance and fidelity: its inputs, its immutable dependencies, the reference environment, the features it claims, the expected artifact or typed result and the comparison rules. This chapter states the cases and what each one must show.

How to read a case

Each case carries two parts. The setup lists what is involved: the records, the operation and, where it decides the answer, the execution class. The expected outcome is what must hold for the case to pass.

The original 25 cases have no admitted fixture yet. Cases 26 and 27 add motion requirements: plan 281 supplies local pilot evidence for part of case 26, while neither case is an admitted conformance suite.

A case states the resolution or confirmed decision it tests. Plan section 17 lists the cases and their required evidence; the ids in this chapter are this chapter's own mapping of each case onto the decisions in plan section 2 and the corrections in section 0.1.

A case must never be reworded to match an implementation that failed it. That is why the plan's section 18 places these fixtures before any shared type is frozen: a failure is evidence about the model, not about the fixture.

Twelve cases come from the three pilots and the utilities. Eleven more were added by review: four after the first round and seven from the final review's findings C1 to C7. Two more, 24 and 25, were added on 2026-09-26 for invariants that had no case of their own. Cases 26 and 27 were added on 2026-09-28 for editable motion and nested time. The added cases are grouped below under the resolution or decision each one tests.

Pilot and utility cases

1. Constrained Lolly Design, two people. One authored Design tool is opened twice, once in governed execution and once unmanaged (D12). Expected outcome: governed execution must enforce the mandatory rules, and the unmanaged person may reject a waivable creative rule without mutating the original definition and without keeping a false approval claim (R6, packages/core/src/design-tool-v1.ts).

2. Chart inside Lolly Design and inside another tool. One chart definition is placed in a Lolly Design document and in a second tool, each with its own dataset. Expected outcome: typed data bindings, public overrides, brand rules and accessibility metadata must survive composition as a chart layer, and the two instances must keep independent identity and state (R14, packages/core/src/chart-v1.ts).

3. Lolly Design across print, raster and motion. One authored Lolly Design document is rendered to a print target, a raster target and a motion target. Expected outcome: one authored contract must serve the three output targets with explicit units, resources, timing and stated differences between the outputs (D2, engine/src/units.ts).

4. Agenda in interactive web, slides and motion. One schedule is published as an interactive page, as slides and as a video. Expected outcome: the three outputs must preserve the event, presentation and reference clocks, the presentation state and its transitions, the reading order and the declared differences between them (D2, R15, docs/agenda.md).

5. Unpack without a canvas. The Unpack route takes a design file apart through an operation adapter, and that route has no manifest (R13, shells/web/src/views/pdf-extract.ts). Expected outcome: inspection must stay passive and extraction must return a typed result with its effects declared (R5). A cancellation and a failed item must each have a stated outcome (R13).

6. Rebrand with partial completion. A reviewed plan is compiled over a deck and the run stops partway. Expected outcome: intentional changes and protected content must stay distinguishable, and review, retries and output ownership must stay explicit under OutcomeV1 (R5, packages/node-shell/src/rebrand-run-manifest.ts).

7. Non-recorded live operation. A tool that reads live input runs with capture off. Expected outcome: the operation must succeed without retaining raw input, replay must not be offered and the immediate outcome must be useful on its own (D11, R15).

8. Unknown extension. A document carrying an extension this host does not implement is opened. Expected outcome: safe inspection and byte preservation must work, and an edit that touches the extension's declared dependency scope must be refused or offered as an explicit lossy copy before any data changes (R10, Capabilities, trust and extensions).

9. Flattened chart with matching pixels. A chart nested through composes is compared with the same chart as a native layer. Expected outcome: the appearance check must pass while the editable round trip must fail, because the nested render returns an image asset and not a chart (R14, packages/core/src/host-v1/compose.ts).

10. Motion with a brief defect. A short animation carries a defect between two sampled progress points. Expected outcome: the timing, transition and coverage checks must expose the defect that percentage samples alone miss (D9, R12).

11. Missing or conflicting requirements. One run is given a missing font, an unsupported capability and two conflicting required rules. Expected outcome: each must fail at the boundary that owns it, with no silent substitution and no committed effect. The missing font must fail at the resource boundary (R15). The unsupported capability must fail at the requirement gate, scoped to the affected operation (R11). The two conflicting required rules must stop the affected operation at the policy boundary, reported with both ids (R6, engine/src/runtime.ts).

12. Legacy compatibility. Representative existing tools run unchanged through an adapter. Expected outcome: their behaviour must be preserved, and the adapter must report its trust, editing and repeatability limits rather than inherit a strict claim (R3, engine/src/hook-worker-core.ts).

Cases added by the review

Typed payloads and one authoritative source (R1, R14, C1)

13. Typed payload round trip. A nested chart is serialised, reopened, copied, patched, synchronised and exported. Expected outcome: datasets, encodings and accessibility metadata must survive every step, two concurrent edits to one payload must produce the documented outcome and no step may turn the chart into a string or a flattened image (R14, C1). The collaboration row value is a string, a number, a boolean or null, so a chart must travel as its own payload record (packages/core/src/canvas-op-v1.ts, schemas/canvas-op.schema.json). The mechanism is specified in Source rows, payloads and patches.

14. Second coordinate domain. Lolly Design's 3d layer carries its scene as a URL-encoded string inside a scalar field today (community/design/tool.json). Expected outcome: that scene must become a typed payload record referenced by the row, without breaking the frozen blocks wire order and without breaking an already shared link (R1, schemas/blocks-wire-order.json). The record must declare its length unit and its up axis, so that a GLB or USDZ export states the real size without a guess (Source rows, payloads and patches).

Concurrent merges (R1, C2)

15. Concurrent reparent. Five merges: Alice reparents A into B while Bob reparents B into A, a delete against a reparent, two concurrent atomic choices, an envelope whose final operation is invalid and two patches against one mutable head (C2). Expected outcome: each merge must be run in both delivery orders and across a reconnect and a checkpoint, and each invalid result must block evaluation with both edits kept for repair (R1). The reference model converges per field and produces the cycle in either order, so validation must run after convergence rather than on each patch alone (packages/core/src/canvas-op-v1.ts). The MCP path transforms supplied inputs and holds no head, so its outcome must record that no base revision was checked (services/mcp/src/tools.ts).

Outcomes that are not one file (R5, C3)

16. Outcomes beyond one file. Five runs are compared (C3): a zero-artifact inspection, a batch cancelled after two of three writes, a failure after a committed write, an unknown completion after a lost acknowledgement and a Rebrand plan that is ready before any export. Expected outcome: the inspection must succeed with a typed result and no artifact (R5). The cancelled batch must keep both committed files (R5). The failure after a committed write must keep that artifact under artifacts[] (R5). The unknown completion must be reported as unknown and never as failed (R5). The Rebrand plan that is ready must read as a lifecycle state and never as a succeeded export (R5). Each must map onto the persisted legacy vocabularies without changing them: the single-file invariant stays inside its adapter (packages/core/src/file-operation-v1.ts), and pending and ready stay run lifecycle states beside the outcome (packages/node-shell/src/rebrand-run-manifest.ts). Operations and outcomes specifies the split.

17. Fan-out export. A three-artboard document is exported as stills. Expected outcome: one outcome must carry three artifacts with stable per-artifact ids (R5, plan section 7.2). Each artifact must be addressed by the reserved s state selector and never by an index into the artifact list. The selector carries a frame id where the document stamps one and a one-based position in presentation order where it does not (engine/src/url-mode.ts, engine/src/frame-address.ts).

Local choice and the offline governed client (R6, R7, C4, C5)

18. Local waiver. An authored approved-font rule is rejected locally, the same rejection is then attempted under a Lolly Work overlay that forbids it and then a fingerprinted fact changes (C4). Expected outcome: the unmanaged operation must complete with an explicit exception, the governed attempt must be blocked and the changed fact must require a fresh decision (R6). Measured conformance to the unmodified rule must read failed or excepted and never passed (R6, C4). The recorded-decision pattern is the session record's rights decisions, keyed by work and kind with a fingerprint (engine/src/session-record.ts). The web view, the CLI and the MCP validation projection must agree on all three results (C4). Constraints, authority and local choice specifies the resolution order.

19. Offline governed client. A governed client loses its connection and the same authored document is opened 25 hours later (C5). Expected outcome: the document must open and stay usable, a governed claim must follow the explicit freshness rule and the receipt must name the policy version it evaluated rather than claim current online approval (R7). A host that cannot be reached answers unreachable, and a stale mark must stay reserved for an update that could not be brought down (shells/web/src/lib/design-system/hosted.ts). Leave must keep the person's sessions and perform its documented cleanup, and an editable copy must be a separate action with known dependencies and no inherited governance claim (R7, shells/web/src/lib/instance-leave.ts).

Effect authority (R3, C6)

20. Effect authority. Four attempts: a bracketed member access and a local alias against a strict grant, a write through a hook during passive inspection, a hook that resolves after cancellation and a trusted compatibility run (C6). Expected outcome: an alias and a dynamic access must not bypass a strict grant (R3). Passive inspection must not write through a hook (R3). A hook that resolves after cancellation must not commit a new strict effect (R3). A trusted run must never receive a strict claim (R3). The generated inventory is a pattern over host.<api> and misses both alias forms, so it is lint and never authority (scripts/tool-requires.ts). A hook that overran its budget keeps running in the realm, which is why a grant binds to the operation, the phase and the attempt (engine/src/runtime.ts). Values, expressions, code and time specifies the execution classes.

Preservation across save and restart (R10, R11, C7)

21. Preservation round trip. A future optional extension is imported, saved locally, restarted, edited in an unrelated permitted way and exported (C7). Expected outcome: the opaque bytes must compare equal after that round trip (R10). A touch on a protected dependency must be refused or routed through an explicit lossy copy (R10). An older client must refuse by its reader gate (R11). A stale receipt must never describe the new revision as accepted (R11). Additive parts already travel under the integrity map while the manifest is rebuilt from typed fields on every save, so a retained package state must connect those two boundaries (shells/web/src/lib/lolly-pack.ts). Packaging, identity and migration specifies that state.

Fidelity evidence (R9, R15, C8)

22. Vanished caption. A render loses its caption, and no whole-image measurement separates it from a harmless half-pixel shift or a resample: the three pairs sit within 0.2 points of each other on changed pixels and on SSIM (C8, plans/276-document-model-evidence/README.md). Expected outcome: the three checks must read the produced artifact or an independently extracted representation of it, never the authored source (R9, C8). They must fail that render. An unchanged result must pass. An accepted shift must pass only inside a calibrated band. Text with similar ink but the wrong content must fail (R9). An incomplete extraction or an undetermined comparison must never count as a pass (engine/src/compare.ts). PNG alpha, PDF page boxes and colour intent must each have their own checks, and a white RGB fixture must never be generalised to CMYK print conformance (C8). The measurements that motivated this case are in Conformance and fidelity, and this fixture must replace them before any number enters a suite (C8).

23. Live-text fallback. A run whose text stayed a live <text> element instead of an outline is exported. Expected outcome: the receipt must record that fallback per run, with the resolved font files by digest, the shaping engine version and the emoji set and treatment (R15). The run must not claim font-independent fidelity (R15). The command line already warns on an unresolvable font or a baseline shift it cannot place exactly, and a strict run promotes that warning to a refusal (shells/cli/src/svg-outline.ts). Today that fact reaches standard error, the --json envelope's warnings list and, under --strict, the exit code, but never a receipt (shells/cli/src/output.ts, shells/cli/src/envelope.ts). The receipt is the gap this case closes.

Invariants with no case of their own (D1, D11, R5, R15)

Two cases were added when the table in the constitution mapped each invariant to its cases. No case tested invariant 11 on its own, and only case 7, the live-input half of Q4, stood behind invariant 5.

24. Accessible intent across outputs. One chart whose accessibility metadata carries a title, a description, a reading order and a data table is exported to SVG, PDF, PNG and MP4 (packages/core/src/chart-v1.ts). Expected outcome: each output must carry the parts its format has a place for, and each must be checked by a check of its own that reads the exported file, never the screen render or the spec (D1, C8). An output with no place for the reading order or the table must report that loss as a finding in the one finding shape, never drop it silently (R5, packages/core/src/file-v1.ts). A declared motion description must reach the motion output or be reported missing. No output may be recorded as accessible because another output was. Today the chart template writes the title and description into the SVG as <title>, <desc> and an aria-label (community/chart/template.html). A test pins that template source (tests/chart-spec.test.ts), and nothing reads the metadata back from an exported file.

25. Local utility with no record. The on-device strip-data tool removes metadata from a person's file under Q4's default for a utility: capture off, retention none and replay semantic from pinned inputs (community/strip-data/tool.json). Expected outcome: the operation must succeed with a typed outcome and no receipt, and an absent receipt must read as "no receipt was retained", never as "not evaluated" (D11, R15). The output must carry no provenance and no watermark. The host must keep neither the input file nor a record of the run once it ends, and the run must declare that it kept none rather than leave it to be inferred. A second run on the same input file, held by the person and not by the host, must compare as equivalent-content or identical-bytes with the first (engine/src/compare.ts). Today a picked file never reaches a link (engine/src/url-mode.ts) and the output carries no stamp (engine/src/runtime.ts), but no declaration says what a run captured or kept, so neither fact can be checked from outside the run.

Editable motion and nested time (R1, R10, R11, R12, R15)

26. Editable film and playback projection. A Lolly Design scene with captured UI text and shapes, split text, a camera, a staged pointer and a soundtrack is saved as .lolly, opened in a fresh session, edited and exported to HTML and a movie. Change a headline, move the panel and retime the interaction. Seek to the same sample after a different sequence of earlier seeks. Open the HTML with network access disabled. Expected outcome: text and geometry must remain editable; imported asset ids must resolve to the carried bytes; the edited values must survive another save and reopen. The player and the movie must evaluate the same authored motion, with raster and codec differences reported separately. Font dependencies must be identified, and embedded HTML fonts must not imply that the editable package carries those fonts. Audio must follow the declared time mapping. Pausing, muting or seeking the player must not alter the source revision. The last displayed sample and encoded frame count must follow an explicit endpoint policy. Plan 281 is local pilot evidence for the current adapter, not proof of general video, Lottie, 3D or arbitrary CSS support.

27. Nested motion and regeneration. A timed composition contains a clipped panel, staggered text and a trimmed audio clip. The parent moves, rotates and changes playback rate. An author then changes one generated key and reapplies the recipe. An older reader opens the document and saves an unrelated permitted edit before restart. Expected outcome: local geometry, transform order, clipping, opacity composition and time mapping must be unambiguous. Direct seek and continuous playback must agree at trim and composition boundaries. A declared writer conflict must be refused rather than resolved by execution order. Regeneration must preserve the authored key or require an explicit decision to replace the properties it owns. Required motion records must survive the older reader's round trip or that reader must refuse the operation through its gate. A flat set of boxes that happens to look right at one time cannot pass this case. No fixture exists yet; this case must run before a shared hierarchy or timeline payload is frozen.

28. Timed artboards as scenes. A film has three differently sized artboards, child motion, one camera per scene, scene-owned audio and an unframed soundtrack. Move the second scene before the first through the timeline, save, reopen and export. Seek repeatedly across scene boundaries and a dissolve, then use the HTML player's scene menu. Expected outcome: scene membership determines which starts move, even when a member extends beyond its owner's end. Local keys and the global soundtrack stay unchanged. Each camera affects only its own scene and uses that artboard's size. Scene audio is clipped with its source trim and gain preserved. The outgoing picture holds its final in-bounds sample through a dissolve. HTML and movie contain-fit each scene consistently. Playback navigation must not change the saved source. Deleting a scene removes its members in the same undoable edit. The current adapter stores member starts in project time; passing this case does not prove nested rate or parent-transform support. Plan 281 supplies local examples and targeted tests, not an admitted general conformance suite.

29. A song that is code. A rondocode song is uploaded as an audio asset, placed on a Lolly Design timeline as a trimmed clip and exported as a movie on the web, rendered by the CLI and decoded through the public MCP server (plan 301). A second song reaches for fetch inside js{ ... }, loops forever inside a pattern and rewrites JSON.stringify to forge its own output. A third calls sing() and mic(). Execution class: vm.

Expected outcome: the song's code runs only in the vm class on every surface, and each result records that class with the renderer's version and seed (R15). One song at one length gives the same PCM on the web and on Node; JavaScriptCore is not yet measured. The hostile song ends with a named error at the deadline of the phase it broke, its forged output is refused by the inspection step, and the host process carries on (R3). The third song renders with its sung and microphone parts named as silent, never as a complete render (R10). A host without the renderer carries the .rondo.json bytes unchanged through a save and a .lolly export (R10, C7). Passing this case does not prove the opaque-origin frame the editor runs in, which capabilities, trust and extensions leaves as an open point.

What must never pass

For every admitted visual suite, schema validity alone must never pass the gate (D3, plan section 17). For an action-only operation, a fabricated preview must never stand in for the real outcome (D11, plan section 17).

Two further limits follow from the same rule. A skipped test must never be recorded as a pass (R8). A comparison that was cut short by its budget must never be recorded as a pass, and it must stay distinguishable from a harmless truncation of displayed detail (R9, engine/src/compare-budget.ts).

This chapter makes no conformance or reproducibility claim beyond the ones docs/determinism.md already makes, and it states no threshold.

Spatial and fabrication examples stay paper probes in this wave (D5). They test whether an extension boundary holds, and they are not a commitment to build those suites.

DAM resource cases added on 2026-10-15

These cases extend the Lolly Design resource boundary after the DAM review (plan 314). They keep Lolly Design, Chart and Agenda as the pilots (D2). They are requirements for future contract fixtures, not claims of implemented source-history or review enforcement. Focused tests of existing seams are evidence only for the behaviour those tests exercise.

30. Two originals and a preview. A provider asset contains two SVG attachments and a raster preview of the second. Select the second file, save the instance, reopen, convert and deliver the selected original. Expected outcome: every step retains the same selected file identity and observed revision/digest. The preview remains a separate representation and never satisfies an original request. Reordering attachments changes neither selection nor identity. Existing selected-file helpers cover part of this case (shells/web/src/lib/asset-files.ts); durable provider pin resolution remains required (R4, R15).

31. Overwrite without a metadata change. A source overwrites one attachment with equal-length bytes while keeping its timestamp and format metadata. Compare the catalog change token and actual byte digests, then reopen an earlier pinned instance. Expected outcome: a cache token alone cannot establish unchanged content. The pin returns verified earlier bytes through a qualified revision or permitted retained copy, or an explicit unavailable result. It never reads the new head as the old revision. Lolly Work currently derives the token from metadata and exposes no general historical-revision resolver (lolly-work/server/src/catalog/federation.ts, lolly-work/server/src/catalog/providers/types.ts), so full exact-pin support is not established (invariant 7, R15).

32. Offline after authority changes. A source is withdrawn or a processing lease expires while a member has an offline saved Lolly Design and permitted cached material. Reopen after 25 hours, edit a local caption, request a restricted original, start processing and attempt delivery. Expected outcome: held policy continues to govern permitted work (R7). Each consequential action follows its own explicit freshness and validity requirements. A historical receipt never renews access or processing permission. A local creative waiver and an editable copy cannot widen the source grant (R3, R6). Missing authority blocks only the affected operation, and existing source evidence remains history.

33. Review of one revision. An upstream proof reviews two files, then one file is replaced or the proof membership changes. A separately staged Lolly output is also replaced with a remotely transformed result. Expected outcome: each decision stays bound to its reviewed subject and scope. Catalog admission, source review, contextual eligibility, conformance acceptance and final-byte approval remain separate. New output bytes need the checks and review their own delivery policy requires. Lolly Work's existing version-curation and staged-delivery paths must be represented accurately, without assigning them an unimplemented general revision-review guarantee (R8, R15; lolly-work/server/src/catalog/submit.ts, lolly-work/server/src/delivery/types.ts).

34. Hidden neighbours and shared credentials. A visible source has a hidden dependant and a private generation recipe. A service credential can read both upstream; the Lolly Work member can read only the source. Repeat the query through Assets, an agent, facets, lineage and an export. Expected outcome: no hidden neighbour, field, identifier, count or redaction detail crosses the member's authority. Shared exposure and delegated upstream member authority are explicitly distinguished. Usage reports known recorded uses within that authority; it never promises complete tracking (R3, R15).

35. Imported incomplete generation. Import generated bytes and a workflow sidecar whose final sampler, model revision and one input are missing. Reuse the stored image, request replay and then explicitly generate a variation. Expected outcome: missing fields remain unknown and the workflow remains external evidence. Reuse reads the stored bytes without running a model. Recorded workflow, executable environment and replay support have independent answers. The new variation is a separate authorised operation with bounded cost and a new result/review state. No Lolly-observed execution receipt is fabricated for the imported run (R4, R15).

36. Fixed output and adaptive publication. A reviewed Lolly design goes through a remote transform before fixed delivery. A second request proposes automatic format and quality selection at the destination. Expected outcome: the fixed path creates and checks a new artifact, binds approval to its staged final digest and delivers those bytes. The adaptive path can proceed only under its own explicit source-plus-transformation-policy contract; it cannot claim fixed-byte acceptance. This amendment enables neither new path. Plan 300's current byte-lock policy continues to apply (R5, R8).

37. Processing acknowledgement lost. A remote job returns after the caller times out; a later delivery acknowledgement is also lost. Retry each logical operation and cancel an earlier attempt while its remote work may still be running. Expected outcome: reconciliation reads operation identity, attempts, staged artifacts and observed committed effects before repeating work. Unknown completion remains unknown. A local cancellation must never imply confirmed remote cancellation or no charge. No late result commits after the authority required at commit is withdrawn (R3, R5). This extends case 16.

38. Preserved private evidence. Import a future recipe/evidence part, persist, restart, edit an unrelated permitted field and save. Then export to a recipient who lacks recipe access, followed by an older-reader round trip. Expected outcome: authorised retained bytes survive the owner round trip. Disclosure is checked separately before export; private fields and hidden lineage do not travel by accident. Revision-scoped evidence remains historical after a change. Required unknown parts invoke the reader or affected-operation gate. No new part is emitted before those preservation and compatibility gates exist (R10, R11). This extends case 21.

Production and provider cases from the follow-up review

These cases extend the DAM boundary after the Papirfly, Air and Adobe review (plans 314 and 315). They are requirements; focused evidence at an existing seam is not the complete case.

39. Old bytes, current attributes. Resolve a historical original whose source retains no historical attributes. Change its current review and access state without changing its bytes or metadata cache token. Expected outcome: byte identity, metadata observation, review subject and current authority remain separate. Current attributes are not attributed to the historical revision. A digest or cache token cannot preserve permission after withdrawal; missing historical evidence remains unknown (R3, R4, R15).

40. Incompatible search modes. Request semantic ranking with exact tags and a date filter from a source that supports those filters only in lexical mode. Return one capped relevance page and one unavailable source. Expected outcome: the host refuses or explicitly negotiates unsupported combinations without silently dropping required filters. Exact-filter browsing remains available. Result scope, completeness and permission-filtered counts are explicit; no-match, unavailable and unsearched are distinct answers (R3, R11).

41. Campaign refresh and selective retry. Bind two locales to a content-schema revision, override one row's copy, then refresh the content and tool definition. One variant fails preflight; retry only that variant after repair. Expected outcome: incoming fields are compared against the pinned base; local overrides and conflicts survive. Stable row identity and input revision follow every finding and output despite queue compaction. Successful rows are not regenerated or relabelled. Changed proof membership invokes its stated review policy (R1, R4, R5, R15).

42. Transfer accepted, original pending. Deliver to an existing remote asset with explicit create, new-version and replacement intentions in separate attempts. Lose the completion acknowledgement while processing continues, and deliver duplicate or no events. Expected outcome: conflict/version policy is explicit before the write. Reconciliation checks remote identity and effects before retry. Accepted transfer, processing, original readiness, review and publication remain separate observations. No preview substitutes for a pending original, no unintended overwrite occurs and unknown completion remains unknown (R3, R5, R11). This extends case 37.

43. Automated approval for another target. Import a source's automatically set internal-library approval. Submit a public-delivery proof containing two locale variants, then change one crop and a responsive viewport. Expected outcome: decision origin and activation target are retained. The internal assertion cannot approve public delivery or become human review. The new decision binds exact variant revisions and membership; responsive proof records the tested viewport and state. Earlier decisions remain historical and cannot approve changed bytes or untested views (R8, R15).

44. Viewer context changes during a task. Preview a mutation of selected files, navigate to another file, then revoke access to one selected item while earlier items complete. Expected outcome: navigation never widens the explicit target set or confirms a destination. Admission and commit checks apply per affected item, with committed, blocked and unknown outcomes retained. Prior task consent cannot widen source or destination grants, and hidden targets remain hidden (R3, R5, R15).

The five that come first

The plan's section 18 names five of these cases as the ones that run before any shared type is frozen, because each one carries contract semantics that a type would otherwise settle by accident.

OrderCaseWhat a failure would change
113, typed payload round tripWhere a structured value lives and how it synchronises (R1, R14)
215, concurrent reparentWhat a revision covers and where a merge is validated (R1)
316, outcomes beyond one fileWhether a typed result, the committed artifacts and a termination stay separate (R5)
418, local waiverWhether a recorded local decision has any effect (R6, D7)
521, preservation round tripWhat is preserved across save, restart and an older client (R10, R11)

The patch envelope and the source-aware diff land when their semantics are fixed in Source rows, payloads and patches and Packaging, identity and migration, not before (plan section 18). Cases 13, 15 and 16 are the evidence those semantics are settled.

Cases 30 to 44 add gates for shared source-history, processing and review contracts. They do not replace the five above or make the first native still-image suite depend on a DAM vendor. Freeze only the smallest contract justified by its applicable fixtures, and keep unimplemented cases stated as requirements (plan 314).

Source and history implementation evidence

The source-history suites exercise maintained resource and review boundaries. tests/source-history.browser.test.ts covers exact selected-file reads, source overwrite with an unchanged token, saved revisions, restart and explicit missing bytes. tests/source-history-package.test.ts exercises the existing editable package vehicle and distinguishes imported operation reports from execution observed on this device. tests/asset-version.test.ts also binds credential collection to each exact source version used by an export.

The Lolly Work source-review suite covers a frozen purpose, activation target and file membership, replacement after request, and hidden proof members. These are focused implementation cases. They do not establish vendor-native history, historical source attributes, complete shared usage, replayable imported recipes or approval of later output bytes. No new portable evidence part or shared document record is emitted by these cases.

Open points

The other questions are stated in other chapters. Q5 is answered in Conformance and fidelity. Q6 is answered in Status and open points.

Precedents