From 8112dea7a371755c7373f4ecc09a6488a73ac136 Mon Sep 17 00:00:00 2001 From: "sorokin.oleg.edu" Date: Sat, 12 Sep 2026 14:59:08 -0700 Subject: [PATCH] Preserve canvas correction failures and bound scenario evaluators --- .gitattributes | 1 + harness/STATE.md | 8 +- .../activation-design.md | 79 + .../activation-implementation.md | 17 + .../always-active-review.md | 58 + .../bound-fixture-preparation.md | 21 + .../bound-fixture.rs | 527 ++++ .../README.md | 1 + .../bound-nested-calls.arcadia | 486 +++ .../diagnostics.txt | 24 + .../scenario-identities.tsv | 4 + .../draft-fixture.rs | 107 + .../manifest.json | 132 + .../nested-bound-b250-core/build.json | 52 + .../nested-bound-b250-core/build.log | 0 .../nested-bound-b250-core/generate.json | 9 + .../nested-bound-b250-core/generate.log | 4 + .../nested-bound-b250-core/probe-source.rs | 520 ++++ .../nested-bound-r1-b250-core/build.json | 52 + .../nested-bound-r1-b250-core/build.log | 0 .../nested-bound-r1-b250-core/generate.json | 9 + .../nested-bound-r1-b250-core/generate.log | 1 + .../nested-call-f7-core/build.json | 52 + .../nested-call-f7-core/build.log | 0 .../nested-call-f7-core/fixtures.json | 9 + .../nested-call-f7-core/fixtures.log | 1 + .../diagnostics.txt | 841 ++++++ .../nested-call-evaluator.arcadia | 1689 +++++++++++ .../state-focus-review.md | 140 + .../archive-manifest.json | 30 + .../clippy-e2c027e.inputs.json | 2670 +++++++++++++++++ .../clippy-e2c027e.log | 26 + .../clippy-e2c027e.result.json | 19 + .../focus-24bb248.inputs.json | 2660 ++++++++++++++++ .../focus-24bb248.log | 44 + .../focus-24bb248.result.json | 20 + harness/release-canvas-followup-20260912.md | 77 + ...elease-diagram-removal-windows-20260912.md | 4 + 38 files changed, 10393 insertions(+), 1 deletion(-) create mode 100644 harness/experiments/canvas-editing-followup-20260912/activation-design.md create mode 100644 harness/experiments/canvas-editing-followup-20260912/activation-implementation.md create mode 100644 harness/experiments/canvas-editing-followup-20260912/always-active-review.md create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-fixture-preparation.md create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-fixture.rs create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/README.md create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/diagnostics.txt create mode 100644 harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/scenario-identities.tsv create mode 100644 harness/experiments/canvas-editing-followup-20260912/draft-fixture.rs create mode 100644 harness/experiments/canvas-editing-followup-20260912/manifest.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/probe-source.rs create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.json create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.log create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/diagnostics.txt create mode 100644 harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/nested-call-evaluator.arcadia create mode 100644 harness/experiments/canvas-editing-followup-20260912/state-focus-review.md create mode 100644 harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.inputs.json create mode 100644 harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.log create mode 100644 harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.result.json create mode 100644 harness/experiments/diagram-removal-windows-20260912/focus-24bb248.inputs.json create mode 100644 harness/experiments/diagram-removal-windows-20260912/focus-24bb248.log create mode 100644 harness/experiments/diagram-removal-windows-20260912/focus-24bb248.result.json create mode 100644 harness/release-canvas-followup-20260912.md diff --git a/.gitattributes b/.gitattributes index d282f2ae..e7da050a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -68,3 +68,4 @@ harness/experiments/allocation-3840ca2-pause-20260912/** -text whitespace=-blank harness/experiments/diagram-removal-windows-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol harness/experiments/diagram-resize-foundation-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol harness/experiments/delete-native-f7-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol +harness/experiments/canvas-editing-followup-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol diff --git a/harness/STATE.md b/harness/STATE.md index 278e4e8c..6240b4cc 100644 --- a/harness/STATE.md +++ b/harness/STATE.md @@ -76,7 +76,13 @@ corrections. Its [native deletion checks](release-delete-native-f7-20260912.md) pass exact Save/Undo for architecture/state placement removal, semantic work deletion, state Entry relation and scenario lifeline deletion. Native Save/Undo revealed lost canvas focus; reviewed correction **24bb248** requires its own -gates. This is not completed native acceptance. Complete direct +gates. Its focused run subsequently passed 22 tests and failed the persisted +state Save/Undo case. Combined candidate **e2c027e** fixes the state widget's +positional focus-tree replacement and includes nested activations and redundant +canvas-control removal. Strict lint found two obsolete event variants; no passing +combined gate or native acceptance is claimed. The +[canvas follow-up evidence](release-canvas-followup-20260912.md) preserves exact +failures, reviews and validated bound OA/SA evaluator fixtures. Complete direct manipulation, persistent process placement/lanes and coherent peer integration remain open. Gitea owns live coordination. diff --git a/harness/experiments/canvas-editing-followup-20260912/activation-design.md b/harness/experiments/canvas-editing-followup-20260912/activation-design.md new file mode 100644 index 00000000..3281b05a --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/activation-design.md @@ -0,0 +1,79 @@ +# Issue 21: nested call activation design and evidence + +Advisory contribution by `/root/nested_call_design`, 2026-09-12. Root owns issue 21 and integration; baseline supplied by root: `f7d84fa`, `codex/behavior-authoring-20260910`. Read current root sources without editing them. No native input, compilation, tests, Git changes, remote coordination, or production implementation performed. Proposed checks below are not passes. The user-owned PROJECT_GOAL remains untouched. + +## Finding + +The reported four-message model `Call1 L1→L2, Call2 L1→L2, Reply2 L2→L1 reply_to Call2, Reply1 L2→L1 reply_to Call1` is already expressible. The core does not require stack-order returns. `docs/language.rst:675` and `oa-core/src/validation.rs:1672` require exact call identity, guaranteed-before order, reversed endpoints and no multiply executable duplicate reply. A rendering fix must not impose a new LIFO constraint or change correlations. + +The direct defect is scene projection and paint geometry: + +- `oa-desktop/src/behavior.rs:1295–1322` collects calls from the row BTreeMap, hence UUID order, and invokes `activation_sequence` with each receiver's identical lane x. It has no concept of overlap/depth. +- `activation_segment` at 1601 creates all bars at `x-4`, width 8. Every overlapping call has the exact same horizontal footprint. Closed calls also append a width-14 cap at that same x. The last UUID-painted bar can obscure either the inner or outer call. Sorting alone cannot make two same-x bars readable. +- `occurrences` at 1463 routes messages to lane centers, including 24-pixel self-message drops. `activation_sequence` starts a self-call at its send row y instead of its actual receive point y+24. A self-reply ends an activation at send row y; that is appropriate for the callee, whose execution ends when the reply is sent. +- `draw` at 2060 paints activation boxes with the generic rounded-card path, then lifeline guide strokes and messages over all boxes. A lifeline therefore runs through a filled execution bar. Moving bars without defining draw roles/layers leaves that defect. `hit` shares generic BoxItem records; thinner exposed nested shoulders need hit tests against actual visible bar geometry. + +The user's `.local/gitea-issue21.png` shows two leftward calls and an incomplete-looking second execution (ellipsis). It does not expose exact reply_to values or the final reply. Do not diagnose wrong correlation from this crop, nor assume every visible Reply belongs to the most recently drawn Call. Inspect the saved model when reproducing it. + +## Comparable primary evidence + +The existing local `harness/release-capella-scenario-benchmark-20260910.md` established Activity/lifeline creation and a dragged LOOP only. It did **not** exercise nested calls. It cannot support a claim that nested activations have now been reproduced in installed Capella. + +The official [Sirius sequence user guide](https://eclipse.dev/sirius/doc/user/sequences/Sequence%20Diagrams.html#Executions) depicts recursive execution rectangles on lifelines and on executions, and its complex-message example includes a self-call nested inside an active receiver. This supports offset execution rectangles and meaningful send/receive anchors as the comparable visual pattern. The [specifier guide](https://help.eclipse.org/latest/topic/org.eclipse.sirius.doc/doc/specifier/sequences/Sequence%20Diagrams.html) configures execution start/end finders and recursively reused execution mappings. These are source/documentation observations, not a new native Capella test. + +[Capella Interaction.ecore at 5537297](https://github.com/eclipse-capella/capella/blob/5537297b071fff809285bc63989f5067d675bc52/m2/plugins/org.polarsys.capella.core.data.def/model/Interaction.ecore#L589) represents Execution as a TimeLapse covering an InstanceRole, with start and finish concepts. Studio currently derives call bars from occurrences and has no standalone execution or thread record. Copying Capella's model wholesale is unnecessary for this bounded defect; offset placement must remain a derived display, not a new ownership or execution-stack assertion. + +## Recommended bounded contract + +Call identity comes only from the Call occurrence UUID. Its responding messages come only from Reply.reply_to. Labels, exchange identity and row adjacency never establish correlation. + +Keep the existing branch-aware correlation traversal as the semantic starting point. First produce typed activation segments containing call ID, receiver lifeline, segment start/end, enclosing branch path and termination kind (reply / branch boundary / unresolved end). Then assign horizontal placement, then route final message endpoints, then draw/hit against those final shapes. Avoid deriving semantics back from screen rectangles. Keep raw row order separate from final send/receive endpoint y. + +Prefer a dedicated `ActivationSegment`/`ActivationLayout` over anonymous title-empty `BoxItem` conventions. Expose the same resulting rectangles and call/reply anchors to painting and hit testing. A local module `behavior/scenario_activation.rs` is a bounded home; this needs no persisted schema change. + +Use a fixed receiver-relative rightward offset for nested bars regardless of the direction from which a call arrives. A proposed starting style is width 12 and offset 6 world pixels, square corners, with outer bars painted before inner bars. These dimensions are a design candidate requiring minimum-scale visual QA, not an assertion that six pixels is already usable. Make corresponding closed cap edges consistent with the bar instead of the existing oversized generic capsule. At depth >0 there must be an exposed shoulder and separately visible start and end edges. Selection cannot be the only way to reveal an inner call. + +Depth/columns are **visual overlap separation**, not inferred synchronous thread ownership. Assign deterministically in semantic event order (with UUID used only as an otherwise-unneeded final tie-breaker), independently per receiver lifeline and compatible branch path. Retain one column for a call through its segments; reuse a column after that call's relevant closed extent. For well-nested complete intervals, the inner call occupies the next column. Crossed complete intervals also require distinct columns, but their actual termination y values remain crossed. Never shorten or re-correlate one to make a pretty nesting tree. + +Calls wholly in different ALT operands do not consume each other's depth. Calls wholly in different PAR operands are also not evidence of nesting: branch layout is presentation, not chronology. Inherited outer activations may have separate segments in each operand and need to be compared only against activations in that operand. Reuse the existing ALT/PAR/OPT/LOOP open-path outcomes; add a regression before refactoring them. If a pure rectangle-overlap allocator is used, verify it cannot mistake the vertically stacked operands for a single execution path or merge distinct returns. + +### Exact examples and bounds + +| Scenario | Expected display and semantic boundary | +| --- | --- | +| User sequence C1,C2,R2,R1 | L2 C1 starts at receive(C1), ends at send(R1); C2 starts at receive(C2), ends at send(R2), shifted one column. Both bars and both terminators remain visible and independently selectable. Two ordinary calls on L1 do not create an invented L1 execution. | +| Sequential C1,R1,C2,R2 | Both L2 bars may use base column. No gratuitous staircase from counting all preceding calls. | +| Crossed C1,C2,R1,R2 | Preserve exact correlation and both extents; overlapping bars use separate columns. This core-admitted model must not be rejected or changed into C1,C2,R2,R1. Do not call it proof of a single nested thread. | +| Self-call on inactive L1 | The routed loop leaves the lane and returns to the new bar after its vertical drop. Bar top equals final receiving endpoint y, not the upper send row. An inactive caller has no fabricated execution before receipt. | +| A→B C1; B→B C2; self R2; B→A R1 | C2 offsets from C1 on B. C2 call starts at the active parent edge and ends at child start; R2 starts at child end and returns to the still-active parent. Parent remains visible outside the child. | +| A→B C1; B→A C2; A→B R2; B→A R1 | Bars belong to B for C1 and A for C2. Depth is per lifeline. Merely having an outgoing Call does not establish an A parent execution. If A was already active from an earlier received call, C2 is offset on A. | +| Incoming calls to same lifeline from different senders | Use exact receiver and interval overlap, not exchange identity or sender equality. No thread relationship may be inferred. | +| ALT inherited outer call with Reply in one operand and no Reply in another | Preserve segmented outer bar, exact matched end in returned operand, explicit open mark in unresolved operand, and existing post-fragment continuation rule. No bar across branch headers or false unconditional return. | +| PAR sibling local calls | Render each in its own operand and correlate locally. Do not increase second sibling depth just because its row is later. Keep inherited outer-call behavior separately covered. | +| Missing Reply | Preserve an explicit incomplete/open indicator; do not fabricate a reply or a full known execution duration. Current isolated open-call stub is 26 pixels. A stub cannot be used as evidence that activity definitely ended there. If it overlaps another displayed stub, separate them. Unknown semantic duration is not proof of nesting at a later call. | +| Reply without reply_to | Remains a draft diagnostic and ordinary Reply line; it closes no bar. | +| Missing sender/receiver | Preserve editable draft fallback. No invented lane or anchor. A Call with known receiver but missing sender may retain a clearly incomplete receiver activation, following current draft behavior. | + +Anchor rules: for ordinary inter-lifeline calls/replies, connect to the side of the relevant execution facing the other endpoint; a Reply's source execution is its exact correlated Call. Its target can attach to an unambiguously active caller execution; absent one, attach to the caller lane. When several independent active executions could be the caller, do not guess a semantic parent: use the lane or an explicitly documented neutral rule. For self-messages, route the loop outside the outermost involved bar and attach at parent/child edges; never route a loop through the bar. Compute label bounds from final route, not stale lane centers. + +## Candidate comparison + +1. **Paint the selected bar last / change color only:** small but fails visibility without selection and cannot distinguish same-x shapes. Reject. +2. **Count preceding Calls per lane:** small but staircases sequential pairs, depends on unresolved calls, and falsely nests branch siblings. Reject. +3. **Single global active stack:** apparently matches common examples but imposes unmodelled thread and LIFO assumptions, and mishandles branches/crossed correlations. Reject. +4. **Typed correlation segments plus deterministic path-aware overlap placement and shared anchors:** modest renderer refactor, preserves existing source/REST semantics, and admits concrete paint/hit evaluators. Recommended. +5. **New explicit execution/thread metamodel:** potentially useful later but not justified solely by this display defect; larger source/API/transition burden and more uncertainty before the reported scenario works. + +## Required evaluator (not executed) + +Start with actual core-built Project fixtures, validation and canonical source round trips, then pass those accepted Projects to the production Scene. Do not use a miniature fake project or a reimplementation of activation logic as the sole oracle. `.local/nested-call-fixtures-20260912.rs` supplies deterministic actual-core fixture construction for a first gate; root must compile/run it, inspect warnings and add the resulting paths to native verification. The probe intentionally uses missing exchange references to isolate activation semantics in both layers; native release acceptance should also repeat the user case with an actual bound exchange and values. + +For C1,C2,R2,R1, inspect final production activation records: top/end match actual line receive/send vertices, width positive, child x differs, exposed horizontal interval of each is nonempty, and neither terminal is swallowed by another fill. Permute UUIDs while keeping steps/correlation identical; geometry and paint order must be equivalent. Inspect selected and unselected cases, both lane directions, self-call drop, crossed returns, 3+ nesting levels and two different receiver lanes. + +Call `Scene::hit` on an exposed inner shoulder away from message lines and labels, and on an exposed outer shoulder. Expect the respective Call IDs at default/minimum scale and nonzero camera pan. Test each matching Reply line separately. Activation body clicks must not select the lane or unrelated outer Call. Account for actual `8/scale` line hit tolerances: mere bar-center checks near message rows can pass by hitting a line instead of the bar. + +Paint order gate: backgrounds/fragments, lifeline guides, activation bars shallow→deep, message routes/arrowheads, labels/selection adorners as appropriate. Lifeline guides must not appear through filled activation interiors; messages must end at intended bar edges. Generic rounded-card rendering is inappropriate for narrow execution rectangles. + +Use actual Iced draw output/native screenshot at default/minimum scale in 1100×700 and normal larger window. Verify exposed shoulders, starts/ends, self loops, line dashes, unselected contrast and selected outer/inner strokes. A Scene coordinate test does not prove paint layering. Exercise selecting each bar and each reply, editing reply correlation, changing order, Undo/Redo and save/reopen. Canonical source and the full accepted model must retain IDs/steps/endpoints/values; merely selecting/opening never dirties the model. Reuse existing valid lifecycle/header/ALT gates and rerun affected ones. + +This bounded repair cannot satisfy issue 20/22's free arrangement/editing requirements or the overall Behavior UX objective. It does not deliver persisted lane placement, arbitrary visual spacing, process geometry, cross-operand movement or a general execution metamodel. Root should record which slice is integrated without closing broader work. diff --git a/harness/experiments/canvas-editing-followup-20260912/activation-implementation.md b/harness/experiments/canvas-editing-followup-20260912/activation-implementation.md new file mode 100644 index 00000000..de7ad6a0 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/activation-implementation.md @@ -0,0 +1,17 @@ +# Issue 21 source implementation handoff + +Commit **43c2d51**, branch `codex/nested-call-956atf-20260912`, worktree `.local/nested-call-implementation-20260912`, base `f7d84fa`. Root owns issue 21 coordination, integration, compilation, native validation and release. This contribution changes only `behavior.rs`, `behavior/scenario_activation.rs` and `behavior/scenario_activation/tests.rs`. + +Implemented typed call/receiver/scope activation segments, semantic-order overlap columns, exact-correlated Reply source anchors, self-call receive versus send y, and shared final bar/route geometry for hit testing. Square activation fills paint over lifeline guides, under cards/messages, shallow before deep. Large line hit tolerances follow actual activation-body hits so zoomed-out shoulder points do not select a nearby unrelated message. Selected and unselected bars share geometry. No schema, source semantics, endpoint IDs, reply correlation or persisted layout change. + +Twelve production Scene regressions construct actual OA/SA Projects with validation and canonical source round trips. Coverage includes both directions; sequential/nested/crossed and permuted UUIDs; self/reentrant calls; three exposed nested columns; exact canvas press/release selection under pan and scales 1/.25/.05; incomplete correlation; ALT/PAR scope separation; inherited outer execution; and fragment-boundary false-nesting falsifiers. Existing direct-canvas ALT/open tests now inspect typed activation records. + +Independent source critic `/root/nested_call_design/activation_source_review` found (1) scope-clipped crossed calls appearing nested and (2) ALT sibling return order incorrectly rejecting true nesting. Corrections retain correlation-level reply endpoints and compare only compatible reply paths; critic rechecked both. This is source review, not independent runtime acceptance. The critic disclosed one initial read-only git diff despite its requested no-Git boundary; no Git mutation occurred. + +Executed: rustfmt with edition 2024 and skip_children=true on the three owned files; unstaged and staged `git diff --check`; owned-files commit. No compiler, Cargo, desktop/native input, Gitea or root tracked edits. Initial checkout failed on historical long filenames; per-command `git -c core.longpaths=true worktree add` succeeded without changing global settings or overwriting existing work. + +Root had previously compiled/run `.local/nested-call-fixtures-20260912.rs` against exact full425 core dependencies: `.local/native-qa/nested-call-f7-core/build.json`, `fixtures.json`/log; output `.local/native-qa/nested-call-fixture-20260912`; 132 elements / 77 completeness warnings. This validates that separate fixture generator, not the new desktop implementation. + +Next: root compiles commit 43c2d51 and runs `behavior::scenario_activation::tests`, existing `behavior::direct_canvas_tests` activation/ALT/selection gates and affected workspace/input tests. Verify actual unselected and selected paint, both-direction message edge anchors, loops, shoulder selection, source correlation edits, Undo/Redo and save/reopen with a bound exchange. The fixture intentionally omits exchange references to isolate activation geometry; repeat the user model with actual exchanges/values for native acceptance. + +Width 12 and offset 6 are world-pixel style candidates. At scale .05 they become .6/.3 screen pixels: pointer identity tests at that scale do **not** prove raster legibility or practical selection. Root explicitly retains native evaluation at realistic and minimum scale. Incomplete isolated calls keep the existing 26-unit open stub; branch continuations remain explicit open continuations. No general execution/thread metamodel or new LIFO rule is introduced. This work does not satisfy issues 20/22's free geometry or the broader Behavior UX objective. diff --git a/harness/experiments/canvas-editing-followup-20260912/always-active-review.md b/harness/experiments/canvas-editing-followup-20260912/always-active-review.md new file mode 100644 index 00000000..e30c91da --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/always-active-review.md @@ -0,0 +1,58 @@ +# Issue 25 — remove misleading canvas activation controls + +Root owns Gitea issue 25 (claim/recheck comment 668), compilation and native +acceptance. This worker owns the isolated worktree +`C:/Users/User/Documents/Git/ARCADIA-Studio/.local/always-active-canvas-20260912`, +branch `codex/always-active-canvas-956atf-20260912`, baseline `e57c390`. + +## Source finding and scope decision + +There is no canvas activation gate to turn on. The production Viewport accepts +the first clean pointer press, passes semantic hits/tools to its child, and +focuses that canvas through ordinary pointer ownership. Gesture eligibility is +derived from valid clean ownership, not either removed control. + +The toolbar's `Canvas` control only dispatched keyboard Focus. The header's +`Focus canvas`/`Restore panels` control toggled presentation panel visibility; +top-level views.rs reads the corresponding presentation state. Neither enabled +editing. F6/Tab focus operations and pointer focus are legitimate separate input +ownership policies, particularly while Inspector or a form owns typing. + +Parent explicitly approved removing both affordances and the unused controls() +focus argument while preserving the independent existing panel-layout command +semantics. Details/panel redesign remains issue 24. Free geometry remains issues +20/22. No behavior.rs or scenario_activation files changed. + +## Changes + +- Remove `Canvas` and `Focus canvas`/`Restore panels` widgets from process and + scenario presentation. Remove their local event/intent plumbing and the shared + controls() focus argument. +- Keep F6/Tab/Enter/Space/Escape guidance on the remaining toolbar tooltip. +- Extend actual mounted process OA/SA and scenario editing checks with absent + Canvas/Panels control identities and no initial keyboard focus grab. Existing + first canvas pan, tool selection and canvas creation clicks require no prior + activation and keep their source/model/form-lifetime checks. +- Keyboard tests traverse directly from Fit through the remaining controls to + viewport, preserving real focus, visible rings, F6 entry/exit and Inspector + typing checks. +- Retained toolbar tests capture only controls that still exist. Independent + panel-layout lifetime tests invoke the public presentation command and retain + their stale camera/gesture/source checks. + +## Verification and handoff + +`git diff --check` passed. No Cargo/compiler/native/Gitea operations were run. +Attempting to reuse the independent Astra/high critic failed with `agent thread +limit reached`. Root completed source review and found scope, first-click, +F6 and text ownership changes sound; commit authorized. +No executable or native acceptance is claimed. + +Useful root Windows filters: + +- `behavior::topology::view::layout_tests::` +- `behavior::scenario::workspace::tests::production_` +- `app::behavior_removal_tests::` for retained keyboard/text-ownership dependents + +The root should inspect the native default process/scenario view, first-click +selection/tool creation, F6/Tab keyboard entry and typing after Inspector focus. diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-fixture-preparation.md b/harness/experiments/canvas-editing-followup-20260912/bound-fixture-preparation.md new file mode 100644 index 00000000..d4a50e30 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-fixture-preparation.md @@ -0,0 +1,21 @@ +# Bound native activation fixture — source handoff + +Generator: `.local/nested-call-bound-fixture-20260912.rs`. Source-only; no compiler, Cargo, native UI, Git or Gitea calls. Root owns compilation/execution and acceptance. Rustfmt only checks/formats Rust syntax; it does not establish type correctness or fixture admission. + +Root's first version compiled with `-D warnings` but generation failed before writing output (exit 101). The exact failed source is preserved as `.local/native-qa/nested-bound-b250-core/probe-source.rs`, SHA256 `c5a5ce13c1910ecde13ff3e4ae9f551db521e2818ae28f4b5bded9da69c37102`, verified against `build.json` before editing. The first failed constructor was `Kind::Actor` in SA: the actual public kind is `Kind::SystemActor`. Generic `make_element(Kind::Port, ...)` would also fail intentionally; revised source now uses `ports::make_port` with explicit owner and Standard component contract. Validation, operation proof, values and whole-Project equality checks remain unchanged. Revised source awaits root's new compile/run receipts; this correction is not yet a runtime pass. + +The fresh Project contains three compact scenarios, each two lifelines/four messages in exact order C1,C2,R2,R1: + +| Scenario | Binding | +| --- | --- | +| OA Nested pressure checks | Two Activity lifelines; actual Interaction carrying an Information/Operation item; In `requested_pressure` and Return `measured_pressure`, both Real kPa. | +| SA Nested pressure checks | Actor/System lifelines; concrete Standard component ports; required/provided interface; synchronous InterfaceItemAllocation; BoundaryExchange carrying that operation; both Calls explicitly select that exact allocation, Replies derive it from their correlated Calls. | +| OA Reentrant pressure review | C1 L1→L2; C2 L2→L1 through an explicit reverse Interaction; R2 L1→L2; R1 L2→L1. All four remain bound to the correct channel/item and carry values. | + +C1 requests `420.0` and R1 returns `418.0`; C2 requests `380.0` and R2 returns `378.0`. Every message carries one nonempty expression. IDs use the deterministic `21b00d00-0000-4000-8000-...` namespace; Call UUID order is deliberately opposite to semantic sequence order. Scenario numeric ID suffixes are 1000, 2000, and 3000; the generated TSV records actual UUID strings. Unicode `Δ pressure · 戻り値` is retained in the project description and whole-Project round trip. + +Contract evidence read: `crates/oa-core/tests/source7_contract.rs` operation fixture/resolution and `operation_edit`; `crates/oa-core/src/operations.rs` exact allocation, channel, provider/caller port and reply derivation checks; `crates/oa-core/tests/r6_data.rs` OA Interaction carrying an Operation item with directional parameters/values; current `model.rs` constructors and field shapes. The OA case deliberately stores no OperationUse, which core limits to SA BoundaryInterface. It still has a real bound operation-item data contract. + +Execution takes exactly one **nonexistent output directory** argument and refuses existing evidence. It validates zero Errors, resolves all four SA messages to their exact Call/allocation/ports, checks values and ordered IDs, then formats/parses through actual core and asserts complete Project equality plus canonical stability before writing. Expected completeness warnings remain recorded rather than suppressed. Outputs: `bound-nested-calls.arcadia`, `scenario-identities.tsv`, `diagnostics.txt`, and `README.md`. + +Open the `.arcadia` entry and inspect the three named Behavior scenarios. Native acceptance still needs unselected/selected bar paint, exact reply ends, labels, selection, values/correlation Properties, Undo/Redo and save/reopen. Fixture admission is not activation-renderer or minimum-scale raster acceptance. No second include file is introduced: this fixture targets compact native activation behavior; comments/include preservation already has separate evaluators. diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-fixture.rs b/harness/experiments/canvas-editing-followup-20260912/bound-fixture.rs new file mode 100644 index 00000000..2d5f59e8 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-fixture.rs @@ -0,0 +1,527 @@ +//! Source-only native fixture generator for issue 21; root compiles/runs it. +//! Uses actual oa-core validation, operation resolution, and whole-Project source round trips. +//! Usage: nested-call-bound-fixture.exe NEW_OUTPUT_DIRECTORY +use oa_core::{operations, validation, *}; +use std::{fs, path::Path}; + +fn id(n: u128) -> Id { + Id::from_u128(0x21b00d00000040008000000000000000 + n) +} +fn element( + p: &mut Project, + layer: Layer, + n: u128, + kind: Kind, + name: &str, + parent: Option, +) -> Id { + let mut e = p + .make_element(kind, layer, name, parent) + .unwrap_or_else(|| { + panic!("No generic constructor for {layer:?} {kind:?} '{name}' (fixture ID {n})") + }); + e.id = id(n); + e.alias = format!("bound_{n}"); + assert!(p.elements.insert(e.id, e).is_none()); + id(n) +} +fn shared(p: &mut Project, element: Id, body: SharedBody) { + *p.elements.get_mut(&element).unwrap().shared_mut().unwrap() = body; +} +fn component_port(p: &mut Project, n: u128, owner: Id, name: &str) -> Id { + let mut port = ports::make_port( + p, + id(n), + owner, + name, + PortContract::Component { + kind: ComponentPortKind::Standard, + orientation: ComponentPortOrientation::Unset, + }, + ) + .expect("Explicit component-port contract and owner"); + port.alias = format!("bound_{n}"); + assert!(p.elements.insert(port.id, port).is_none()); + id(n) +} +fn relation(p: &mut Project, n: u128, name: &str, body: RelationBody) -> Id { + let r = Relation { + id: id(n), + alias: format!("bound_{n}"), + name: name.into(), + description: String::new(), + body, + }; + assert!(p.relations.insert(r.id, r).is_none()); + id(n) +} +fn parameter( + p: &mut Project, + layer: Layer, + n: u128, + owner: Id, + name: &str, + direction: ParameterDirection, +) -> Id { + let field = element(p, layer, n, Kind::DataField, name, Some(owner)); + shared( + p, + field, + SharedBody::DataField { + type_ref: TypeRef::Real, + minimum: 1, + maximum: Some(1), + unit: "kPa".into(), + direction, + storage: FieldStorage::Value, + default: None, + }, + ); + field +} +#[derive(Clone, Copy)] +struct Contract { + layer: Layer, + requester: Id, + responder: Id, + channel: Id, + operation: Option, + input: Id, + output: Id, +} +fn oa_contract(p: &mut Project) -> Contract { + let layer = Layer::Oa; + let requester = element( + p, + layer, + 100, + Kind::Activity, + "Review pressure demand", + None, + ); + let responder = element(p, layer, 101, Kind::Activity, "Inspect pressure", None); + let item = element(p, layer, 110, Kind::ExchangeItem, "Check pressure", None); + shared( + p, + item, + SharedBody::ExchangeItem { + kind: ExchangeItemKind::Information, + mechanism: ExchangeMechanism::Operation, + supertype: None, + }, + ); + let input = parameter( + p, + layer, + 111, + item, + "requested_pressure", + ParameterDirection::In, + ); + let output = parameter( + p, + layer, + 112, + item, + "measured_pressure", + ParameterDirection::Return, + ); + let channel = relation( + p, + 120, + "Pressure check", + RelationBody::Interaction { + source: requester, + target: responder, + items: vec![item], + }, + ); + Contract { + layer, + requester, + responder, + channel, + operation: None, + input, + output, + } +} +fn sa_contract(p: &mut Project) -> Contract { + let layer = Layer::Sa; + let requester = element(p, layer, 200, Kind::SystemActor, "Operator console", None); + let responder = element(p, layer, 201, Kind::System, "Pressure service", None); + let caller_port = component_port(p, 202, requester, "Client socket"); + let provider_port = component_port(p, 203, responder, "Service socket"); + let item = element(p, layer, 210, Kind::ExchangeItem, "Check pressure", None); + shared( + p, + item, + SharedBody::ExchangeItem { + kind: ExchangeItemKind::Information, + mechanism: ExchangeMechanism::Operation, + supertype: None, + }, + ); + let input = parameter( + p, + layer, + 211, + item, + "requested_pressure", + ParameterDirection::In, + ); + let output = parameter( + p, + layer, + 212, + item, + "measured_pressure", + ParameterDirection::Return, + ); + let interface = element(p, layer, 213, Kind::Interface, "Pressure check API", None); + shared(p, interface, SharedBody::Interface { supertype: None }); + let allocation = relation( + p, + 220, + "Synchronous pressure check", + RelationBody::InterfaceItemAllocation { + source: interface, + target: item, + order: 0, + transmission: TransmissionProtocol::Synchronous, + acquisition: AcquisitionProtocol::Unspecified, + }, + ); + relation( + p, + 221, + "Console requires check", + RelationBody::InterfaceRequirement { + source: caller_port, + target: interface, + }, + ); + relation( + p, + 222, + "Service provides check", + RelationBody::InterfaceProvision { + source: provider_port, + target: interface, + }, + ); + let channel = relation( + p, + 223, + "Pressure channel", + RelationBody::BoundaryExchange { + source: caller_port, + target: provider_port, + oriented: false, + items: vec![item], + }, + ); + Contract { + layer, + requester, + responder, + channel, + operation: Some(allocation), + input, + output, + } +} +struct Case { + owner: Id, + caller: Id, + callee: Id, + call: Id, + inner: Id, + inner_reply: Id, + reply: Id, +} +fn message( + p: &mut Project, + contract: Contract, + n: u128, + owner: Id, + name: &str, + endpoints: (Id, Id), + reply_and_value: (Option, &str), +) -> Id { + let (reply, expression) = reply_and_value; + let message = element(p, contract.layer, n, Kind::Occurrence, name, Some(owner)); + shared( + p, + message, + SharedBody::Occurrence { + body: OccurrenceBody::Exchange { + operation: if reply.is_none() { + contract.operation.map(|allocation| OperationUse { + allocation: Some(allocation), + }) + } else { + None + }, + exchange: Some(contract.channel), + sender: Some(endpoints.0), + receiver: Some(endpoints.1), + message_kind: if reply.is_some() { + MessageKind::Reply + } else { + MessageKind::Call + }, + reply_to: reply, + values: vec![MessageValue { + field: if reply.is_some() { + contract.output + } else { + contract.input + }, + path: vec![], + expression: expression.into(), + }], + }, + precondition: String::new(), + postcondition: String::new(), + }, + ); + message +} +fn scenario( + p: &mut Project, + contract: Contract, + base: u128, + name: &str, + callback: Option, +) -> Case { + let owner = element(p, contract.layer, base, Kind::Scenario, name, None); + shared( + p, + owner, + SharedBody::Scenario { + viewpoint: if contract.layer == Layer::Oa { + ScenarioViewpoint::OperationalActivity + } else { + ScenarioViewpoint::BoundaryInterface + }, + context: None, + precondition: "Two pressure checks are reviewed before the outer reply".into(), + postcondition: "Each reply retains its own requested and measured values".into(), + steps: vec![], + }, + ); + let caller = element( + p, + contract.layer, + base + 1, + Kind::Lifeline, + "L1 Console", + Some(owner), + ); + let callee = element( + p, + contract.layer, + base + 2, + Kind::Lifeline, + "L2 Inspector", + Some(owner), + ); + shared( + p, + caller, + SharedBody::Lifeline { + represented: Some(contract.requester), + }, + ); + shared( + p, + callee, + SharedBody::Lifeline { + represented: Some(contract.responder), + }, + ); + // Reverse UUID order deliberately: chronological order comes from steps. + let call = message( + p, + contract, + base + 40, + owner, + "C1 420 kPa", + (caller, callee), + (None, "420.0"), + ); + let inner_contract = Contract { + channel: callback.unwrap_or(contract.channel), + ..contract + }; + let inner_endpoints = if callback.is_some() { + (callee, caller) + } else { + (caller, callee) + }; + let inner = message( + p, + inner_contract, + base + 30, + owner, + "C2 380 kPa", + inner_endpoints, + (None, "380.0"), + ); + let inner_reply = message( + p, + inner_contract, + base + 60, + owner, + "R2 378 kPa", + (inner_endpoints.1, inner_endpoints.0), + (Some(inner), "378.0"), + ); + let reply = message( + p, + contract, + base + 50, + owner, + "R1 418 kPa", + (callee, caller), + (Some(call), "418.0"), + ); + *p.elements.get_mut(&owner).unwrap().steps_mut().unwrap() = + vec![call, inner, inner_reply, reply]; + Case { + owner, + caller, + callee, + call, + inner, + inner_reply, + reply, + } +} +fn assert_case(p: &Project, case: &Case, contract: Contract) { + assert_eq!( + p.elements[&case.owner].steps().unwrap(), + &vec![case.call, case.inner, case.inner_reply, case.reply] + ); + for (message, invocation, expression) in [ + (case.call, case.call, "420.0"), + (case.inner, case.inner, "380.0"), + (case.inner_reply, case.inner, "378.0"), + (case.reply, case.call, "418.0"), + ] { + let Some(SharedBody::Occurrence { + body: + OccurrenceBody::Exchange { + values, + exchange, + sender, + receiver, + .. + }, + .. + }) = p.elements[&message].shared() + else { + panic!("Missing message"); + }; + assert!(exchange.is_some() && sender.is_some() && receiver.is_some()); + assert_eq!(values.len(), 1); + assert_eq!(values[0].expression, expression); + if let Some(allocation) = contract.operation { + let operations::OperationResolution::Selected(proof) = + operations::resolve(p, message).unwrap() + else { + panic!("Operation is not actually resolved"); + }; + assert_eq!(proof.invocation, invocation); + assert_eq!(proof.allocation, allocation); + assert_eq!(proof.caller_port, id(202)); + assert_eq!(proof.provider_port, id(203)); + } else { + assert_eq!( + operations::resolve(p, message).unwrap(), + operations::OperationResolution::Ordinary + ); + } + } +} +fn main() { + let args: Vec<_> = std::env::args().collect(); + assert_eq!(args.len(), 2, "Pass a NEW output directory"); + let directory = Path::new(&args[1]); + assert!( + !directory.exists(), + "Refuse to replace existing native evidence" + ); + let mut p = Project::empty(); + p.id = id(1); + p.alias = "bound_nested_calls".into(); + p.name = "Bound nested pressure checks".into(); + p.description = "Native activation acceptance. Requested 420/380 kPa, measured 418/378 kPa. Unicode readback: Δ pressure · 戻り値.".into(); + let oa = oa_contract(&mut p); + let sa = sa_contract(&mut p); + let oa_case = scenario(&mut p, oa, 1000, "OA Nested pressure checks", None); + let sa_case = scenario(&mut p, sa, 2000, "SA Nested pressure checks", None); + let callback = relation( + &mut p, + 121, + "Demand review callback", + RelationBody::Interaction { + source: oa.responder, + target: oa.requester, + items: vec![id(110)], + }, + ); + let reentrant = scenario( + &mut p, + oa, + 3000, + "OA Reentrant pressure review", + Some(callback), + ); + let issues = validation::validate(&p); + let errors: Vec<_> = issues + .iter() + .filter(|i| i.severity == validation::Severity::Error) + .collect(); + assert!( + errors.is_empty(), + "Actual core rejects fixture: {errors:#?}" + ); + for (case, contract) in [(&oa_case, oa), (&sa_case, sa), (&reentrant, oa)] { + assert_case(&p, case, contract); + } + let canonical = language::format(&p); + let reparsed = + language::parse(&canonical).expect("Canonical source must parse through actual core"); + assert_eq!( + reparsed, p, + "Whole-Project equality, not only ordered steps" + ); + assert_eq!(language::format(&reparsed), canonical); + let mut manifest = String::from("scenario\towner\tL1\tL2\tC1\tC2\tR2\tR1\n"); + for case in [&oa_case, &sa_case, &reentrant] { + manifest.push_str(&format!( + "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n", + p.named(case.owner), + case.owner, + case.caller, + case.callee, + case.call, + case.inner, + case.inner_reply, + case.reply + )); + } + fs::create_dir(directory).unwrap(); + fs::write(directory.join("bound-nested-calls.arcadia"), canonical).unwrap(); + fs::write(directory.join("scenario-identities.tsv"), manifest).unwrap(); + fs::write(directory.join("diagnostics.txt"), format!("{issues:#?}\n")).unwrap(); + fs::write(directory.join("README.md"), "Open bound-nested-calls.arcadia. In Behavior select OA Nested pressure checks, SA Nested pressure checks, or OA Reentrant pressure review. Each has two lifelines and four rows ordered C1,C2,R2,R1. C1 requests 420.0 kPa and R1 returns 418.0; C2 requests 380.0 and R2 returns 378.0. The SA messages resolve an actual synchronous interface-operation allocation; Replies derive it from their exact Calls. OA uses a bound Interaction carrying an Operation item without SA-only OperationUse. The reentrant case uses an explicit reverse Interaction for C2/R2. Check unselected bars, both reply ends, each bar's selection, Properties values/correlation, source parity and save/reopen. scenario-identities.tsv lists every UI target UUID. diagnostics.txt records completeness warnings. Generator validation and roundtrip are not desktop paint or native acceptance.\n").unwrap(); + println!( + "PASS: {} elements, {} relations, three bound scenarios, zero Errors, {} warnings; whole-Project roundtrip and exact SA operation resolution", + p.elements.len(), + p.relations.len(), + issues.len() + ); +} diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/README.md b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/README.md new file mode 100644 index 00000000..0d1642e3 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/README.md @@ -0,0 +1 @@ +Open bound-nested-calls.arcadia. In Behavior select OA Nested pressure checks, SA Nested pressure checks, or OA Reentrant pressure review. Each has two lifelines and four rows ordered C1,C2,R2,R1. C1 requests 420.0 kPa and R1 returns 418.0; C2 requests 380.0 and R2 returns 378.0. The SA messages resolve an actual synchronous interface-operation allocation; Replies derive it from their exact Calls. OA uses a bound Interaction carrying an Operation item without SA-only OperationUse. The reentrant case uses an explicit reverse Interaction for C2/R2. Check unselected bars, both reply ends, each bar's selection, Properties values/correlation, source parity and save/reopen. scenario-identities.tsv lists every UI target UUID. diagnostics.txt records completeness warnings. Generator validation and roundtrip are not desktop paint or native acceptance. diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia new file mode 100644 index 00000000..45d95f6d --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia @@ -0,0 +1,486 @@ +arcadia 7; +project bound_nested_calls "Bound nested pressure checks" id "21b00d00-0000-4000-8000-000000000001" { + description "Native activation acceptance. Requested 420/380 kPa, measured 418/378 kPa. Unicode readback: Δ pressure · 戻り値."; + + oa_activity bound_100 "Review pressure demand" id "21b00d00-0000-4000-8000-000000000064" { + description ""; + parent none; + } + + oa_activity bound_101 "Inspect pressure" id "21b00d00-0000-4000-8000-000000000065" { + description ""; + parent none; + } + + oa_exchange_item bound_110 "Check pressure" id "21b00d00-0000-4000-8000-00000000006e" { + description ""; + kind Information; + mechanism Operation; + parent none; + supertype none; + } + + oa_data_field bound_111 "requested_pressure" id "21b00d00-0000-4000-8000-00000000006f" { + default none; + description ""; + direction In; + maximum 1; + minimum 1; + parent @bound_110; + storage Value; + type_ref Real; + unit "kPa"; + } + + oa_data_field bound_112 "measured_pressure" id "21b00d00-0000-4000-8000-000000000070" { + default none; + description ""; + direction Return; + maximum 1; + minimum 1; + parent @bound_110; + storage Value; + type_ref Real; + unit "kPa"; + } + + sa_actor bound_200 "Operator console" id "21b00d00-0000-4000-8000-0000000000c8" { + description ""; + parent none; + } + + sa_system bound_201 "Pressure service" id "21b00d00-0000-4000-8000-0000000000c9" { + description ""; + parent none; + } + + sa_port bound_202 "Client socket" id "21b00d00-0000-4000-8000-0000000000ca" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @bound_200; + } + + sa_port bound_203 "Service socket" id "21b00d00-0000-4000-8000-0000000000cb" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @bound_201; + } + + sa_exchange_item bound_210 "Check pressure" id "21b00d00-0000-4000-8000-0000000000d2" { + description ""; + kind Information; + mechanism Operation; + parent none; + supertype none; + } + + sa_data_field bound_211 "requested_pressure" id "21b00d00-0000-4000-8000-0000000000d3" { + default none; + description ""; + direction In; + maximum 1; + minimum 1; + parent @bound_210; + storage Value; + type_ref Real; + unit "kPa"; + } + + sa_data_field bound_212 "measured_pressure" id "21b00d00-0000-4000-8000-0000000000d4" { + default none; + description ""; + direction Return; + maximum 1; + minimum 1; + parent @bound_210; + storage Value; + type_ref Real; + unit "kPa"; + } + + sa_interface bound_213 "Pressure check API" id "21b00d00-0000-4000-8000-0000000000d5" { + description ""; + parent none; + supertype none; + } + + oa_scenario bound_1000 "OA Nested pressure checks" id "21b00d00-0000-4000-8000-0000000003e8" { + context none; + description ""; + parent none; + postcondition "Each reply retains its own requested and measured values"; + precondition "Two pressure checks are reviewed before the outer reply"; + steps [@bound_1040, @bound_1030, @bound_1060, @bound_1050]; + viewpoint OperationalActivity; + } + + oa_lifeline bound_1001 "L1 Console" id "21b00d00-0000-4000-8000-0000000003e9" { + description ""; + parent @bound_1000; + represented @bound_100; + } + + oa_lifeline bound_1002 "L2 Inspector" id "21b00d00-0000-4000-8000-0000000003ea" { + description ""; + parent @bound_1000; + represented @bound_101; + } + + oa_occurrence bound_1030 "C2 380 kPa" id "21b00d00-0000-4000-8000-000000000406" { + body { + Exchange { + exchange @bound_120; + message_kind Call; + receiver @bound_1002; + reply_to none; + sender @bound_1001; + values [{ + expression "380.0"; + field @bound_111; + path []; + }]; + }; + }; + description ""; + parent @bound_1000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_1040 "C1 420 kPa" id "21b00d00-0000-4000-8000-000000000410" { + body { + Exchange { + exchange @bound_120; + message_kind Call; + receiver @bound_1002; + reply_to none; + sender @bound_1001; + values [{ + expression "420.0"; + field @bound_111; + path []; + }]; + }; + }; + description ""; + parent @bound_1000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_1050 "R1 418 kPa" id "21b00d00-0000-4000-8000-00000000041a" { + body { + Exchange { + exchange @bound_120; + message_kind Reply; + receiver @bound_1001; + reply_to @bound_1040; + sender @bound_1002; + values [{ + expression "418.0"; + field @bound_112; + path []; + }]; + }; + }; + description ""; + parent @bound_1000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_1060 "R2 378 kPa" id "21b00d00-0000-4000-8000-000000000424" { + body { + Exchange { + exchange @bound_120; + message_kind Reply; + receiver @bound_1001; + reply_to @bound_1030; + sender @bound_1002; + values [{ + expression "378.0"; + field @bound_112; + path []; + }]; + }; + }; + description ""; + parent @bound_1000; + postcondition ""; + precondition ""; + } + + sa_scenario bound_2000 "SA Nested pressure checks" id "21b00d00-0000-4000-8000-0000000007d0" { + context none; + description ""; + parent none; + postcondition "Each reply retains its own requested and measured values"; + precondition "Two pressure checks are reviewed before the outer reply"; + steps [@bound_2040, @bound_2030, @bound_2060, @bound_2050]; + viewpoint BoundaryInterface; + } + + sa_lifeline bound_2001 "L1 Console" id "21b00d00-0000-4000-8000-0000000007d1" { + description ""; + parent @bound_2000; + represented @bound_200; + } + + sa_lifeline bound_2002 "L2 Inspector" id "21b00d00-0000-4000-8000-0000000007d2" { + description ""; + parent @bound_2000; + represented @bound_201; + } + + sa_occurrence bound_2030 "C2 380 kPa" id "21b00d00-0000-4000-8000-0000000007ee" { + body { + Exchange { + exchange @bound_223; + message_kind Call; + operation { + allocation @bound_220; + }; + receiver @bound_2002; + reply_to none; + sender @bound_2001; + values [{ + expression "380.0"; + field @bound_211; + path []; + }]; + }; + }; + description ""; + parent @bound_2000; + postcondition ""; + precondition ""; + } + + sa_occurrence bound_2040 "C1 420 kPa" id "21b00d00-0000-4000-8000-0000000007f8" { + body { + Exchange { + exchange @bound_223; + message_kind Call; + operation { + allocation @bound_220; + }; + receiver @bound_2002; + reply_to none; + sender @bound_2001; + values [{ + expression "420.0"; + field @bound_211; + path []; + }]; + }; + }; + description ""; + parent @bound_2000; + postcondition ""; + precondition ""; + } + + sa_occurrence bound_2050 "R1 418 kPa" id "21b00d00-0000-4000-8000-000000000802" { + body { + Exchange { + exchange @bound_223; + message_kind Reply; + receiver @bound_2001; + reply_to @bound_2040; + sender @bound_2002; + values [{ + expression "418.0"; + field @bound_212; + path []; + }]; + }; + }; + description ""; + parent @bound_2000; + postcondition ""; + precondition ""; + } + + sa_occurrence bound_2060 "R2 378 kPa" id "21b00d00-0000-4000-8000-00000000080c" { + body { + Exchange { + exchange @bound_223; + message_kind Reply; + receiver @bound_2001; + reply_to @bound_2030; + sender @bound_2002; + values [{ + expression "378.0"; + field @bound_212; + path []; + }]; + }; + }; + description ""; + parent @bound_2000; + postcondition ""; + precondition ""; + } + + oa_scenario bound_3000 "OA Reentrant pressure review" id "21b00d00-0000-4000-8000-000000000bb8" { + context none; + description ""; + parent none; + postcondition "Each reply retains its own requested and measured values"; + precondition "Two pressure checks are reviewed before the outer reply"; + steps [@bound_3040, @bound_3030, @bound_3060, @bound_3050]; + viewpoint OperationalActivity; + } + + oa_lifeline bound_3001 "L1 Console" id "21b00d00-0000-4000-8000-000000000bb9" { + description ""; + parent @bound_3000; + represented @bound_100; + } + + oa_lifeline bound_3002 "L2 Inspector" id "21b00d00-0000-4000-8000-000000000bba" { + description ""; + parent @bound_3000; + represented @bound_101; + } + + oa_occurrence bound_3030 "C2 380 kPa" id "21b00d00-0000-4000-8000-000000000bd6" { + body { + Exchange { + exchange @bound_121; + message_kind Call; + receiver @bound_3001; + reply_to none; + sender @bound_3002; + values [{ + expression "380.0"; + field @bound_111; + path []; + }]; + }; + }; + description ""; + parent @bound_3000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_3040 "C1 420 kPa" id "21b00d00-0000-4000-8000-000000000be0" { + body { + Exchange { + exchange @bound_120; + message_kind Call; + receiver @bound_3002; + reply_to none; + sender @bound_3001; + values [{ + expression "420.0"; + field @bound_111; + path []; + }]; + }; + }; + description ""; + parent @bound_3000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_3050 "R1 418 kPa" id "21b00d00-0000-4000-8000-000000000bea" { + body { + Exchange { + exchange @bound_120; + message_kind Reply; + receiver @bound_3001; + reply_to @bound_3040; + sender @bound_3002; + values [{ + expression "418.0"; + field @bound_112; + path []; + }]; + }; + }; + description ""; + parent @bound_3000; + postcondition ""; + precondition ""; + } + + oa_occurrence bound_3060 "R2 378 kPa" id "21b00d00-0000-4000-8000-000000000bf4" { + body { + Exchange { + exchange @bound_121; + message_kind Reply; + receiver @bound_3002; + reply_to @bound_3030; + sender @bound_3001; + values [{ + expression "378.0"; + field @bound_112; + path []; + }]; + }; + }; + description ""; + parent @bound_3000; + postcondition ""; + precondition ""; + } + + interaction bound_120 "Pressure check" id "21b00d00-0000-4000-8000-000000000078" { + description ""; + items [@bound_110]; + source @bound_100; + target @bound_101; + } + + interaction bound_121 "Demand review callback" id "21b00d00-0000-4000-8000-000000000079" { + description ""; + items [@bound_110]; + source @bound_101; + target @bound_100; + } + + interface_item_allocation bound_220 "Synchronous pressure check" id "21b00d00-0000-4000-8000-0000000000dc" { + acquisition Unspecified; + description ""; + order 0; + source @bound_213; + target @bound_210; + transmission Synchronous; + } + + interface_requirement bound_221 "Console requires check" id "21b00d00-0000-4000-8000-0000000000dd" { + description ""; + source @bound_202; + target @bound_213; + } + + interface_provision bound_222 "Service provides check" id "21b00d00-0000-4000-8000-0000000000de" { + description ""; + source @bound_203; + target @bound_213; + } + + boundary_exchange bound_223 "Pressure channel" id "21b00d00-0000-4000-8000-0000000000df" { + description ""; + items [@bound_210]; + oriented false; + source @bound_202; + target @bound_203; + } + +} diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/diagnostics.txt b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/diagnostics.txt new file mode 100644 index 00000000..b026a721 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/diagnostics.txt @@ -0,0 +1,24 @@ +[ + Issue { + severity: Warning, + element: Some( + 21b00d00-0000-4000-8000-000000000064, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Review pressure demand' to a performer.", + }, + Issue { + severity: Warning, + element: Some( + 21b00d00-0000-4000-8000-000000000065, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Inspect pressure' to a performer.", + }, +] diff --git a/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/scenario-identities.tsv b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/scenario-identities.tsv new file mode 100644 index 00000000..7cd0cd19 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/scenario-identities.tsv @@ -0,0 +1,4 @@ +scenario owner L1 L2 C1 C2 R2 R1 +OA Nested pressure checks 21b00d00-0000-4000-8000-0000000003e8 21b00d00-0000-4000-8000-0000000003e9 21b00d00-0000-4000-8000-0000000003ea 21b00d00-0000-4000-8000-000000000410 21b00d00-0000-4000-8000-000000000406 21b00d00-0000-4000-8000-000000000424 21b00d00-0000-4000-8000-00000000041a +SA Nested pressure checks 21b00d00-0000-4000-8000-0000000007d0 21b00d00-0000-4000-8000-0000000007d1 21b00d00-0000-4000-8000-0000000007d2 21b00d00-0000-4000-8000-0000000007f8 21b00d00-0000-4000-8000-0000000007ee 21b00d00-0000-4000-8000-00000000080c 21b00d00-0000-4000-8000-000000000802 +OA Reentrant pressure review 21b00d00-0000-4000-8000-000000000bb8 21b00d00-0000-4000-8000-000000000bb9 21b00d00-0000-4000-8000-000000000bba 21b00d00-0000-4000-8000-000000000be0 21b00d00-0000-4000-8000-000000000bd6 21b00d00-0000-4000-8000-000000000bf4 21b00d00-0000-4000-8000-000000000bea diff --git a/harness/experiments/canvas-editing-followup-20260912/draft-fixture.rs b/harness/experiments/canvas-editing-followup-20260912/draft-fixture.rs new file mode 100644 index 00000000..a45c52ba --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/draft-fixture.rs @@ -0,0 +1,107 @@ +//! Actual oa-core fixtures for issue 21. Source-only contribution; NOT compiled/run. +//! Link to the current oa_core rlib, then run with a NEW output directory argument. +//! Draw/paint/hit verification belongs to the production desktop, not this probe. +use oa_core::*; +use std::{fs, path::Path}; + +fn id(n: u128) -> Id { Id::from_u128(0x21ca1100000040008000000000000000 + n) } +fn seed(p: &mut Project, layer: Layer, n: u128, kind: Kind, name: &str, parent: Option) -> Id { + let mut e = p.make_element(kind, layer, name, parent).unwrap(); + e.id = id(n); + e.alias = format!("activation_{n}"); + let result = e.id; + assert!(p.elements.insert(result, e).is_none()); + result +} +fn occurrence(p: &mut Project, layer: Layer, n: u128, name: &str, parent: Id, body: OccurrenceBody) -> Id { + let result = seed(p, layer, n, Kind::Occurrence, name, Some(parent)); + *p.elements.get_mut(&result).unwrap().shared_mut().unwrap() = SharedBody::Occurrence { + body, precondition: String::new(), postcondition: String::new(), + }; + result +} +fn message(p: &mut Project, layer: Layer, n: u128, name: &str, parent: Id, sender: Id, receiver: Id, reply: Option) -> Id { + occurrence(p, layer, n, name, parent, OccurrenceBody::Exchange { + operation: None, exchange: None, sender: Some(sender), receiver: Some(receiver), + message_kind: if reply.is_some() { MessageKind::Reply } else { MessageKind::Call }, + reply_to: reply, values: vec![], + }) +} +fn steps(p: &mut Project, owner: Id, values: Vec) { + *p.elements.get_mut(&owner).unwrap().steps_mut().unwrap() = values; +} +fn main() { + let args: Vec<_> = std::env::args().collect(); + assert_eq!(args.len(), 2, "Pass a NEW output directory"); + let directory = Path::new(&args[1]); + assert!(!directory.exists(), "Preserve existing evidence; use a fresh directory"); + let mut p = Project::empty(); + p.id = id(1); + p.alias = "nested_call_evaluator".into(); + p.name = "Nested call activation evaluator".into(); + p.description = "Draft exchange references intentionally absent; exact lifelines and correlations isolate receiver activation geometry.".into(); + for (side, layer) in [(0u128, Layer::Oa), (1, Layer::Sa)] { + let base = 10000 + side * 10000; + let work_kind = if layer == Layer::Oa { Kind::Activity } else { Kind::Function }; + let a = seed(&mut p, layer, base, work_kind, "Caller work", None); + let b = seed(&mut p, layer, base + 1, work_kind, "Callee work", None); + for (case_index, case) in ["nested", "sequential", "crossed", "self", "reentrant", "open", "alt", "parallel"].iter().enumerate() { + let n = base + 100 + case_index as u128 * 100; + let owner = seed(&mut p, layer, n, Kind::Scenario, &format!("{layer:?} {case}"), None); + if let SharedBody::Scenario { viewpoint, .. } = p.elements.get_mut(&owner).unwrap().shared_mut().unwrap() { + *viewpoint = if layer == Layer::Oa { ScenarioViewpoint::OperationalActivity } else { ScenarioViewpoint::Functional }; + } + let l1 = seed(&mut p, layer, n + 1, Kind::Lifeline, "L1 Caller", Some(owner)); + let l2 = seed(&mut p, layer, n + 2, Kind::Lifeline, "L2 Callee", Some(owner)); + for (line, represented) in [(l1, a), (l2, b)] { + *p.elements.get_mut(&line).unwrap().shared_mut().unwrap() = SharedBody::Lifeline { represented: Some(represented) }; + } + // Deliberately reverse Call UUID order compared with semantic order. + let c1 = message(&mut p, layer, n + 40, "Call 1", owner, l1, l2, None); + if *case == "alt" || *case == "parallel" { + let operator = if *case == "alt" { FragmentOperator::Alternative } else { FragmentOperator::Parallel }; + let fragment = occurrence(&mut p, layer, n + 10, case, owner, OccurrenceBody::Fragment { operator, branches: vec![id(n + 11), id(n + 12)] }); + for branch_index in 0..2u128 { + let branch = occurrence(&mut p, layer, n + 11 + branch_index, &format!("Operand {branch_index}"), fragment, OccurrenceBody::Branch { + guard: format!("condition_{branch_index}"), occurrences: vec![], + }); + let local = message(&mut p, layer, n + 20 + branch_index * 3, "Branch Call", branch, l1, l2, None); + let local_reply = message(&mut p, layer, n + 21 + branch_index * 3, "Branch Reply", branch, l2, l1, Some(local)); + let mut branch_steps = vec![local, local_reply]; + if *case == "alt" && branch_index == 0 { + let reply = message(&mut p, layer, n + 70, "Conditional outer Reply", branch, l2, l1, Some(c1)); + branch_steps.push(reply); + } + steps(&mut p, branch, branch_steps); + } + steps(&mut p, owner, vec![c1, fragment]); + continue; + } + let (from, to) = match *case { "self" => (l2, l2), "reentrant" => (l2, l1), _ => (l1, l2) }; + let c2 = message(&mut p, layer, n + 30, "Call 2", owner, from, to, None); + let r2 = message(&mut p, layer, n + 60, "Reply 2 to Call 2", owner, to, from, Some(c2)); + let r1 = message(&mut p, layer, n + 50, "Reply 1 to Call 1", owner, l2, l1, Some(c1)); + let ordered = match *case { + "sequential" => vec![c1, r1, c2, r2], + "crossed" => vec![c1, c2, r1, r2], + "open" => { p.elements.remove(&r1); vec![c1, c2, r2] }, + _ => vec![c1, c2, r2, r1], + }; + steps(&mut p, owner, ordered); + } + } + let issues = validation::validate(&p); + let errors: Vec<_> = issues.iter().filter(|i| i.severity == validation::Severity::Error).collect(); + assert!(errors.is_empty(), "Core fixture errors: {errors:#?}"); + let canonical = language::format(&p); + let reparsed = language::parse(&canonical).expect("Actual canonical source must parse"); + assert_eq!(language::format(&reparsed), canonical, "Canonical source round trip"); + assert_eq!(reparsed.elements.len(), p.elements.len()); + for (uuid, element) in &p.elements { + assert_eq!(reparsed.elements[uuid].steps(), element.steps(), "Exact ordered steps for {uuid}"); + } + fs::create_dir_all(directory).unwrap(); + fs::write(directory.join("nested-call-evaluator.arcadia"), canonical).unwrap(); + fs::write(directory.join("diagnostics.txt"), format!("{issues:#?}\n")).unwrap(); + println!("PASS actual core validation and canonical round trip: {} elements, {} warnings; no desktop draw/hit/runtime claim", p.elements.len(), issues.len()); +} diff --git a/harness/experiments/canvas-editing-followup-20260912/manifest.json b/harness/experiments/canvas-editing-followup-20260912/manifest.json new file mode 100644 index 00000000..e51f56db --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/manifest.json @@ -0,0 +1,132 @@ +[ + { + "file": "activation-design.md", + "bytes": 14414, + "sha256": "039ee45a46072697cfd05aa582b248dc6da22a17e93188a6aaaa55b5e8690501" + }, + { + "file": "activation-implementation.md", + "bytes": 3849, + "sha256": "245825817aa154ff4f46efa78b4bc8ff3f17420246a5a5fd4dd439a7a3f8fcc2" + }, + { + "file": "draft-fixture.rs", + "bytes": 6789, + "sha256": "e296ad928a4e01321d20cbcfb046a64a733561cf6f7a07d8d52eaeb64d4e4ee2" + }, + { + "file": "bound-fixture.rs", + "bytes": 15775, + "sha256": "d74a482d6433a8e0d8e82ae67eaca1b28df92920466bbb247ffac0bd1cd80928" + }, + { + "file": "bound-fixture-preparation.md", + "bytes": 3942, + "sha256": "5f045603cbf312ba3d75dd2751c01082be3a894e33f2d88a94b43cda0eaa2efb" + }, + { + "file": "state-focus-review.md", + "bytes": 8522, + "sha256": "a6e376732a7bebe65ed2779dcb74a63aef8e2dc28de8aa54a1e0c79edf378b8f" + }, + { + "file": "always-active-review.md", + "bytes": 3060, + "sha256": "ebafb01d9c2c846128d065745a616a237b073c841ebd8c9bcde8c8c77b9e53a9" + }, + { + "file": "nested-call-f7-core/build.json", + "bytes": 2090, + "sha256": "545fff7f846cd5cfe575d9a5b66b6ccf93abab799f9a70f8fbeb8a4e006d67c6" + }, + { + "file": "nested-call-f7-core/build.log", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "file": "nested-call-f7-core/fixtures.json", + "bytes": 340, + "sha256": "903ed16d6a118535a89b0f1ba2c4a59c6e8eb0e1f7e97df3828272b98b8a90c6" + }, + { + "file": "nested-call-f7-core/fixtures.log", + "bytes": 115, + "sha256": "6df65352be448872b2485700615fec64e898f37427572b9cade519337f0693e2" + }, + { + "file": "nested-bound-b250-core/build.json", + "bytes": 2113, + "sha256": "eb423b32a6ed5fd6c544fb608d1dff7c552368f6aa5b6067598db791fe37160e" + }, + { + "file": "nested-bound-b250-core/build.log", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "file": "nested-bound-b250-core/generate.json", + "bytes": 349, + "sha256": "36a6672f5df816de3263316d51e7d924f6fa06683bfc3d9ea958f44406b8db37" + }, + { + "file": "nested-bound-b250-core/generate.log", + "bytes": 251, + "sha256": "5fd962fe347b06caf5c089ae7fad37b09bc832bf6b2cc8a1db9130fbecadd77a" + }, + { + "file": "nested-bound-b250-core/probe-source.rs", + "bytes": 15562, + "sha256": "c5a5ce13c1910ecde13ff3e4ae9f551db521e2818ae28f4b5bded9da69c37102" + }, + { + "file": "nested-bound-r1-b250-core/build.json", + "bytes": 2125, + "sha256": "ae7cde0e85fdd89730a8cb8679321415b6f350778775746a866f803f57060412" + }, + { + "file": "nested-bound-r1-b250-core/build.log", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "file": "nested-bound-r1-b250-core/generate.json", + "bytes": 356, + "sha256": "b076e404b91faee4e8e504f27c8614647b80dfdd4f3a476fe19ed0c569fd4daa" + }, + { + "file": "nested-bound-r1-b250-core/generate.log", + "bytes": 138, + "sha256": "a0b3983820c29ec95d451e15ccb02f05a18518b8f8204b984c2738dd3ee2ce91" + }, + { + "file": "nested-call-fixture-20260912/diagnostics.txt", + "bytes": 20426, + "sha256": "2651c90057ba8ce46b9331a0fb05206e3d744928d40c63232775123282c52698" + }, + { + "file": "nested-call-fixture-20260912/nested-call-evaluator.arcadia", + "bytes": 50095, + "sha256": "ee8eec6459f28a11dcd25736e3147d6a0e153e22ecc8a4c8a3c61e4494ca2835" + }, + { + "file": "bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia", + "bytes": 14219, + "sha256": "7531ec264ad3f4b343997e3c0b0ac3b539163908b117e32197876decf3dee3dd" + }, + { + "file": "bound-nested-fixture-r1-20260912/diagnostics.txt", + "bytes": 592, + "sha256": "e2df3656e0fe6185465aced67f6649fc02bd6e584e7cb38b51ad226c9624da00" + }, + { + "file": "bound-nested-fixture-r1-20260912/README.md", + "bytes": 855, + "sha256": "f5b4e5090ecf28b230bb96f24c58c0566542aae1032c32bbba058aa4eaf79ac5" + }, + { + "file": "bound-nested-fixture-r1-20260912/scenario-identities.tsv", + "bytes": 891, + "sha256": "fa9cd8bd17a0d16d70e72e76a670e060e64d92ca3bd4a5bd6b92a363393108b0" + } +] diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.json b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.json new file mode 100644 index 00000000..c9d48c32 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.json @@ -0,0 +1,52 @@ +{ + "source": "42511f0f8ae46f29e11ae18c1030face654c2994", + "current_head": "b25065c442fd8decd3419a94d33125cafbf9a22e", + "scope": "Core-only standalone probe; core/configuration/lock inputs match identified full test run. Desktop changes do not become core evidence.", + "start": "2026-09-12T14:11:41.203627+00:00", + "end": "2026-09-12T14:12:20.356027+00:00", + "command": [ + "rustc", + "--edition=2024", + "-D", + "warnings", + "-C", + "linker=clang.exe", + "-L", + "dependency=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps", + "--extern", + "serde_json=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "--extern", + "oa_core=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nested-call-bound-fixture-20260912.rs", + "-o", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-bound-b250-core\\nested-bound-b250-core.exe" + ], + "exit": 0, + "files": [ + { + "path": ".local\\nested-call-bound-fixture-20260912.rs", + "bytes": 15562, + "sha256": "c5a5ce13c1910ecde13ff3e4ae9f551db521e2818ae28f4b5bded9da69c37102" + }, + { + "path": "target\\debug\\.fingerprint\\oa-desktop-e358a5ed59b1de41\\test-bin-arcadia-studio.json", + "bytes": 1079, + "sha256": "cbf2edff63ac3601b264065345b7c77e456ed8e34b09ebd204d5785d2324a2dd" + }, + { + "path": "target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "bytes": 2991440, + "sha256": "485300d4125a69de7da5413f832eb4b9cde547e60f103f3b284e49aee4194d05" + }, + { + "path": "target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "bytes": 102820446, + "sha256": "d395dbe1f761d41bce3cb850f44cdc0343b0db172bd03abf89e455c44f4b7e86" + }, + { + "path": ".local\\native-qa\\nested-bound-b250-core\\nested-bound-b250-core.exe", + "bytes": 18493952, + "sha256": "994a78c151c9240207bbaca8ce2807b2799947382fb63e4d1ff7e47375790a36" + } + ] +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.log b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/build.log new file mode 100644 index 00000000..e69de29b diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.json b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.json new file mode 100644 index 00000000..817efb91 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.json @@ -0,0 +1,9 @@ +{ + "utc": "2026-09-12T14:12:53.234934+00:00", + "command": [ + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-bound-b250-core\\nested-bound-b250-core.exe", + ".local/native-qa/bound-nested-fixture-20260912" + ], + "binary_sha256": "994a78c151c9240207bbaca8ce2807b2799947382fb63e4d1ff7e47375790a36", + "exit": 101 +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.log b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.log new file mode 100644 index 00000000..e46cd422 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/generate.log @@ -0,0 +1,4 @@ + +thread 'main' (8772) panicked at C:\Users\User\Documents\Git\ARCADIA-Studio\.local\nested-call-bound-fixture-20260912.rs:18:59: +called `Option::unwrap()` on a `None` value +note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/probe-source.rs b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/probe-source.rs new file mode 100644 index 00000000..f5529790 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-b250-core/probe-source.rs @@ -0,0 +1,520 @@ +//! Source-only native fixture generator for issue 21; root compiles/runs it. +//! Uses actual oa-core validation, operation resolution, and whole-Project source round trips. +//! Usage: nested-call-bound-fixture.exe NEW_OUTPUT_DIRECTORY +use oa_core::{operations, validation, *}; +use std::{fs, path::Path}; + +fn id(n: u128) -> Id { + Id::from_u128(0x21b00d00000040008000000000000000 + n) +} +fn element( + p: &mut Project, + layer: Layer, + n: u128, + kind: Kind, + name: &str, + parent: Option, +) -> Id { + let mut e = p.make_element(kind, layer, name, parent).unwrap(); + e.id = id(n); + e.alias = format!("bound_{n}"); + assert!(p.elements.insert(e.id, e).is_none()); + id(n) +} +fn shared(p: &mut Project, element: Id, body: SharedBody) { + *p.elements.get_mut(&element).unwrap().shared_mut().unwrap() = body; +} +fn relation(p: &mut Project, n: u128, name: &str, body: RelationBody) -> Id { + let r = Relation { + id: id(n), + alias: format!("bound_{n}"), + name: name.into(), + description: String::new(), + body, + }; + assert!(p.relations.insert(r.id, r).is_none()); + id(n) +} +fn parameter( + p: &mut Project, + layer: Layer, + n: u128, + owner: Id, + name: &str, + direction: ParameterDirection, +) -> Id { + let field = element(p, layer, n, Kind::DataField, name, Some(owner)); + shared( + p, + field, + SharedBody::DataField { + type_ref: TypeRef::Real, + minimum: 1, + maximum: Some(1), + unit: "kPa".into(), + direction, + storage: FieldStorage::Value, + default: None, + }, + ); + field +} +#[derive(Clone, Copy)] +struct Contract { + layer: Layer, + requester: Id, + responder: Id, + channel: Id, + operation: Option, + input: Id, + output: Id, +} +fn oa_contract(p: &mut Project) -> Contract { + let layer = Layer::Oa; + let requester = element( + p, + layer, + 100, + Kind::Activity, + "Review pressure demand", + None, + ); + let responder = element(p, layer, 101, Kind::Activity, "Inspect pressure", None); + let item = element(p, layer, 110, Kind::ExchangeItem, "Check pressure", None); + shared( + p, + item, + SharedBody::ExchangeItem { + kind: ExchangeItemKind::Information, + mechanism: ExchangeMechanism::Operation, + supertype: None, + }, + ); + let input = parameter( + p, + layer, + 111, + item, + "requested_pressure", + ParameterDirection::In, + ); + let output = parameter( + p, + layer, + 112, + item, + "measured_pressure", + ParameterDirection::Return, + ); + let channel = relation( + p, + 120, + "Pressure check", + RelationBody::Interaction { + source: requester, + target: responder, + items: vec![item], + }, + ); + Contract { + layer, + requester, + responder, + channel, + operation: None, + input, + output, + } +} +fn sa_contract(p: &mut Project) -> Contract { + let layer = Layer::Sa; + let requester = element(p, layer, 200, Kind::Actor, "Operator console", None); + let responder = element(p, layer, 201, Kind::System, "Pressure service", None); + let caller_port = element(p, layer, 202, Kind::Port, "Client socket", Some(requester)); + let provider_port = element(p, layer, 203, Kind::Port, "Service socket", Some(responder)); + for port in [caller_port, provider_port] { + shared( + p, + port, + SharedBody::Port { + contract: PortContract::Component { + kind: ComponentPortKind::Standard, + orientation: ComponentPortOrientation::Unset, + }, + legacy: None, + }, + ); + } + let item = element(p, layer, 210, Kind::ExchangeItem, "Check pressure", None); + shared( + p, + item, + SharedBody::ExchangeItem { + kind: ExchangeItemKind::Information, + mechanism: ExchangeMechanism::Operation, + supertype: None, + }, + ); + let input = parameter( + p, + layer, + 211, + item, + "requested_pressure", + ParameterDirection::In, + ); + let output = parameter( + p, + layer, + 212, + item, + "measured_pressure", + ParameterDirection::Return, + ); + let interface = element(p, layer, 213, Kind::Interface, "Pressure check API", None); + shared(p, interface, SharedBody::Interface { supertype: None }); + let allocation = relation( + p, + 220, + "Synchronous pressure check", + RelationBody::InterfaceItemAllocation { + source: interface, + target: item, + order: 0, + transmission: TransmissionProtocol::Synchronous, + acquisition: AcquisitionProtocol::Unspecified, + }, + ); + relation( + p, + 221, + "Console requires check", + RelationBody::InterfaceRequirement { + source: caller_port, + target: interface, + }, + ); + relation( + p, + 222, + "Service provides check", + RelationBody::InterfaceProvision { + source: provider_port, + target: interface, + }, + ); + let channel = relation( + p, + 223, + "Pressure channel", + RelationBody::BoundaryExchange { + source: caller_port, + target: provider_port, + oriented: false, + items: vec![item], + }, + ); + Contract { + layer, + requester, + responder, + channel, + operation: Some(allocation), + input, + output, + } +} +struct Case { + owner: Id, + caller: Id, + callee: Id, + call: Id, + inner: Id, + inner_reply: Id, + reply: Id, +} +fn message( + p: &mut Project, + contract: Contract, + n: u128, + owner: Id, + name: &str, + endpoints: (Id, Id), + reply_and_value: (Option, &str), +) -> Id { + let (reply, expression) = reply_and_value; + let message = element(p, contract.layer, n, Kind::Occurrence, name, Some(owner)); + shared( + p, + message, + SharedBody::Occurrence { + body: OccurrenceBody::Exchange { + operation: if reply.is_none() { + contract.operation.map(|allocation| OperationUse { + allocation: Some(allocation), + }) + } else { + None + }, + exchange: Some(contract.channel), + sender: Some(endpoints.0), + receiver: Some(endpoints.1), + message_kind: if reply.is_some() { + MessageKind::Reply + } else { + MessageKind::Call + }, + reply_to: reply, + values: vec![MessageValue { + field: if reply.is_some() { + contract.output + } else { + contract.input + }, + path: vec![], + expression: expression.into(), + }], + }, + precondition: String::new(), + postcondition: String::new(), + }, + ); + message +} +fn scenario( + p: &mut Project, + contract: Contract, + base: u128, + name: &str, + callback: Option, +) -> Case { + let owner = element(p, contract.layer, base, Kind::Scenario, name, None); + shared( + p, + owner, + SharedBody::Scenario { + viewpoint: if contract.layer == Layer::Oa { + ScenarioViewpoint::OperationalActivity + } else { + ScenarioViewpoint::BoundaryInterface + }, + context: None, + precondition: "Two pressure checks are reviewed before the outer reply".into(), + postcondition: "Each reply retains its own requested and measured values".into(), + steps: vec![], + }, + ); + let caller = element( + p, + contract.layer, + base + 1, + Kind::Lifeline, + "L1 Console", + Some(owner), + ); + let callee = element( + p, + contract.layer, + base + 2, + Kind::Lifeline, + "L2 Inspector", + Some(owner), + ); + shared( + p, + caller, + SharedBody::Lifeline { + represented: Some(contract.requester), + }, + ); + shared( + p, + callee, + SharedBody::Lifeline { + represented: Some(contract.responder), + }, + ); + // Reverse UUID order deliberately: chronological order comes from steps. + let call = message( + p, + contract, + base + 40, + owner, + "C1 420 kPa", + (caller, callee), + (None, "420.0"), + ); + let inner_contract = Contract { + channel: callback.unwrap_or(contract.channel), + ..contract + }; + let inner_endpoints = if callback.is_some() { + (callee, caller) + } else { + (caller, callee) + }; + let inner = message( + p, + inner_contract, + base + 30, + owner, + "C2 380 kPa", + inner_endpoints, + (None, "380.0"), + ); + let inner_reply = message( + p, + inner_contract, + base + 60, + owner, + "R2 378 kPa", + (inner_endpoints.1, inner_endpoints.0), + (Some(inner), "378.0"), + ); + let reply = message( + p, + contract, + base + 50, + owner, + "R1 418 kPa", + (callee, caller), + (Some(call), "418.0"), + ); + *p.elements.get_mut(&owner).unwrap().steps_mut().unwrap() = + vec![call, inner, inner_reply, reply]; + Case { + owner, + caller, + callee, + call, + inner, + inner_reply, + reply, + } +} +fn assert_case(p: &Project, case: &Case, contract: Contract) { + assert_eq!( + p.elements[&case.owner].steps().unwrap(), + &vec![case.call, case.inner, case.inner_reply, case.reply] + ); + for (message, invocation, expression) in [ + (case.call, case.call, "420.0"), + (case.inner, case.inner, "380.0"), + (case.inner_reply, case.inner, "378.0"), + (case.reply, case.call, "418.0"), + ] { + let Some(SharedBody::Occurrence { + body: + OccurrenceBody::Exchange { + values, + exchange, + sender, + receiver, + .. + }, + .. + }) = p.elements[&message].shared() + else { + panic!("Missing message"); + }; + assert!(exchange.is_some() && sender.is_some() && receiver.is_some()); + assert_eq!(values.len(), 1); + assert_eq!(values[0].expression, expression); + if let Some(allocation) = contract.operation { + let operations::OperationResolution::Selected(proof) = + operations::resolve(p, message).unwrap() + else { + panic!("Operation is not actually resolved"); + }; + assert_eq!(proof.invocation, invocation); + assert_eq!(proof.allocation, allocation); + assert_eq!(proof.caller_port, id(202)); + assert_eq!(proof.provider_port, id(203)); + } else { + assert_eq!( + operations::resolve(p, message).unwrap(), + operations::OperationResolution::Ordinary + ); + } + } +} +fn main() { + let args: Vec<_> = std::env::args().collect(); + assert_eq!(args.len(), 2, "Pass a NEW output directory"); + let directory = Path::new(&args[1]); + assert!( + !directory.exists(), + "Refuse to replace existing native evidence" + ); + let mut p = Project::empty(); + p.id = id(1); + p.alias = "bound_nested_calls".into(); + p.name = "Bound nested pressure checks".into(); + p.description = "Native activation acceptance. Requested 420/380 kPa, measured 418/378 kPa. Unicode readback: Δ pressure · 戻り値.".into(); + let oa = oa_contract(&mut p); + let sa = sa_contract(&mut p); + let oa_case = scenario(&mut p, oa, 1000, "OA Nested pressure checks", None); + let sa_case = scenario(&mut p, sa, 2000, "SA Nested pressure checks", None); + let callback = relation( + &mut p, + 121, + "Demand review callback", + RelationBody::Interaction { + source: oa.responder, + target: oa.requester, + items: vec![id(110)], + }, + ); + let reentrant = scenario( + &mut p, + oa, + 3000, + "OA Reentrant pressure review", + Some(callback), + ); + let issues = validation::validate(&p); + let errors: Vec<_> = issues + .iter() + .filter(|i| i.severity == validation::Severity::Error) + .collect(); + assert!( + errors.is_empty(), + "Actual core rejects fixture: {errors:#?}" + ); + for (case, contract) in [(&oa_case, oa), (&sa_case, sa), (&reentrant, oa)] { + assert_case(&p, case, contract); + } + let canonical = language::format(&p); + let reparsed = + language::parse(&canonical).expect("Canonical source must parse through actual core"); + assert_eq!( + reparsed, p, + "Whole-Project equality, not only ordered steps" + ); + assert_eq!(language::format(&reparsed), canonical); + let mut manifest = String::from("scenario\towner\tL1\tL2\tC1\tC2\tR2\tR1\n"); + for case in [&oa_case, &sa_case, &reentrant] { + manifest.push_str(&format!( + "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n", + p.named(case.owner), + case.owner, + case.caller, + case.callee, + case.call, + case.inner, + case.inner_reply, + case.reply + )); + } + fs::create_dir(directory).unwrap(); + fs::write(directory.join("bound-nested-calls.arcadia"), canonical).unwrap(); + fs::write(directory.join("scenario-identities.tsv"), manifest).unwrap(); + fs::write(directory.join("diagnostics.txt"), format!("{issues:#?}\n")).unwrap(); + fs::write(directory.join("README.md"), "Open bound-nested-calls.arcadia. In Behavior select OA Nested pressure checks, SA Nested pressure checks, or OA Reentrant pressure review. Each has two lifelines and four rows ordered C1,C2,R2,R1. C1 requests 420.0 kPa and R1 returns 418.0; C2 requests 380.0 and R2 returns 378.0. The SA messages resolve an actual synchronous interface-operation allocation; Replies derive it from their exact Calls. OA uses a bound Interaction carrying an Operation item without SA-only OperationUse. The reentrant case uses an explicit reverse Interaction for C2/R2. Check unselected bars, both reply ends, each bar's selection, Properties values/correlation, source parity and save/reopen. scenario-identities.tsv lists every UI target UUID. diagnostics.txt records completeness warnings. Generator validation and roundtrip are not desktop paint or native acceptance.\n").unwrap(); + println!( + "PASS: {} elements, {} relations, three bound scenarios, zero Errors, {} warnings; whole-Project roundtrip and exact SA operation resolution", + p.elements.len(), + p.relations.len(), + issues.len() + ); +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.json b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.json new file mode 100644 index 00000000..39c1d39e --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.json @@ -0,0 +1,52 @@ +{ + "source": "42511f0f8ae46f29e11ae18c1030face654c2994", + "current_head": "b25065c442fd8decd3419a94d33125cafbf9a22e", + "scope": "Core-only standalone probe; core/configuration/lock inputs match identified full test run. Desktop changes do not become core evidence.", + "start": "2026-09-12T14:18:22.188944+00:00", + "end": "2026-09-12T14:18:51.165208+00:00", + "command": [ + "rustc", + "--edition=2024", + "-D", + "warnings", + "-C", + "linker=clang.exe", + "-L", + "dependency=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps", + "--extern", + "serde_json=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "--extern", + "oa_core=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nested-call-bound-fixture-20260912.rs", + "-o", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-bound-r1-b250-core\\nested-bound-r1-b250-core.exe" + ], + "exit": 0, + "files": [ + { + "path": ".local\\nested-call-bound-fixture-20260912.rs", + "bytes": 15775, + "sha256": "d74a482d6433a8e0d8e82ae67eaca1b28df92920466bbb247ffac0bd1cd80928" + }, + { + "path": "target\\debug\\.fingerprint\\oa-desktop-e358a5ed59b1de41\\test-bin-arcadia-studio.json", + "bytes": 1079, + "sha256": "cbf2edff63ac3601b264065345b7c77e456ed8e34b09ebd204d5785d2324a2dd" + }, + { + "path": "target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "bytes": 2991440, + "sha256": "485300d4125a69de7da5413f832eb4b9cde547e60f103f3b284e49aee4194d05" + }, + { + "path": "target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "bytes": 102820446, + "sha256": "d395dbe1f761d41bce3cb850f44cdc0343b0db172bd03abf89e455c44f4b7e86" + }, + { + "path": ".local\\native-qa\\nested-bound-r1-b250-core\\nested-bound-r1-b250-core.exe", + "bytes": 18501120, + "sha256": "6d004f8a86bc3e73ef961c4fad2209bf7979823761c40f43d376879a024b77a6" + } + ] +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.log b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/build.log new file mode 100644 index 00000000..e69de29b diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.json b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.json new file mode 100644 index 00000000..25200e7a --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.json @@ -0,0 +1,9 @@ +{ + "utc": "2026-09-12T14:19:47.716690+00:00", + "command": [ + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-bound-r1-b250-core\\nested-bound-r1-b250-core.exe", + ".local/native-qa/bound-nested-fixture-r1-20260912" + ], + "binary_sha256": "6d004f8a86bc3e73ef961c4fad2209bf7979823761c40f43d376879a024b77a6", + "exit": 0 +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.log b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.log new file mode 100644 index 00000000..0306df16 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-bound-r1-b250-core/generate.log @@ -0,0 +1 @@ +PASS: 34 elements, 6 relations, three bound scenarios, zero Errors, 2 warnings; whole-Project roundtrip and exact SA operation resolution diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.json b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.json new file mode 100644 index 00000000..0c4602f9 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.json @@ -0,0 +1,52 @@ +{ + "source": "42511f0f8ae46f29e11ae18c1030face654c2994", + "current_head": "f7d84faf30cdb5e3695c2dc16ee0a5f2eac91e71", + "scope": "Core-only standalone probe; core/configuration/lock inputs match identified full test run. Desktop changes do not become core evidence.", + "start": "2026-09-12T13:27:52.562653+00:00", + "end": "2026-09-12T13:28:02.627505+00:00", + "command": [ + "rustc", + "--edition=2024", + "-D", + "warnings", + "-C", + "linker=clang.exe", + "-L", + "dependency=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps", + "--extern", + "serde_json=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "--extern", + "oa_core=C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\nested-call-fixtures-20260912.rs", + "-o", + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-call-f7-core\\nested-call-f7-core.exe" + ], + "exit": 0, + "files": [ + { + "path": ".local\\nested-call-fixtures-20260912.rs", + "bytes": 6789, + "sha256": "e296ad928a4e01321d20cbcfb046a64a733561cf6f7a07d8d52eaeb64d4e4ee2" + }, + { + "path": "target\\debug\\.fingerprint\\oa-desktop-e358a5ed59b1de41\\test-bin-arcadia-studio.json", + "bytes": 1079, + "sha256": "cbf2edff63ac3601b264065345b7c77e456ed8e34b09ebd204d5785d2324a2dd" + }, + { + "path": "target\\debug\\deps\\libserde_json-da2c4f333fc47818.rlib", + "bytes": 2991440, + "sha256": "485300d4125a69de7da5413f832eb4b9cde547e60f103f3b284e49aee4194d05" + }, + { + "path": "target\\debug\\deps\\liboa_core-145180297aa692e4.rlib", + "bytes": 102820446, + "sha256": "d395dbe1f761d41bce3cb850f44cdc0343b0db172bd03abf89e455c44f4b7e86" + }, + { + "path": ".local\\native-qa\\nested-call-f7-core\\nested-call-f7-core.exe", + "bytes": 18152448, + "sha256": "1beea08d2b9b0892d0ecd9892b77466f57e290163b5684d4e3f4c883b53d9b26" + } + ] +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.log b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/build.log new file mode 100644 index 00000000..e69de29b diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.json b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.json new file mode 100644 index 00000000..62b5d0d9 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.json @@ -0,0 +1,9 @@ +{ + "utc": "2026-09-12T13:28:32.861887+00:00", + "command": [ + "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\native-qa\\nested-call-f7-core\\nested-call-f7-core.exe", + ".local/native-qa/nested-call-fixture-20260912" + ], + "binary_sha256": "1beea08d2b9b0892d0ecd9892b77466f57e290163b5684d4e3f4c883b53d9b26", + "exit": 0 +} diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.log b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.log new file mode 100644 index 00000000..3ca211f7 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-call-f7-core/fixtures.log @@ -0,0 +1 @@ +PASS actual core validation and canonical round trip: 132 elements, 77 warnings; no desktop draw/hit/runtime claim diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/diagnostics.txt b/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/diagnostics.txt new file mode 100644 index 00000000..c5b2680a --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/diagnostics.txt @@ -0,0 +1,841 @@ +[ + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000000001, + ), + code: "missing_system", + field: Some( + "elements", + ), + message: "Identify the SA system of interest.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002710, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Caller work' to a performer.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002711, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Callee work' to a performer.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002792, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000279c, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000027a6, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000027b0, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000027f6, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002800, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000280a, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002814, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000285a, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002864, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000286e, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002878, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000028be, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000028c8, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000028d2, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000028dc, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002922, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000292c, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002936, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002940, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002986, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002990, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029a4, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029e0, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029e1, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029e3, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029e4, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000029f4, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a12, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a44, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a45, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a47, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a48, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002a58, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004e20, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Caller work' to a performer.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004e21, + ), + code: "unallocated_leaf", + field: Some( + "allocation", + ), + message: "Allocate leaf 'Callee work' to a performer.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004ea2, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004eac, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004eb6, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004ec0, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f06, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f10, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f1a, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f24, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f6a, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f74, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f7e, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004f88, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004fce, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004fd8, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004fe2, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004fec, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005032, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-00000000503c, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005046, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005050, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005096, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050a0, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050b4, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050f0, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050f1, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050f3, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-0000000050f4, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005104, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005122, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005154, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005155, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005157, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005158, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000005168, + ), + code: "missing_exchange", + field: Some( + "exchange", + ), + message: "Choose an exchange.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002710, + ), + code: "work_without_behavior_context", + field: None, + message: "Include this leaf activity/function in a process/chain or scenario through a work action or exchange occurrence.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000002711, + ), + code: "work_without_behavior_context", + field: None, + message: "Include this leaf activity/function in a process/chain or scenario through a work action or exchange occurrence.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004e20, + ), + code: "work_without_behavior_context", + field: None, + message: "Include this leaf activity/function in a process/chain or scenario through a work action or exchange occurrence.", + }, + Issue { + severity: Warning, + element: Some( + 21ca1100-0000-4000-8000-000000004e21, + ), + code: "work_without_behavior_context", + field: None, + message: "Include this leaf activity/function in a process/chain or scenario through a work action or exchange occurrence.", + }, +] diff --git a/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/nested-call-evaluator.arcadia b/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/nested-call-evaluator.arcadia new file mode 100644 index 00000000..0ad1acb1 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/nested-call-fixture-20260912/nested-call-evaluator.arcadia @@ -0,0 +1,1689 @@ +arcadia 7; +project nested_call_evaluator "Nested call activation evaluator" id "21ca1100-0000-4000-8000-000000000001" { + description "Draft exchange references intentionally absent; exact lifelines and correlations isolate receiver activation geometry."; + + oa_activity activation_10000 "Caller work" id "21ca1100-0000-4000-8000-000000002710" { + description ""; + parent none; + } + + oa_activity activation_10001 "Callee work" id "21ca1100-0000-4000-8000-000000002711" { + description ""; + parent none; + } + + oa_scenario activation_10100 "Oa nested" id "21ca1100-0000-4000-8000-000000002774" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10140, @activation_10130, @activation_10160, @activation_10150]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10101 "L1 Caller" id "21ca1100-0000-4000-8000-000000002775" { + description ""; + parent @activation_10100; + represented @activation_10000; + } + + oa_lifeline activation_10102 "L2 Callee" id "21ca1100-0000-4000-8000-000000002776" { + description ""; + parent @activation_10100; + represented @activation_10001; + } + + oa_occurrence activation_10130 "Call 2" id "21ca1100-0000-4000-8000-000000002792" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10102; + reply_to none; + sender @activation_10101; + values []; + }; + }; + description ""; + parent @activation_10100; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10140 "Call 1" id "21ca1100-0000-4000-8000-00000000279c" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10102; + reply_to none; + sender @activation_10101; + values []; + }; + }; + description ""; + parent @activation_10100; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10150 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-0000000027a6" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10101; + reply_to @activation_10140; + sender @activation_10102; + values []; + }; + }; + description ""; + parent @activation_10100; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10160 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-0000000027b0" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10101; + reply_to @activation_10130; + sender @activation_10102; + values []; + }; + }; + description ""; + parent @activation_10100; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10200 "Oa sequential" id "21ca1100-0000-4000-8000-0000000027d8" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10240, @activation_10250, @activation_10230, @activation_10260]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10201 "L1 Caller" id "21ca1100-0000-4000-8000-0000000027d9" { + description ""; + parent @activation_10200; + represented @activation_10000; + } + + oa_lifeline activation_10202 "L2 Callee" id "21ca1100-0000-4000-8000-0000000027da" { + description ""; + parent @activation_10200; + represented @activation_10001; + } + + oa_occurrence activation_10230 "Call 2" id "21ca1100-0000-4000-8000-0000000027f6" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10202; + reply_to none; + sender @activation_10201; + values []; + }; + }; + description ""; + parent @activation_10200; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10240 "Call 1" id "21ca1100-0000-4000-8000-000000002800" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10202; + reply_to none; + sender @activation_10201; + values []; + }; + }; + description ""; + parent @activation_10200; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10250 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-00000000280a" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10201; + reply_to @activation_10240; + sender @activation_10202; + values []; + }; + }; + description ""; + parent @activation_10200; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10260 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000002814" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10201; + reply_to @activation_10230; + sender @activation_10202; + values []; + }; + }; + description ""; + parent @activation_10200; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10300 "Oa crossed" id "21ca1100-0000-4000-8000-00000000283c" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10340, @activation_10330, @activation_10350, @activation_10360]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10301 "L1 Caller" id "21ca1100-0000-4000-8000-00000000283d" { + description ""; + parent @activation_10300; + represented @activation_10000; + } + + oa_lifeline activation_10302 "L2 Callee" id "21ca1100-0000-4000-8000-00000000283e" { + description ""; + parent @activation_10300; + represented @activation_10001; + } + + oa_occurrence activation_10330 "Call 2" id "21ca1100-0000-4000-8000-00000000285a" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10302; + reply_to none; + sender @activation_10301; + values []; + }; + }; + description ""; + parent @activation_10300; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10340 "Call 1" id "21ca1100-0000-4000-8000-000000002864" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10302; + reply_to none; + sender @activation_10301; + values []; + }; + }; + description ""; + parent @activation_10300; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10350 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-00000000286e" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10301; + reply_to @activation_10340; + sender @activation_10302; + values []; + }; + }; + description ""; + parent @activation_10300; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10360 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000002878" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10301; + reply_to @activation_10330; + sender @activation_10302; + values []; + }; + }; + description ""; + parent @activation_10300; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10400 "Oa self" id "21ca1100-0000-4000-8000-0000000028a0" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10440, @activation_10430, @activation_10460, @activation_10450]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10401 "L1 Caller" id "21ca1100-0000-4000-8000-0000000028a1" { + description ""; + parent @activation_10400; + represented @activation_10000; + } + + oa_lifeline activation_10402 "L2 Callee" id "21ca1100-0000-4000-8000-0000000028a2" { + description ""; + parent @activation_10400; + represented @activation_10001; + } + + oa_occurrence activation_10430 "Call 2" id "21ca1100-0000-4000-8000-0000000028be" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10402; + reply_to none; + sender @activation_10402; + values []; + }; + }; + description ""; + parent @activation_10400; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10440 "Call 1" id "21ca1100-0000-4000-8000-0000000028c8" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10402; + reply_to none; + sender @activation_10401; + values []; + }; + }; + description ""; + parent @activation_10400; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10450 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-0000000028d2" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10401; + reply_to @activation_10440; + sender @activation_10402; + values []; + }; + }; + description ""; + parent @activation_10400; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10460 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-0000000028dc" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10402; + reply_to @activation_10430; + sender @activation_10402; + values []; + }; + }; + description ""; + parent @activation_10400; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10500 "Oa reentrant" id "21ca1100-0000-4000-8000-000000002904" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10540, @activation_10530, @activation_10560, @activation_10550]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10501 "L1 Caller" id "21ca1100-0000-4000-8000-000000002905" { + description ""; + parent @activation_10500; + represented @activation_10000; + } + + oa_lifeline activation_10502 "L2 Callee" id "21ca1100-0000-4000-8000-000000002906" { + description ""; + parent @activation_10500; + represented @activation_10001; + } + + oa_occurrence activation_10530 "Call 2" id "21ca1100-0000-4000-8000-000000002922" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10501; + reply_to none; + sender @activation_10502; + values []; + }; + }; + description ""; + parent @activation_10500; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10540 "Call 1" id "21ca1100-0000-4000-8000-00000000292c" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10502; + reply_to none; + sender @activation_10501; + values []; + }; + }; + description ""; + parent @activation_10500; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10550 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000002936" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10501; + reply_to @activation_10540; + sender @activation_10502; + values []; + }; + }; + description ""; + parent @activation_10500; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10560 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000002940" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10502; + reply_to @activation_10530; + sender @activation_10501; + values []; + }; + }; + description ""; + parent @activation_10500; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10600 "Oa open" id "21ca1100-0000-4000-8000-000000002968" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10640, @activation_10630, @activation_10660]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10601 "L1 Caller" id "21ca1100-0000-4000-8000-000000002969" { + description ""; + parent @activation_10600; + represented @activation_10000; + } + + oa_lifeline activation_10602 "L2 Callee" id "21ca1100-0000-4000-8000-00000000296a" { + description ""; + parent @activation_10600; + represented @activation_10001; + } + + oa_occurrence activation_10630 "Call 2" id "21ca1100-0000-4000-8000-000000002986" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10602; + reply_to none; + sender @activation_10601; + values []; + }; + }; + description ""; + parent @activation_10600; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10640 "Call 1" id "21ca1100-0000-4000-8000-000000002990" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10602; + reply_to none; + sender @activation_10601; + values []; + }; + }; + description ""; + parent @activation_10600; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10660 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-0000000029a4" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10601; + reply_to @activation_10630; + sender @activation_10602; + values []; + }; + }; + description ""; + parent @activation_10600; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10700 "Oa alt" id "21ca1100-0000-4000-8000-0000000029cc" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10740, @activation_10710]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10701 "L1 Caller" id "21ca1100-0000-4000-8000-0000000029cd" { + description ""; + parent @activation_10700; + represented @activation_10000; + } + + oa_lifeline activation_10702 "L2 Callee" id "21ca1100-0000-4000-8000-0000000029ce" { + description ""; + parent @activation_10700; + represented @activation_10001; + } + + oa_occurrence activation_10710 "alt" id "21ca1100-0000-4000-8000-0000000029d6" { + body { + Fragment { + branches [@activation_10711, @activation_10712]; + operator Alternative; + }; + }; + description ""; + parent @activation_10700; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10711 "Operand 0" id "21ca1100-0000-4000-8000-0000000029d7" { + body { + Branch { + guard "condition_0"; + occurrences [@activation_10720, @activation_10721, @activation_10770]; + }; + }; + description ""; + parent @activation_10710; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10712 "Operand 1" id "21ca1100-0000-4000-8000-0000000029d8" { + body { + Branch { + guard "condition_1"; + occurrences [@activation_10723, @activation_10724]; + }; + }; + description ""; + parent @activation_10710; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10720 "Branch Call" id "21ca1100-0000-4000-8000-0000000029e0" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10702; + reply_to none; + sender @activation_10701; + values []; + }; + }; + description ""; + parent @activation_10711; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10721 "Branch Reply" id "21ca1100-0000-4000-8000-0000000029e1" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10701; + reply_to @activation_10720; + sender @activation_10702; + values []; + }; + }; + description ""; + parent @activation_10711; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10723 "Branch Call" id "21ca1100-0000-4000-8000-0000000029e3" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10702; + reply_to none; + sender @activation_10701; + values []; + }; + }; + description ""; + parent @activation_10712; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10724 "Branch Reply" id "21ca1100-0000-4000-8000-0000000029e4" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10701; + reply_to @activation_10723; + sender @activation_10702; + values []; + }; + }; + description ""; + parent @activation_10712; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10740 "Call 1" id "21ca1100-0000-4000-8000-0000000029f4" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10702; + reply_to none; + sender @activation_10701; + values []; + }; + }; + description ""; + parent @activation_10700; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10770 "Conditional outer Reply" id "21ca1100-0000-4000-8000-000000002a12" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10701; + reply_to @activation_10740; + sender @activation_10702; + values []; + }; + }; + description ""; + parent @activation_10711; + postcondition ""; + precondition ""; + } + + oa_scenario activation_10800 "Oa parallel" id "21ca1100-0000-4000-8000-000000002a30" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_10840, @activation_10810]; + viewpoint OperationalActivity; + } + + oa_lifeline activation_10801 "L1 Caller" id "21ca1100-0000-4000-8000-000000002a31" { + description ""; + parent @activation_10800; + represented @activation_10000; + } + + oa_lifeline activation_10802 "L2 Callee" id "21ca1100-0000-4000-8000-000000002a32" { + description ""; + parent @activation_10800; + represented @activation_10001; + } + + oa_occurrence activation_10810 "parallel" id "21ca1100-0000-4000-8000-000000002a3a" { + body { + Fragment { + branches [@activation_10811, @activation_10812]; + operator Parallel; + }; + }; + description ""; + parent @activation_10800; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10811 "Operand 0" id "21ca1100-0000-4000-8000-000000002a3b" { + body { + Branch { + guard "condition_0"; + occurrences [@activation_10820, @activation_10821]; + }; + }; + description ""; + parent @activation_10810; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10812 "Operand 1" id "21ca1100-0000-4000-8000-000000002a3c" { + body { + Branch { + guard "condition_1"; + occurrences [@activation_10823, @activation_10824]; + }; + }; + description ""; + parent @activation_10810; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10820 "Branch Call" id "21ca1100-0000-4000-8000-000000002a44" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10802; + reply_to none; + sender @activation_10801; + values []; + }; + }; + description ""; + parent @activation_10811; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10821 "Branch Reply" id "21ca1100-0000-4000-8000-000000002a45" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10801; + reply_to @activation_10820; + sender @activation_10802; + values []; + }; + }; + description ""; + parent @activation_10811; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10823 "Branch Call" id "21ca1100-0000-4000-8000-000000002a47" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10802; + reply_to none; + sender @activation_10801; + values []; + }; + }; + description ""; + parent @activation_10812; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10824 "Branch Reply" id "21ca1100-0000-4000-8000-000000002a48" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_10801; + reply_to @activation_10823; + sender @activation_10802; + values []; + }; + }; + description ""; + parent @activation_10812; + postcondition ""; + precondition ""; + } + + oa_occurrence activation_10840 "Call 1" id "21ca1100-0000-4000-8000-000000002a58" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_10802; + reply_to none; + sender @activation_10801; + values []; + }; + }; + description ""; + parent @activation_10800; + postcondition ""; + precondition ""; + } + + sa_function activation_20000 "Caller work" id "21ca1100-0000-4000-8000-000000004e20" { + description ""; + parent none; + } + + sa_function activation_20001 "Callee work" id "21ca1100-0000-4000-8000-000000004e21" { + description ""; + parent none; + } + + sa_scenario activation_20100 "Sa nested" id "21ca1100-0000-4000-8000-000000004e84" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20140, @activation_20130, @activation_20160, @activation_20150]; + viewpoint Functional; + } + + sa_lifeline activation_20101 "L1 Caller" id "21ca1100-0000-4000-8000-000000004e85" { + description ""; + parent @activation_20100; + represented @activation_20000; + } + + sa_lifeline activation_20102 "L2 Callee" id "21ca1100-0000-4000-8000-000000004e86" { + description ""; + parent @activation_20100; + represented @activation_20001; + } + + sa_occurrence activation_20130 "Call 2" id "21ca1100-0000-4000-8000-000000004ea2" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20102; + reply_to none; + sender @activation_20101; + values []; + }; + }; + description ""; + parent @activation_20100; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20140 "Call 1" id "21ca1100-0000-4000-8000-000000004eac" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20102; + reply_to none; + sender @activation_20101; + values []; + }; + }; + description ""; + parent @activation_20100; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20150 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000004eb6" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20101; + reply_to @activation_20140; + sender @activation_20102; + values []; + }; + }; + description ""; + parent @activation_20100; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20160 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000004ec0" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20101; + reply_to @activation_20130; + sender @activation_20102; + values []; + }; + }; + description ""; + parent @activation_20100; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20200 "Sa sequential" id "21ca1100-0000-4000-8000-000000004ee8" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20240, @activation_20250, @activation_20230, @activation_20260]; + viewpoint Functional; + } + + sa_lifeline activation_20201 "L1 Caller" id "21ca1100-0000-4000-8000-000000004ee9" { + description ""; + parent @activation_20200; + represented @activation_20000; + } + + sa_lifeline activation_20202 "L2 Callee" id "21ca1100-0000-4000-8000-000000004eea" { + description ""; + parent @activation_20200; + represented @activation_20001; + } + + sa_occurrence activation_20230 "Call 2" id "21ca1100-0000-4000-8000-000000004f06" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20202; + reply_to none; + sender @activation_20201; + values []; + }; + }; + description ""; + parent @activation_20200; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20240 "Call 1" id "21ca1100-0000-4000-8000-000000004f10" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20202; + reply_to none; + sender @activation_20201; + values []; + }; + }; + description ""; + parent @activation_20200; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20250 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000004f1a" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20201; + reply_to @activation_20240; + sender @activation_20202; + values []; + }; + }; + description ""; + parent @activation_20200; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20260 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000004f24" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20201; + reply_to @activation_20230; + sender @activation_20202; + values []; + }; + }; + description ""; + parent @activation_20200; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20300 "Sa crossed" id "21ca1100-0000-4000-8000-000000004f4c" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20340, @activation_20330, @activation_20350, @activation_20360]; + viewpoint Functional; + } + + sa_lifeline activation_20301 "L1 Caller" id "21ca1100-0000-4000-8000-000000004f4d" { + description ""; + parent @activation_20300; + represented @activation_20000; + } + + sa_lifeline activation_20302 "L2 Callee" id "21ca1100-0000-4000-8000-000000004f4e" { + description ""; + parent @activation_20300; + represented @activation_20001; + } + + sa_occurrence activation_20330 "Call 2" id "21ca1100-0000-4000-8000-000000004f6a" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20302; + reply_to none; + sender @activation_20301; + values []; + }; + }; + description ""; + parent @activation_20300; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20340 "Call 1" id "21ca1100-0000-4000-8000-000000004f74" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20302; + reply_to none; + sender @activation_20301; + values []; + }; + }; + description ""; + parent @activation_20300; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20350 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000004f7e" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20301; + reply_to @activation_20340; + sender @activation_20302; + values []; + }; + }; + description ""; + parent @activation_20300; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20360 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000004f88" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20301; + reply_to @activation_20330; + sender @activation_20302; + values []; + }; + }; + description ""; + parent @activation_20300; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20400 "Sa self" id "21ca1100-0000-4000-8000-000000004fb0" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20440, @activation_20430, @activation_20460, @activation_20450]; + viewpoint Functional; + } + + sa_lifeline activation_20401 "L1 Caller" id "21ca1100-0000-4000-8000-000000004fb1" { + description ""; + parent @activation_20400; + represented @activation_20000; + } + + sa_lifeline activation_20402 "L2 Callee" id "21ca1100-0000-4000-8000-000000004fb2" { + description ""; + parent @activation_20400; + represented @activation_20001; + } + + sa_occurrence activation_20430 "Call 2" id "21ca1100-0000-4000-8000-000000004fce" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20402; + reply_to none; + sender @activation_20402; + values []; + }; + }; + description ""; + parent @activation_20400; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20440 "Call 1" id "21ca1100-0000-4000-8000-000000004fd8" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20402; + reply_to none; + sender @activation_20401; + values []; + }; + }; + description ""; + parent @activation_20400; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20450 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000004fe2" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20401; + reply_to @activation_20440; + sender @activation_20402; + values []; + }; + }; + description ""; + parent @activation_20400; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20460 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000004fec" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20402; + reply_to @activation_20430; + sender @activation_20402; + values []; + }; + }; + description ""; + parent @activation_20400; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20500 "Sa reentrant" id "21ca1100-0000-4000-8000-000000005014" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20540, @activation_20530, @activation_20560, @activation_20550]; + viewpoint Functional; + } + + sa_lifeline activation_20501 "L1 Caller" id "21ca1100-0000-4000-8000-000000005015" { + description ""; + parent @activation_20500; + represented @activation_20000; + } + + sa_lifeline activation_20502 "L2 Callee" id "21ca1100-0000-4000-8000-000000005016" { + description ""; + parent @activation_20500; + represented @activation_20001; + } + + sa_occurrence activation_20530 "Call 2" id "21ca1100-0000-4000-8000-000000005032" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20501; + reply_to none; + sender @activation_20502; + values []; + }; + }; + description ""; + parent @activation_20500; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20540 "Call 1" id "21ca1100-0000-4000-8000-00000000503c" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20502; + reply_to none; + sender @activation_20501; + values []; + }; + }; + description ""; + parent @activation_20500; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20550 "Reply 1 to Call 1" id "21ca1100-0000-4000-8000-000000005046" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20501; + reply_to @activation_20540; + sender @activation_20502; + values []; + }; + }; + description ""; + parent @activation_20500; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20560 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-000000005050" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20502; + reply_to @activation_20530; + sender @activation_20501; + values []; + }; + }; + description ""; + parent @activation_20500; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20600 "Sa open" id "21ca1100-0000-4000-8000-000000005078" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20640, @activation_20630, @activation_20660]; + viewpoint Functional; + } + + sa_lifeline activation_20601 "L1 Caller" id "21ca1100-0000-4000-8000-000000005079" { + description ""; + parent @activation_20600; + represented @activation_20000; + } + + sa_lifeline activation_20602 "L2 Callee" id "21ca1100-0000-4000-8000-00000000507a" { + description ""; + parent @activation_20600; + represented @activation_20001; + } + + sa_occurrence activation_20630 "Call 2" id "21ca1100-0000-4000-8000-000000005096" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20602; + reply_to none; + sender @activation_20601; + values []; + }; + }; + description ""; + parent @activation_20600; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20640 "Call 1" id "21ca1100-0000-4000-8000-0000000050a0" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20602; + reply_to none; + sender @activation_20601; + values []; + }; + }; + description ""; + parent @activation_20600; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20660 "Reply 2 to Call 2" id "21ca1100-0000-4000-8000-0000000050b4" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20601; + reply_to @activation_20630; + sender @activation_20602; + values []; + }; + }; + description ""; + parent @activation_20600; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20700 "Sa alt" id "21ca1100-0000-4000-8000-0000000050dc" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20740, @activation_20710]; + viewpoint Functional; + } + + sa_lifeline activation_20701 "L1 Caller" id "21ca1100-0000-4000-8000-0000000050dd" { + description ""; + parent @activation_20700; + represented @activation_20000; + } + + sa_lifeline activation_20702 "L2 Callee" id "21ca1100-0000-4000-8000-0000000050de" { + description ""; + parent @activation_20700; + represented @activation_20001; + } + + sa_occurrence activation_20710 "alt" id "21ca1100-0000-4000-8000-0000000050e6" { + body { + Fragment { + branches [@activation_20711, @activation_20712]; + operator Alternative; + }; + }; + description ""; + parent @activation_20700; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20711 "Operand 0" id "21ca1100-0000-4000-8000-0000000050e7" { + body { + Branch { + guard "condition_0"; + occurrences [@activation_20720, @activation_20721, @activation_20770]; + }; + }; + description ""; + parent @activation_20710; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20712 "Operand 1" id "21ca1100-0000-4000-8000-0000000050e8" { + body { + Branch { + guard "condition_1"; + occurrences [@activation_20723, @activation_20724]; + }; + }; + description ""; + parent @activation_20710; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20720 "Branch Call" id "21ca1100-0000-4000-8000-0000000050f0" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20702; + reply_to none; + sender @activation_20701; + values []; + }; + }; + description ""; + parent @activation_20711; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20721 "Branch Reply" id "21ca1100-0000-4000-8000-0000000050f1" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20701; + reply_to @activation_20720; + sender @activation_20702; + values []; + }; + }; + description ""; + parent @activation_20711; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20723 "Branch Call" id "21ca1100-0000-4000-8000-0000000050f3" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20702; + reply_to none; + sender @activation_20701; + values []; + }; + }; + description ""; + parent @activation_20712; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20724 "Branch Reply" id "21ca1100-0000-4000-8000-0000000050f4" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20701; + reply_to @activation_20723; + sender @activation_20702; + values []; + }; + }; + description ""; + parent @activation_20712; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20740 "Call 1" id "21ca1100-0000-4000-8000-000000005104" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20702; + reply_to none; + sender @activation_20701; + values []; + }; + }; + description ""; + parent @activation_20700; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20770 "Conditional outer Reply" id "21ca1100-0000-4000-8000-000000005122" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20701; + reply_to @activation_20740; + sender @activation_20702; + values []; + }; + }; + description ""; + parent @activation_20711; + postcondition ""; + precondition ""; + } + + sa_scenario activation_20800 "Sa parallel" id "21ca1100-0000-4000-8000-000000005140" { + context none; + description ""; + parent none; + postcondition ""; + precondition ""; + steps [@activation_20840, @activation_20810]; + viewpoint Functional; + } + + sa_lifeline activation_20801 "L1 Caller" id "21ca1100-0000-4000-8000-000000005141" { + description ""; + parent @activation_20800; + represented @activation_20000; + } + + sa_lifeline activation_20802 "L2 Callee" id "21ca1100-0000-4000-8000-000000005142" { + description ""; + parent @activation_20800; + represented @activation_20001; + } + + sa_occurrence activation_20810 "parallel" id "21ca1100-0000-4000-8000-00000000514a" { + body { + Fragment { + branches [@activation_20811, @activation_20812]; + operator Parallel; + }; + }; + description ""; + parent @activation_20800; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20811 "Operand 0" id "21ca1100-0000-4000-8000-00000000514b" { + body { + Branch { + guard "condition_0"; + occurrences [@activation_20820, @activation_20821]; + }; + }; + description ""; + parent @activation_20810; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20812 "Operand 1" id "21ca1100-0000-4000-8000-00000000514c" { + body { + Branch { + guard "condition_1"; + occurrences [@activation_20823, @activation_20824]; + }; + }; + description ""; + parent @activation_20810; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20820 "Branch Call" id "21ca1100-0000-4000-8000-000000005154" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20802; + reply_to none; + sender @activation_20801; + values []; + }; + }; + description ""; + parent @activation_20811; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20821 "Branch Reply" id "21ca1100-0000-4000-8000-000000005155" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20801; + reply_to @activation_20820; + sender @activation_20802; + values []; + }; + }; + description ""; + parent @activation_20811; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20823 "Branch Call" id "21ca1100-0000-4000-8000-000000005157" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20802; + reply_to none; + sender @activation_20801; + values []; + }; + }; + description ""; + parent @activation_20812; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20824 "Branch Reply" id "21ca1100-0000-4000-8000-000000005158" { + body { + Exchange { + exchange none; + message_kind Reply; + receiver @activation_20801; + reply_to @activation_20823; + sender @activation_20802; + values []; + }; + }; + description ""; + parent @activation_20812; + postcondition ""; + precondition ""; + } + + sa_occurrence activation_20840 "Call 1" id "21ca1100-0000-4000-8000-000000005168" { + body { + Exchange { + exchange none; + message_kind Call; + receiver @activation_20802; + reply_to none; + sender @activation_20801; + values []; + }; + }; + description ""; + parent @activation_20800; + postcondition ""; + precondition ""; + } + +} diff --git a/harness/experiments/canvas-editing-followup-20260912/state-focus-review.md b/harness/experiments/canvas-editing-followup-20260912/state-focus-review.md new file mode 100644 index 00000000..3ca14fb0 --- /dev/null +++ b/harness/experiments/canvas-editing-followup-20260912/state-focus-review.md @@ -0,0 +1,140 @@ +# Canvas focus continuity after accepted edits and history + +Native parent observation at immutable `f7d84fa`: allocation work canvas click, +Delete placement, Save, Undo, Save, Redo, Save, Undo, then Shift+Delete produces +no dialog. Clicking the same work restores the expected model confirmation. +Parent evidence: `.local/native-qa/delete-20260912/evidence/03-shift-delete-after-undo-no-dialog.png` +and `04modelconfirmafterclick`. + +Isolated worktree: `C:/Users/User/Documents/Git/ARCADIA-Studio/.local/delete-undo-focus-20260912`. +Branch: `codex/delete-undo-focus-956atf-20260912`, baseline `f7d84fa`. +Reviewed change commit: `7bf57db` (six production/test files; no runtime gate run +by this worker). + +## Source diagnosis and change + +`diagram::focus::Owner::diff` previously revoked keyboard focus whenever any +`route_edit::Context` field changed. The context includes document revision, +so accepting a placement removal or Undo/Redo revoked the focus that still +belonged to the displayed canvas. This is a production defect, unlike the +earlier retained-Apply evaluator ordering issue. + +Owner now preserves its existing focused and traversing values across a revision +change only. It clears pointer history for every changed full context. It still +revokes focus on document, diagram or canvas epoch change, disabled input, window +loss/resize, a pointer press outside the canvas, and actual focus operations. +It never grants focus on a revision change. The inner canvas still receives the +new full context, and model/confirmation intent validation is unchanged. + +A second necessary cause is passive Save: `save_to` sets `busy`, while the old +single enabled flag treated busy like a modal owner transfer. The shared keyboard +predicate now distinguishes logical owner availability from busy command +admission, with the previous command predicate behavior unchanged. Architecture +and state callers pass both owner availability and busy suspension to Owner. +Save/export suspension retains existing focus but denies keyboard/pointer +commands and focus acquisition. Explicit unfocus operations, outside clicks and +window loss still revoke the owner. No App save logic was changed. +Entering suspension recreates only the wrapped canvas child tree once, retiring +transient drags that could otherwise miss a release during I/O. Outer keyboard +focus and App-owned diagram presentation remain intact. + +`refresh_draft` restores the selected architecture/state placement from the +preserved semantic selection after Undo; no selection-history rewrite is needed. + +## Actual mounted regression changes + +`app/diagram_removal_tests.rs` adds: + +- OA and SA repeated placement Delete after Undo/Redo, then Shift+Delete without + another pointer event or explicit focus operation; exact bundle comparisons. +- Native allocation work click/hide/Undo/Redo/Undo/Shift+Delete sequence with the + expected work confirmation target and unchanged model/source bundle. Real + saves are included between history steps; each task is held while the actual + busy tree receives F2/Shift+Delete, then completed to a temporary source file. +- Persisted State placement hide/Undo/Shift+Delete, preserving the architecture + placement and correctly targeting the state. +- A canvas-versus-Inspector test that starts with actual pointer focus, accepts + an unrelated rename, traverses Undo/Redo/Undo, checks the real widget operation + focus witness, and verifies F2 reaches only the canvas. Repeated F2/Delete + cannot reach the diagram from either Inspector or the newly opened inline name. +- Actual Inspector click or programmatic field focus during a held Save must + revoke the retained canvas owner, including after the Save task completes. +- Passive Save cannot grant focus through either a focus operation or pointer + press, and cannot restore focus lost to a window Unfocused event while busy. +- An actual held diagram drag is released while Save is busy; later motion and + release must not commit that old gesture. A fresh drag must work and Undo must + restore the exact original source bundle. + +Existing stale revision/epoch/document/selection intent, confirmation replay, +modal/window/dirty/modified-key, clean Inspector and Tab tests remain unchanged. + +## Derived viewport assessment + +The process/scenario Viewport has analogous revision revocation, but its Scope +epoch is `camera_epoch`, mixing revisions and keyboard ownership boundaries. +Passing `canvas_epoch` as a replacement focus lifetime is unsafe: process/scenario +ordinary pan, zoom, viewport sizing and scroll changes also increment that epoch. +A separate derived focus-lifetime contract needs a bounded follow-up; this patch +does not broaden to those views or weaken their current guards. + +## Verification boundary + +`git diff --check` passes. This worker has run no Cargo/compiler or native GUI +commands and made no Gitea changes. Parent owns executable gates and native +recheck. Fresh Astra/high source review found no issue in the revision-only +change, then identified a high-priority focus-theft bug in the first busy draft: +omitting the suspended canvas from focus operations and outside clicks prevented +Inspector acquisition from revoking retained canvas focus. The current change +keeps unfocus and outside-click revocation active, denies only acquisition, and +adds both actual click and operation regressions. +The same critic then identified the swallowed-release gesture risk described +above; the child-tree retirement and actual held/fresh drag regression address +it. The final Astra/high source re-review reports no further findings and judges +the actual gesture regression meaningful. No executable pass is claimed. + +Recommended existing root Windows gate filters: + +- `app::diagram_removal_tests::` (all affected actual-root tests) +- `app::architecture_authoring::tests::` (inline F2 and ownership dependents) + +The new test is +`app::diagram_removal_tests::mounted_revision_and_history_preserve_the_actual_canvas_or_inspector_focus_owner`. +The original allocation filter remains +`app::diagram_removal_tests::mounted_allocation_work_click_then_delete_without_redraw_removes_placement_once`. + +## Persisted-state structural correction after root gate + +Root's Windows gate at integrated `24bb24839b14353c1a2b668f3bac34235d39f7a7` +reported 22 pass / 1 fail with all 531 inputs unchanged. Remaining failure: +`mounted_state_delete_uses_state_placement_and_preserves_architecture_placement` +had no delete_target after its real Save/Undo/Shift+Delete sequence. Other new +revision, passive-save, Inspector and gesture tests passed in that scoped gate. +Receipt: root `.local/allocation-union-20260912/focus-24bb248.result.json`. + +Source cause is separate from Context focus retention: state_view conditionally +pushed the unplaced-element picker immediately before the canvas Owner. The +installed `iced_widget-0.14.2/src/column.rs:207` delegates to Tree::diff_children. +Installed `iced_core-0.14.0/src/widget/tree.rs` reconciles children positionally +with zip, appending or truncating, and replaces a Tree on widget-tag mismatch. +When Hide adds the picker, the former Owner slot becomes a PickList and a new +unfocused Owner is appended. Undo truncates that Owner and replaces PickList +with yet another new Owner. StateCanvas has no private focused flag; state +viewport resizing does not change canvas_epoch. Loosening Context guards would +therefore not fix the cause. + +The corrected view has a permanent body Column with exactly two children: +an optional-controls Column, and the canvas Owner. Picker insertion/removal is +confined to the first child's subtree. The body uses zero spacing when that +slot is empty and eight pixels when present, preserving the previous visible +layout without a blank spacer. No new focus is assigned. + +The original failing test now checks the unplaced set's empty/one/empty +transition, unchanged document/diagram/epoch ownership after Hide, and actual +mounted focus immediately after Hide, Save and Undo. Redraws after Hide/Undo +exercise the real viewport transition. The final Shift+Delete target assertion +and source preservation remain unchanged. These additional checks are unrun; +root owns the next gate. Source review was requested from root because the +independent critic tool currently rejects follow-up with a thread-limit error. +Root completed source review and authorized the scoped correction, committed +as `e24054b` on the original isolated branch. Runtime verification remains with +root; no compiler/native action was performed by this worker. diff --git a/harness/experiments/diagram-removal-windows-20260912/archive-manifest.json b/harness/experiments/diagram-removal-windows-20260912/archive-manifest.json index 57d6d837..151fad50 100644 --- a/harness/experiments/diagram-removal-windows-20260912/archive-manifest.json +++ b/harness/experiments/diagram-removal-windows-20260912/archive-manifest.json @@ -183,5 +183,35 @@ "file": "gui-f7d84fa.result.json", "bytes": 351, "sha256": "3e8f2dbcc46b3ed78855c3139c9c721313acaa0c94deafc5ce91b49c66a64f0a" + }, + { + "file": "focus-24bb248.log", + "bytes": 3587, + "sha256": "7e2f754096cf9a419f6b819fe251f2509b67a4930cd46327c750578d24357996" + }, + { + "file": "focus-24bb248.inputs.json", + "bytes": 98922, + "sha256": "53c3c1cb5b0766324ad9338b8101f7317610c182916e18d1debda20b8c8af08d" + }, + { + "file": "focus-24bb248.result.json", + "bytes": 408, + "sha256": "8bd63a97a9557f2d26825362a01580a3604257268911e6b9244de98b8eb5e062" + }, + { + "file": "clippy-e2c027e.log", + "bytes": 1076, + "sha256": "e73f770457d5a2e56c8f41e637700cb77f539e6a326e0df51cc244876bc16c1e" + }, + { + "file": "clippy-e2c027e.inputs.json", + "bytes": 99306, + "sha256": "341ff6023fc288c36011515a68ad5743d31e3b8506d0d03d64a382392198ff94" + }, + { + "file": "clippy-e2c027e.result.json", + "bytes": 379, + "sha256": "296c4f96f1e1d08b4d447e03edce442a53d830101f867876fc1edd20882dccf9" } ] diff --git a/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.inputs.json b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.inputs.json new file mode 100644 index 00000000..95e220ea --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.inputs.json @@ -0,0 +1,2670 @@ +{ + "source": "e2c027e54c6be0d051820374f669c52278d90f97", + "inputs": [ + { + "path": "Cargo.lock", + "bytes": 119973, + "sha256": "065c23c94908fe499d32ed91d55a70946ed5b08ecfda3b483ec1e635572257bf" + }, + { + "path": "Cargo.toml", + "bytes": 400, + "sha256": "369f5b4b2b60705a94623c8c0b68f8e0b048f263280ce07ae0629ad353797d62" + }, + { + "path": "build/windows.manifest", + "bytes": 354, + "sha256": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb" + }, + { + "path": "build/windows.rc", + "bytes": 24, + "sha256": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e" + }, + { + "path": "build/windows_manifest.rs", + "bytes": 1460, + "sha256": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80" + }, + { + "path": "crates/oa-cli/Cargo.toml", + "bytes": 279, + "sha256": "49c567f1af74a826683b4d96845feb3806fd9bcb7dc2767e16b5509d4e5e1cde" + }, + { + "path": "crates/oa-cli/src/lib.rs", + "bytes": 15498, + "sha256": "97bebab63b4a611a1d36ad0c20fe452cbe1985fe3a6fbd39c954603da11410fc" + }, + { + "path": "crates/oa-cli/src/main.rs", + "bytes": 2984, + "sha256": "de964f9b6c59c0f31c080afbd3b31d442b07b1b44f6a187a248d3409c45d35fb" + }, + { + "path": "crates/oa-cli/tests/source_cli.rs", + "bytes": 16600, + "sha256": "a3a1b856c7a9fd3d80bc8074150a24fbb0ef0e9ddf736c7cea036725fc3dc2b8" + }, + { + "path": "crates/oa-core/Cargo.toml", + "bytes": 408, + "sha256": "6b5c062474ebb62d5082e07dabed99ee85e4a833edf26690fb4f887028d3416f" + }, + { + "path": "crates/oa-core/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-core/examples/generate_demo.rs", + "bytes": 795, + "sha256": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661" + }, + { + "path": "crates/oa-core/examples/generate_release1.rs", + "bytes": 1798, + "sha256": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5" + }, + { + "path": "crates/oa-core/examples/release_dense_views.rs", + "bytes": 14664, + "sha256": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412" + }, + { + "path": "crates/oa-core/examples/routing_workshop.rs", + "bytes": 17248, + "sha256": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7" + }, + { + "path": "crates/oa-core/src/analysis_numeric.rs", + "bytes": 3735, + "sha256": "6c88eef3119162aeb6c07b9e75812c3af9fbfe75554b0503ad00f103cb478408" + }, + { + "path": "crates/oa-core/src/analysis_numeric/dimension.rs", + "bytes": 3045, + "sha256": "d4ad8e5307a1620e31791d724a0e31fdba860d00dc83e3e1f2209d9c5e22a340" + }, + { + "path": "crates/oa-core/src/analysis_numeric/exact.rs", + "bytes": 17338, + "sha256": "4eb8cb0f66b10e5da204899af82ee26adfec74bab47b1a6c9842b5488ee04c4d" + }, + { + "path": "crates/oa-core/src/analysis_numeric/fixtures/r7-literal-boundaries.json", + "bytes": 6085, + "sha256": "3b959dec5e100a6f03817f5314bef497347ba579ebd235476516d4bd83399181" + }, + { + "path": "crates/oa-core/src/analysis_numeric/meter.rs", + "bytes": 7129, + "sha256": "1f7174beb992935b4c399acdef91114af73faf041070feab968455ac827e8ee4" + }, + { + "path": "crates/oa-core/src/analysis_numeric/quantity.rs", + "bytes": 12257, + "sha256": "ead5142d6eeea8f99399d57e02d8f7d819980923de76387cd454694d6a747aee" + }, + { + "path": "crates/oa-core/src/analysis_numeric/tests.rs", + "bytes": 27486, + "sha256": "323ce82fc057d36f44463569fd8ea324c7d700fddfbf32bce15e04bd2a66970b" + }, + { + "path": "crates/oa-core/src/data.rs", + "bytes": 42696, + "sha256": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a" + }, + { + "path": "crates/oa-core/src/demo.rs", + "bytes": 20657, + "sha256": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c" + }, + { + "path": "crates/oa-core/src/language.rs", + "bytes": 99938, + "sha256": "638f08a42e9cf4996b5d07f69b4d6f517a518369f3604d25be1006e40e080765" + }, + { + "path": "crates/oa-core/src/language/semantic_source.rs", + "bytes": 7326, + "sha256": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29" + }, + { + "path": "crates/oa-core/src/language_nesting_tests.rs", + "bytes": 20639, + "sha256": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b" + }, + { + "path": "crates/oa-core/src/lib.rs", + "bytes": 549, + "sha256": "ea1d9bf5acba8381ba204db12ff5b5fe1f320417d17af517e46b90fd6bcb241c" + }, + { + "path": "crates/oa-core/src/migration_v2/README.md", + "bytes": 1515, + "sha256": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9" + }, + { + "path": "crates/oa-core/src/migration_v2/adapter.rs", + "bytes": 9490, + "sha256": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5" + }, + { + "path": "crates/oa-core/src/migration_v2/mod.rs", + "bytes": 1158, + "sha256": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9" + }, + { + "path": "crates/oa-core/src/migration_v2/model.rs", + "bytes": 52059, + "sha256": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb" + }, + { + "path": "crates/oa-core/src/migration_v2/references.rs", + "bytes": 13369, + "sha256": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20" + }, + { + "path": "crates/oa-core/src/migration_v2/source.rs", + "bytes": 21946, + "sha256": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6" + }, + { + "path": "crates/oa-core/src/migration_v2/state_validation.rs", + "bytes": 15769, + "sha256": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0" + }, + { + "path": "crates/oa-core/src/migration_v2/transitions.rs", + "bytes": 704, + "sha256": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1" + }, + { + "path": "crates/oa-core/src/migration_v2/validation.rs", + "bytes": 98736, + "sha256": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780" + }, + { + "path": "crates/oa-core/src/migration_v3/README.md", + "bytes": 2128, + "sha256": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82" + }, + { + "path": "crates/oa-core/src/migration_v3/mod.rs", + "bytes": 23023, + "sha256": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722" + }, + { + "path": "crates/oa-core/src/migration_v4.rs", + "bytes": 4020, + "sha256": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70" + }, + { + "path": "crates/oa-core/src/model.rs", + "bytes": 66352, + "sha256": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb" + }, + { + "path": "crates/oa-core/src/operations.rs", + "bytes": 11405, + "sha256": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41" + }, + { + "path": "crates/oa-core/src/persistence.rs", + "bytes": 31774, + "sha256": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14" + }, + { + "path": "crates/oa-core/src/ports.rs", + "bytes": 45413, + "sha256": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80" + }, + { + "path": "crates/oa-core/src/projection.rs", + "bytes": 21374, + "sha256": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b" + }, + { + "path": "crates/oa-core/src/projection/port_layout.rs", + "bytes": 13474, + "sha256": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079" + }, + { + "path": "crates/oa-core/src/projection/state.rs", + "bytes": 5233, + "sha256": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28" + }, + { + "path": "crates/oa-core/src/references.rs", + "bytes": 21957, + "sha256": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb" + }, + { + "path": "crates/oa-core/src/routing.rs", + "bytes": 50309, + "sha256": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080" + }, + { + "path": "crates/oa-core/src/semantic.rs", + "bytes": 540, + "sha256": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239" + }, + { + "path": "crates/oa-core/src/semantic/catalog.rs", + "bytes": 49407, + "sha256": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4" + }, + { + "path": "crates/oa-core/src/semantic/historical.rs", + "bytes": 15271, + "sha256": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb" + }, + { + "path": "crates/oa-core/src/semantic/linked.rs", + "bytes": 6035, + "sha256": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2" + }, + { + "path": "crates/oa-core/src/semantic/mutate.rs", + "bytes": 22683, + "sha256": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d" + }, + { + "path": "crates/oa-core/src/semantic/review.rs", + "bytes": 51116, + "sha256": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e" + }, + { + "path": "crates/oa-core/src/semantic/types.rs", + "bytes": 10405, + "sha256": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb" + }, + { + "path": "crates/oa-core/src/session.rs", + "bytes": 35237, + "sha256": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00" + }, + { + "path": "crates/oa-core/src/source_files.rs", + "bytes": 74803, + "sha256": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683" + }, + { + "path": "crates/oa-core/src/source_project.rs", + "bytes": 61843, + "sha256": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466" + }, + { + "path": "crates/oa-core/src/source_project/source_migration.rs", + "bytes": 4700, + "sha256": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95" + }, + { + "path": "crates/oa-core/src/source_project/source_structure.rs", + "bytes": 20225, + "sha256": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f" + }, + { + "path": "crates/oa-core/src/state_validation.rs", + "bytes": 15665, + "sha256": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18" + }, + { + "path": "crates/oa-core/src/topology_context.rs", + "bytes": 13734, + "sha256": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d" + }, + { + "path": "crates/oa-core/src/topology_context/analysis.rs", + "bytes": 20036, + "sha256": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65" + }, + { + "path": "crates/oa-core/src/topology_context/analysis_tests.rs", + "bytes": 5258, + "sha256": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56" + }, + { + "path": "crates/oa-core/src/transitions.rs", + "bytes": 51998, + "sha256": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d" + }, + { + "path": "crates/oa-core/src/transitions/communication.rs", + "bytes": 8634, + "sha256": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028" + }, + { + "path": "crates/oa-core/src/validation.rs", + "bytes": 112792, + "sha256": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e" + }, + { + "path": "crates/oa-core/src/validation/coverage.rs", + "bytes": 6478, + "sha256": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f" + }, + { + "path": "crates/oa-core/src/view_options.rs", + "bytes": 24481, + "sha256": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208" + }, + { + "path": "crates/oa-core/src/view_options_tests.rs", + "bytes": 21433, + "sha256": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208" + }, + { + "path": "crates/oa-core/tests/communication_boundary_scenarios.rs", + "bytes": 8816, + "sha256": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b" + }, + { + "path": "crates/oa-core/tests/communication_means.rs", + "bytes": 18102, + "sha256": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4" + }, + { + "path": "crates/oa-core/tests/coverage_diagnostics.rs", + "bytes": 20527, + "sha256": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4" + }, + { + "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia", + "bytes": 29220, + "sha256": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3" + }, + { + "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.json", + "bytes": 43990, + "sha256": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005" + }, + { + "path": "crates/oa-core/tests/fixtures/v3-data-contract.arcadia", + "bytes": 2450, + "sha256": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea" + }, + { + "path": "crates/oa-core/tests/fixtures/v3-data-contract.json", + "bytes": 8240, + "sha256": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2" + }, + { + "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia", + "bytes": 1222, + "sha256": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1" + }, + { + "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.json", + "bytes": 1734, + "sha256": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47" + }, + { + "path": "crates/oa-core/tests/language.rs", + "bytes": 56482, + "sha256": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e" + }, + { + "path": "crates/oa-core/tests/port_anchors.rs", + "bytes": 26893, + "sha256": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa" + }, + { + "path": "crates/oa-core/tests/port_migration.rs", + "bytes": 15620, + "sha256": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7" + }, + { + "path": "crates/oa-core/tests/port_source.rs", + "bytes": 4858, + "sha256": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12" + }, + { + "path": "crates/oa-core/tests/prepared_commands.rs", + "bytes": 9555, + "sha256": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b" + }, + { + "path": "crates/oa-core/tests/process_diagnostics.rs", + "bytes": 1104, + "sha256": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906" + }, + { + "path": "crates/oa-core/tests/r3_constructor_ack.rs", + "bytes": 24163, + "sha256": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0" + }, + { + "path": "crates/oa-core/tests/r3_migration.rs", + "bytes": 6590, + "sha256": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd" + }, + { + "path": "crates/oa-core/tests/r3_semantic.rs", + "bytes": 77473, + "sha256": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32" + }, + { + "path": "crates/oa-core/tests/r3_source.rs", + "bytes": 15311, + "sha256": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408" + }, + { + "path": "crates/oa-core/tests/r6_data.rs", + "bytes": 41437, + "sha256": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155" + }, + { + "path": "crates/oa-core/tests/r6_migration.rs", + "bytes": 9174, + "sha256": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1" + }, + { + "path": "crates/oa-core/tests/r6_source.rs", + "bytes": 9519, + "sha256": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6" + }, + { + "path": "crates/oa-core/tests/release1_teaching.rs", + "bytes": 10010, + "sha256": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2" + }, + { + "path": "crates/oa-core/tests/release_capabilities.rs", + "bytes": 19422, + "sha256": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30" + }, + { + "path": "crates/oa-core/tests/release_diagrams.rs", + "bytes": 7689, + "sha256": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d" + }, + { + "path": "crates/oa-core/tests/release_language_limits.rs", + "bytes": 5204, + "sha256": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806" + }, + { + "path": "crates/oa-core/tests/release_ports.rs", + "bytes": 32740, + "sha256": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1" + }, + { + "path": "crates/oa-core/tests/release_routing.rs", + "bytes": 23165, + "sha256": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462" + }, + { + "path": "crates/oa-core/tests/release_scenarios.rs", + "bytes": 41067, + "sha256": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f" + }, + { + "path": "crates/oa-core/tests/release_states.rs", + "bytes": 26873, + "sha256": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811" + }, + { + "path": "crates/oa-core/tests/release_topology.rs", + "bytes": 17643, + "sha256": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9" + }, + { + "path": "crates/oa-core/tests/review_regressions.rs", + "bytes": 21823, + "sha256": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1" + }, + { + "path": "crates/oa-core/tests/route_source.rs", + "bytes": 7270, + "sha256": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb" + }, + { + "path": "crates/oa-core/tests/routing_geometry.rs", + "bytes": 31890, + "sha256": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3" + }, + { + "path": "crates/oa-core/tests/routing_labels.rs", + "bytes": 5530, + "sha256": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6" + }, + { + "path": "crates/oa-core/tests/semantic_artifact_absence_oracle.rs", + "bytes": 4640, + "sha256": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a" + }, + { + "path": "crates/oa-core/tests/semantic_attachments_gui_oracle.rs", + "bytes": 14957, + "sha256": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970" + }, + { + "path": "crates/oa-core/tests/source6_view_contract.rs", + "bytes": 14307, + "sha256": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb" + }, + { + "path": "crates/oa-core/tests/source7_contract.rs", + "bytes": 43262, + "sha256": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f" + }, + { + "path": "crates/oa-core/tests/source_files.rs", + "bytes": 13168, + "sha256": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9" + }, + { + "path": "crates/oa-core/tests/source_identity_updates.rs", + "bytes": 5139, + "sha256": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c" + }, + { + "path": "crates/oa-core/tests/source_nested_updates.rs", + "bytes": 16892, + "sha256": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855" + }, + { + "path": "crates/oa-core/tests/source_project.rs", + "bytes": 45910, + "sha256": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942" + }, + { + "path": "crates/oa-core/tests/state_diagrams.rs", + "bytes": 23973, + "sha256": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5" + }, + { + "path": "crates/oa-core/tests/workflows.rs", + "bytes": 33426, + "sha256": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b" + }, + { + "path": "crates/oa-desktop/Cargo.toml", + "bytes": 842, + "sha256": "f3547b2b924d5db6706c0a8e069014b440ff65315d82fc8aced0360af4b3cdc9" + }, + { + "path": "crates/oa-desktop/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-desktop/src/allocation_drag.rs", + "bytes": 29634, + "sha256": "6b93290627a8697dd529ecf12b6e99196a11783afff1ca7aaf75c6e2762f3d94" + }, + { + "path": "crates/oa-desktop/src/allocation_drag/tests.rs", + "bytes": 60311, + "sha256": "13b7d055a516c8a9f0bd13f03abe3b81423bde9d121c51778a129ff485f4f102" + }, + { + "path": "crates/oa-desktop/src/allocation_input.rs", + "bytes": 8391, + "sha256": "c7825c43383e81b7eb1b78bd902950c8a2206e0387d26002a80ddbe4dc2b6c73" + }, + { + "path": "crates/oa-desktop/src/app.rs", + "bytes": 221462, + "sha256": "6e8e12bebf4aa922aab81d0614edac1ffcc7c3a92e372f0f51ee51b7dad656a1" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag.rs", + "bytes": 24452, + "sha256": "218726dcd2e6809cb6f3660f575e586806360456e6b4fac61b9e361b411aeee9" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag_full_tree_tests.rs", + "bytes": 28288, + "sha256": "ff4c3d07f885f242b71160c09e2c457c4a746073fd89030781da306730c5db44" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag_tests.rs", + "bytes": 42677, + "sha256": "3c6908f8a677921245932252ab38806f16012becbbc082ac11e7871ff7bdeeb4" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring.rs", + "bytes": 27835, + "sha256": "37c7db33e99dd4adcc5a51f09ee4878af94fd32413359890a541690080885f65" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring/palette.rs", + "bytes": 8887, + "sha256": "8f9937cb30b48b83759fd084a8a5990a2daa3920280f1210abe048560241985a" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring/tests.rs", + "bytes": 14565, + "sha256": "174e184f1baf872c3be1cf70d9a7f4bc5569a9623000b3ab0e71e2b82e249cf5" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring_tests.rs", + "bytes": 18551, + "sha256": "ba913f7d7cbf586708d65c9f1db25b9b9ed7846f9d2e75a546b4ac69d8d19c6a" + }, + { + "path": "crates/oa-desktop/src/app/behavior_lifecycle_tests.rs", + "bytes": 13672, + "sha256": "f9a0b030faca5deaf3f55d9f5efcafdf1a7cb1a663001aa20a61baba4f92d080" + }, + { + "path": "crates/oa-desktop/src/app/behavior_removal_tests.rs", + "bytes": 23958, + "sha256": "ef09843a7daeb91afab0b76e83c5679351a1635a84a26d80a194dea744ea5874" + }, + { + "path": "crates/oa-desktop/src/app/checkpoints.rs", + "bytes": 29576, + "sha256": "55e5babdcabef767af3bc8be9cc3153b3f5cc0695701b890820ec0225643852e" + }, + { + "path": "crates/oa-desktop/src/app/diagram_focus_tests.rs", + "bytes": 6047, + "sha256": "65f3f841e1295ae4878b3ae2cf45ff64003d42e26e450e9a1de1c36dbd771bd8" + }, + { + "path": "crates/oa-desktop/src/app/diagram_removal.rs", + "bytes": 8778, + "sha256": "addb51604f41d680b06586bb362362ee3c2603a334f33022ce9abc281295ac85" + }, + { + "path": "crates/oa-desktop/src/app/diagram_removal_tests.rs", + "bytes": 47336, + "sha256": "70f9eb53d8995a23a53535b3941fc0c0b81a340f9fbbb371f0d705cfa775bd9e" + }, + { + "path": "crates/oa-desktop/src/app/diagram_selection_tests.rs", + "bytes": 5582, + "sha256": "4fa507adbc23db3a6eb202d809c695ec0ebd6181356930c4fa7528a9a0c7be57" + }, + { + "path": "crates/oa-desktop/src/app/hosted.rs", + "bytes": 25059, + "sha256": "2f7094c078e1d7cbccd6c0d310afa6c400a7e031f12918bbfce65ba62754e316" + }, + { + "path": "crates/oa-desktop/src/app/hosted/tests.rs", + "bytes": 30344, + "sha256": "fa118f64d04b400ccc01e4e67adaf3541975288882afa265a9e7f092cdbda232" + }, + { + "path": "crates/oa-desktop/src/app/process_canvas.rs", + "bytes": 31677, + "sha256": "7259f093bed5cb7aa00ce39e45204a62c7ce248a00043e912cb3e186b2351365" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring.rs", + "bytes": 11250, + "sha256": "38e033e23e8135032f70117a376a5fe7bc68127c466559a35d7ec200932e3f77" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring/tests.rs", + "bytes": 20067, + "sha256": "b96ddc6bff7f8fde97720e18a92070f891c1340348d2e19c7c9c5a7bda650ce8" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring/tests/mounted.rs", + "bytes": 32805, + "sha256": "14a4914a1c86e50c395672dab8fe80d7af679a79c9082890b509fad7b7c543d9" + }, + { + "path": "crates/oa-desktop/src/app/repair_save_state_tests.rs", + "bytes": 10745, + "sha256": "5543dcba853bb1513acf824b860249729a6004747e7e320b46efe60ea19e2d83" + }, + { + "path": "crates/oa-desktop/src/app/review_navigation_tests.rs", + "bytes": 7049, + "sha256": "872fa91479dad5436e139ffcaece270323e9f5daeeb7a4d80c2c2534f48bc21b" + }, + { + "path": "crates/oa-desktop/src/app/save_as_tests.rs", + "bytes": 4113, + "sha256": "f8b915793f1a36fd152569c4781a4bdc17f4af404a8ceb373330053413087a1c" + }, + { + "path": "crates/oa-desktop/src/app/state_diagram.rs", + "bytes": 10050, + "sha256": "9ae3d533a20963a2bd1d485d357ac04319f336cd9f4c16305aa2a67d833573a8" + }, + { + "path": "crates/oa-desktop/src/app/state_diagram_tests.rs", + "bytes": 39957, + "sha256": "612e414b1a2cab12cbfd8fce23745559ff27577700694d53af67ad1f2883ee2c" + }, + { + "path": "crates/oa-desktop/src/app/transition_context_tests.rs", + "bytes": 11508, + "sha256": "47002fb025f3a2f8c53871f9509bfe8611a61db6fb0e1b3125eb6e875425cb1d" + }, + { + "path": "crates/oa-desktop/src/app/view_copy_tests.rs", + "bytes": 7846, + "sha256": "296821c51dcde568e7d717039aa26bfc1b56a9074aa16051007bb351b33a4d44" + }, + { + "path": "crates/oa-desktop/src/behavior.rs", + "bytes": 130007, + "sha256": "3089d88a8fa66ecaa2151f2f55a85c71de30e556457fcd52fdbd0ca1184b59d8" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace.rs", + "bytes": 7904, + "sha256": "16f7333c3ccac4760ef41aa14c2e5815fd7e7ed7f49182b34301555e7e9fd196" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/control.rs", + "bytes": 7804, + "sha256": "2b8d97b8c0e3ff1b1a2c32187b1d0eb25edf39ba582b5fb3303bc880f674f7ba" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/focus.rs", + "bytes": 8943, + "sha256": "cc58cb3838f546150d22fe4dd83a3ffd52504c279febaeb8d0b4a6a3b8a73950" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/tests.rs", + "bytes": 27101, + "sha256": "b33361c6569354aa2df9b1ba1b60d68e4703800be80f815e0f0505064ea323c3" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/viewport.rs", + "bytes": 15164, + "sha256": "41ff9c50fa9fb89ab9fdb2d18dadc21585aafa1ee008cfcd1e0b731dce645eaf" + }, + { + "path": "crates/oa-desktop/src/behavior/contextual_source_tests.rs", + "bytes": 49518, + "sha256": "044bd412dc45ffe440b1e251993946942dc3759dcb2d5dfe71bd8d6ef61cbcc7" + }, + { + "path": "crates/oa-desktop/src/behavior/creation.rs", + "bytes": 28978, + "sha256": "33ae9aaf4ba90de9432870cc8e99708ef39e3638ae8283a9253c333785c91299" + }, + { + "path": "crates/oa-desktop/src/behavior/creation/app_tests.rs", + "bytes": 13181, + "sha256": "e9c5bf2b07357b7a2f679ae0d8f6904c1c1461aaeb94fa0db478b54d4641ae3e" + }, + { + "path": "crates/oa-desktop/src/behavior/creation/tests.rs", + "bytes": 22793, + "sha256": "a0d1daf9fb3920f7e6181a9802d84fbe056cbf0043b9e41dba5fdda687d9818a" + }, + { + "path": "crates/oa-desktop/src/behavior/form_session.rs", + "bytes": 3941, + "sha256": "f5027fb3a5a5599a182e7d1a10dba56dd66eb1f23a4ba4c4a1744c9a6a5b6e61" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario.rs", + "bytes": 153353, + "sha256": "fb69e052343aeeba9d5763689d09ada736a67b52bad61ff3c42e2e06b4c96b73" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/focus.rs", + "bytes": 9728, + "sha256": "73a9ea10ad7312086081b8688396a21ab4251c9faecc2df6d984b702f3963533" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/workspace.rs", + "bytes": 24990, + "sha256": "0734a09b4df84f5f6ff0c1f1090ea3edef99dbb2d5d9f9a3af3e7581e5567058" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/workspace/tests.rs", + "bytes": 80701, + "sha256": "7684fac276ca4de2d9b6b8fc4e04fb5035a0a5966bc06520e78fca6ffdebc359" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_activation.rs", + "bytes": 14095, + "sha256": "77199dcb08ec8697f779d2560f6b716aed8d8f33965237a4934934954f4e805a" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_activation/tests.rs", + "bytes": 24665, + "sha256": "5b3f1d2144f405e492686731cc35d05f21b87ada60e426014e6b5f5e5f103298" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_lifecycle.rs", + "bytes": 9324, + "sha256": "758d244c2e8de61f515d540baa4d967275f49720e0253c6c9159eb9acd71c859" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_lifecycle/tests.rs", + "bytes": 15430, + "sha256": "01b576993b329810cd78a859b45ac52c66f5a14549065661dd1308196e0b724d" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_operation_tests.rs", + "bytes": 10087, + "sha256": "89fb71c690e07eac314f7a5e05862d5c1e2f9c21039673bf22c4ac894d21c977" + }, + { + "path": "crates/oa-desktop/src/behavior/source_draft.rs", + "bytes": 18031, + "sha256": "08190823090bd8b0305809099abadcc0de431175f7044f1d5abdceda52612ee1" + }, + { + "path": "crates/oa-desktop/src/behavior/state_canvas.rs", + "bytes": 96098, + "sha256": "5844d2abf4a3fe3bb07c707865ee3f8303d213b0fe1871765ac468c11e140da7" + }, + { + "path": "crates/oa-desktop/src/behavior/state_edit.rs", + "bytes": 35843, + "sha256": "4e67321ab0cf88e6200061873086841244c4d610ddd5f88d70c69ac0cc6bf270" + }, + { + "path": "crates/oa-desktop/src/behavior/state_menu.rs", + "bytes": 8530, + "sha256": "9d0a3c29516efa79553c559274848f12101330dbf93ffbbefab398cbc1906790" + }, + { + "path": "crates/oa-desktop/src/behavior/state_view.rs", + "bytes": 7637, + "sha256": "3d01c853663385fc1b760401bbebe3f691fcc289a779a8e63cd0733ff0c8007f" + }, + { + "path": "crates/oa-desktop/src/behavior/states.rs", + "bytes": 26986, + "sha256": "8986ed9492960e20f1254e9dfe3ff91d79ce9fef66f3bda738f9933278043954" + }, + { + "path": "crates/oa-desktop/src/behavior/topology.rs", + "bytes": 84212, + "sha256": "26e24ad0f781a3304c46299b3bd906917e57fac262e7f52fba4adc80a4358ec5" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/contextual.rs", + "bytes": 28432, + "sha256": "5d0ac5b3e258fc70987a00ede1e603681d99746596f2fcc46ad2b3667d65203a" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/contextual_routing.rs", + "bytes": 16731, + "sha256": "d914b0e82aa8d253fe64be2ef74443d1fd2e6cec26d1cf30620a57646e1d426c" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/direct.rs", + "bytes": 39108, + "sha256": "261e27f50dd1e32687e113ffd29a1cb5ae4421628e0aef3abd17a77ac180597c" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/direct_tests.rs", + "bytes": 51170, + "sha256": "edccfe3ce8b224065a3540aa53c6340f13db0cecd48ecc0a3904cd832a483964" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/layout_tests.rs", + "bytes": 38169, + "sha256": "7c4c2fdd966acc926617fbd12a3b28a518b1b21ffbe3a5917e9ff621ff29a938" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/view.rs", + "bytes": 22009, + "sha256": "29e29c2a0667baa429ae44dbb400e67c86f24f88959d5e7dd22894473bdd1f09" + }, + { + "path": "crates/oa-desktop/src/connection_edit.rs", + "bytes": 5301, + "sha256": "020581e077f82b43c936b623cc51733b02b88428df4e5f25df74b9705819fa37" + }, + { + "path": "crates/oa-desktop/src/connection_tool.rs", + "bytes": 27023, + "sha256": "649da93677d52dae495b0e19bc32f3122ab05a6d84de8402578ff5ce3f6ee1d3" + }, + { + "path": "crates/oa-desktop/src/context_menu.rs", + "bytes": 52955, + "sha256": "629354b34dc232763700251f2695b4d4e53d6251c0b1432ecc0dfe424f7dfeac" + }, + { + "path": "crates/oa-desktop/src/data_values.rs", + "bytes": 23877, + "sha256": "e1deb1cad551f0a9fdef9653aad257cfb36e6d9c0f93b6245061ec3fab8fd365" + }, + { + "path": "crates/oa-desktop/src/data_view.rs", + "bytes": 38871, + "sha256": "158b852be5d3db450aa5cda8b68a35bd96bddce1d8d053a7a23582095c06362d" + }, + { + "path": "crates/oa-desktop/src/diagram.rs", + "bytes": 111242, + "sha256": "e5260a39e19fc3df19bd16898ff1f0abd60ede7584f595c035b5e86a12ecef93" + }, + { + "path": "crates/oa-desktop/src/diagram/focus.rs", + "bytes": 9197, + "sha256": "b88a7c43123b08cf6228d8e32257f6ed7fe361f7278f427ec138e233e1ea6ccf" + }, + { + "path": "crates/oa-desktop/src/diagram/lifecycle_tests.rs", + "bytes": 9342, + "sha256": "03dd13106f3fdd06a26699bfdfba006fad086a0711cad2ba1aeb09a4e8f8656e" + }, + { + "path": "crates/oa-desktop/src/diagram/pointer_tests.rs", + "bytes": 11859, + "sha256": "ae68e091032fe2cf71559ff7e671b3b6d657ee8279330345f0c7a57edfa472ef" + }, + { + "path": "crates/oa-desktop/src/diagram/port_hit_tests.rs", + "bytes": 5650, + "sha256": "c3728f127711cb6d7f80a4670a798808b6e4239dd29c273445de81706ab6f39e" + }, + { + "path": "crates/oa-desktop/src/diagram/port_labels.rs", + "bytes": 13574, + "sha256": "6643f0cbde7a59d4772ae5284a488083e3b81f2fefabc43619d75738f474646f" + }, + { + "path": "crates/oa-desktop/src/diagram/view_options_tests.rs", + "bytes": 2815, + "sha256": "cf0c98a7715558baf17b59f67a80556f98ad30262b4434635e617c6601775433" + }, + { + "path": "crates/oa-desktop/src/diagram/work_drag.rs", + "bytes": 7059, + "sha256": "9757534a7ba47dc0df5d41c8d7366b1d90f3d50b24344580ff3c783667bf66f0" + }, + { + "path": "crates/oa-desktop/src/document.rs", + "bytes": 31807, + "sha256": "7c87280b5b8d112c34865253f8ba0f80d43bc9897771943b15dc7b5608eb17a4" + }, + { + "path": "crates/oa-desktop/src/document_save_as_tests.rs", + "bytes": 5781, + "sha256": "83dc243a25f4e97674ff0d86c794a490cc923e98f1f9fb05bb038f622f11e20b" + }, + { + "path": "crates/oa-desktop/src/explorer.rs", + "bytes": 14764, + "sha256": "fa01c59219564ba9ae5553abc2b6f94e9849f9148d5812ef99b40318fe5dcf9a" + }, + { + "path": "crates/oa-desktop/src/explorer_view.rs", + "bytes": 13773, + "sha256": "a720d7484bcc3a24729332a00e005d1cc6f5f945a9cc3965134e0024dffb581f" + }, + { + "path": "crates/oa-desktop/src/forms.rs", + "bytes": 105544, + "sha256": "ea124f479fcd2d3978ac3cb8eb81fec4a7aae5e4f4414c4bdd54849e954dedf9" + }, + { + "path": "crates/oa-desktop/src/forms/context_fields.rs", + "bytes": 10831, + "sha256": "eaacd474f6500dd344d5a8b63ccb1d1dd86fe2aea78ab708afa8a80d62ce69bf" + }, + { + "path": "crates/oa-desktop/src/forms/data_fields.rs", + "bytes": 49285, + "sha256": "a540a0d451bff56a96b1d28643b2e8c0649f3846350c25c5b154729c0538e77c" + }, + { + "path": "crates/oa-desktop/src/forms/history_fields.rs", + "bytes": 27414, + "sha256": "e7100474cde18bdfe95562bcb3c055f29b4b15aa64788a578194464aebcd046e" + }, + { + "path": "crates/oa-desktop/src/forms/history_fields/tests.rs", + "bytes": 33950, + "sha256": "16d3c308138c063f45986d53c621ad83c7dc2ce853edd31b7204e2939a382df9" + }, + { + "path": "crates/oa-desktop/src/forms/port_fields.rs", + "bytes": 30554, + "sha256": "3fe684d651d5be6203fd9db3979c772913e1af5ac1514e67be386ffd88dc8127" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser.rs", + "bytes": 12130, + "sha256": "b60af363be333af048859e51c28e8c989cb5c95d696cad16c8eec15f78d57a12" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/adapter.rs", + "bytes": 10447, + "sha256": "87ab4bc3bf27fd4b5a458791cf62c7ba8e44e9ebf846d8b851b8b6ffb454cd64" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/tests.rs", + "bytes": 27835, + "sha256": "8e98f8a3fcb814d4a201cc85b3db87a689fd3d2ce487f8a2fe312fc296f93377" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/trigger.rs", + "bytes": 13336, + "sha256": "34d0acecfe6bed193970aa473cc3313984971264b86d7b362a6b84c23d013c0a" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/trigger/focus.rs", + "bytes": 9923, + "sha256": "f1e79f4b03b2f9fd1cdc335054d4ae177dc9e759b6ea3d334b2bcca39b57191b" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/widget.rs", + "bytes": 33804, + "sha256": "d66cc17af7a48bb8598be683f084bb08fa7af7304f9636f0a1bea94c5cf6c727" + }, + { + "path": "crates/oa-desktop/src/forms/view_fields.rs", + "bytes": 24987, + "sha256": "5184d438f0dfd4e29f284ff048e19da73e71be1f24a6e9f123c7e922aecb85fa" + }, + { + "path": "crates/oa-desktop/src/guide.rs", + "bytes": 118111, + "sha256": "c23ac5b587950a8ffd7978a47ffe462898f2a0b795607bc12b6fa637762e7f60" + }, + { + "path": "crates/oa-desktop/src/highlight.rs", + "bytes": 2751, + "sha256": "da7c254fff7052e5fd9ec7469f473b91a819406028d7c304f6e22c4169561600" + }, + { + "path": "crates/oa-desktop/src/home.rs", + "bytes": 17587, + "sha256": "f03c1071334894f586a5a7c86026602a694db3c2faf902822e1dbe5156a859c2" + }, + { + "path": "crates/oa-desktop/src/home/tests.rs", + "bytes": 8167, + "sha256": "3b03ccfc97dfb75954e1e0ed568bb87a632295c07b96cedc05ed381f87b378f3" + }, + { + "path": "crates/oa-desktop/src/hosted/client.rs", + "bytes": 21912, + "sha256": "54b24b4b50f8d87d7c92946ea5a2cff4c98760e70555b3ce3d90be27115e95d4" + }, + { + "path": "crates/oa-desktop/src/hosted/client_tests.rs", + "bytes": 23009, + "sha256": "3ef70907ca75e098d631c41b90badd4cff1e1eb1b3c78e15a9f811c13ba8ffbe" + }, + { + "path": "crates/oa-desktop/src/hosted/mod.rs", + "bytes": 3744, + "sha256": "1b75e11c80fcb38fd20bb3487e3f88729fdac73e471c5ae64da28c249f77c63b" + }, + { + "path": "crates/oa-desktop/src/hosted/view.rs", + "bytes": 9281, + "sha256": "fc0c7b7ce3a5f05c49713df6661067751f81e810af11c614ca265ea9490e6463" + }, + { + "path": "crates/oa-desktop/src/main.rs", + "bytes": 1554, + "sha256": "5228743f361f9239e4584780bfa9b65d36207d0288624e1fb42b721146bcff1c" + }, + { + "path": "crates/oa-desktop/src/model_menu.rs", + "bytes": 36340, + "sha256": "d2f836661f43fa1bc8830b1e51cc736948b3d261796c3fa877df02ae15568c4b" + }, + { + "path": "crates/oa-desktop/src/navigation.rs", + "bytes": 8839, + "sha256": "71355a12e1b4791106426d83fe5ebf0b29bce8e1dc594f0655ab85695469669e" + }, + { + "path": "crates/oa-desktop/src/port_edit.rs", + "bytes": 7809, + "sha256": "70b99f577c4fdeda8780c8dc1ee7b1639fd77aaca06658f06d725139fb3efb6d" + }, + { + "path": "crates/oa-desktop/src/port_preview.rs", + "bytes": 35855, + "sha256": "069487c4ece737d52e8ae4a84dcfb132236aca6799e841c91c8e7244320cf871" + }, + { + "path": "crates/oa-desktop/src/port_workflow.rs", + "bytes": 40582, + "sha256": "ccc15f97c3272145a67bb5857b4faeaf7437561bd61912fa27ab26e8824146a0" + }, + { + "path": "crates/oa-desktop/src/recovery.rs", + "bytes": 21041, + "sha256": "57e22e5fbb0e994e64ae03e69450271fe9f04a951db1670c2a018abe99db4489" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/README.md", + "bytes": 1587, + "sha256": "a90002df1e087d2dac7be26926864243568a0de7c4103e4927435b34178e8016" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/profiles.json", + "bytes": 473, + "sha256": "2c12ae96b50e6da5d60ce2b7fa00204be71dfbe2fd51311fc337a0de6a4332ff" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source5-bundle.json", + "bytes": 80974, + "sha256": "12715995e6f7f35414aea53b3ad720b9b31873ffdeaf4444231db1a5ac3c463e" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source5-model.json", + "bytes": 86191, + "sha256": "5535a706df9ec21715e8b6a5aa6dbd79636ae461450aee61305559016167612b" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source6-bundle.json", + "bytes": 85286, + "sha256": "ea88890a33f47d67dfb06d6dbbcc179058cf28dad76ae7d615c00aaf30dbbbfe" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source6-model.json", + "bytes": 90629, + "sha256": "5bb8db0b6394276666323483f977ac3586f88554c81a148c6d508fca0ef4576f" + }, + { + "path": "crates/oa-desktop/src/recovery/source5.rs", + "bytes": 6956, + "sha256": "0f0a763f0c98c2c908d4c2b95d8a4c042b6a255ee1cc16260e5404669691f642" + }, + { + "path": "crates/oa-desktop/src/recovery/source5_tests.rs", + "bytes": 12146, + "sha256": "cfd17a742f1f27b523fce7cd9309f0a07a30413395f6c58659fb91d02834a7a3" + }, + { + "path": "crates/oa-desktop/src/recovery/source7_tests.rs", + "bytes": 18213, + "sha256": "7ee61de66c75bf949489ba51ddc9677e2b4efc68801cf27909c9b894bfdc9288" + }, + { + "path": "crates/oa-desktop/src/route_edit.rs", + "bytes": 2941, + "sha256": "457ae59c2761a43a8620b4d336a7cf0f54b965997110ecaf968756a88b6b0374" + }, + { + "path": "crates/oa-desktop/src/semantic_review.rs", + "bytes": 3432, + "sha256": "8dd1e93783d63a663c7e56c28775a5c389cfd7a6b562013d6a95c891afa21ed8" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts.rs", + "bytes": 24201, + "sha256": "a79236a8150597ff808597e59cf4f1e9e61c74c4901d9c8cf42d3427bb52a9a8" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_recovery_falsifier_tests.rs", + "bytes": 11034, + "sha256": "3f255d04e4bffa5a467b75e3cbf6f7149aa3269a02f2a89fbaa1db0e5df9ae62" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_tests.rs", + "bytes": 20798, + "sha256": "04d0dd2ac453705185663f705282aa4a3a31433466a5be305764248da1a03c32" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_view.rs", + "bytes": 6447, + "sha256": "2100ff73565765d8293c84f6ce2d8e566610c1524c50e32ce3c37dc33b6686e4" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments.rs", + "bytes": 18160, + "sha256": "de0ec0c740895b160ff5b847332c087c3f1a48931583464069470cc61315ed59" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments_tests.rs", + "bytes": 29389, + "sha256": "8b26be0324e0f33b1e7cf7af340350df8ed98963002d6da8589ee0e6f6900bea" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments_view.rs", + "bytes": 3032, + "sha256": "932f231554d77c7cb119d33bb06b9879db5e12127aed187e67013e77b6458e78" + }, + { + "path": "crates/oa-desktop/src/semantic_review/batch.rs", + "bytes": 34485, + "sha256": "a462eb627ae19348072775cf8e60b17d62f6b682b74cc413906d493fba1f0b3c" + }, + { + "path": "crates/oa-desktop/src/semantic_review/batch_tests.rs", + "bytes": 27546, + "sha256": "b67c4d7dcabac710cf3d30730a8db323180a558a415e2d117c868cdfa4804619" + }, + { + "path": "crates/oa-desktop/src/semantic_review/compose.rs", + "bytes": 27155, + "sha256": "c6adcc9882dde65e9f04f6eda7f0c855c5cbb285cf421123029169112793ce9b" + }, + { + "path": "crates/oa-desktop/src/semantic_review/compose_diagnostic_tests.rs", + "bytes": 9809, + "sha256": "440daf8d43278ef981c620d1818d0daaed8fb83193b8e8ff67b2e42fbf882938" + }, + { + "path": "crates/oa-desktop/src/semantic_review/constructor_tests.rs", + "bytes": 54132, + "sha256": "85149521ad7df62918f6f2fab6da2b3346c342ab4bce7100de3f6206c1e81096" + }, + { + "path": "crates/oa-desktop/src/semantic_review/constructors.rs", + "bytes": 12258, + "sha256": "0982163439b06a42d9af1643530364109282e63f05b323a35a76d8241f3caa32" + }, + { + "path": "crates/oa-desktop/src/semantic_review/history.rs", + "bytes": 3211, + "sha256": "df038c2464eab8093a983f3104f0d04ca8f602010a50e1d3eeb8e53f2309e201" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed.rs", + "bytes": 14175, + "sha256": "bdd6c0fdc7108056bc5d7433254503449eed2209813680e717ead24b9d0ce834" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_rows.rs", + "bytes": 13222, + "sha256": "4b7bf25806471ad22d89253b9af8000f5acff53b4cc0aa1c1a83138e7b270eca" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_rows_tests.rs", + "bytes": 30804, + "sha256": "1a3b09e7ed100411cdf8043f9a78defc664a873ee0201117709185c201a5c57f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_tests.rs", + "bytes": 31163, + "sha256": "9dc9b989e5a9d408427ca1baf86b2454f9dd3baf40a551c70ca2359dc18a1227" + }, + { + "path": "crates/oa-desktop/src/semantic_review/message_kind.rs", + "bytes": 789, + "sha256": "4ed19952ea511d1b3226564a138e3322f994371d6b49794c14bc3689d1393e7f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/message_kind_tests.rs", + "bytes": 23424, + "sha256": "5fcf9930e949aebeb12eab0327264f32a2388d62dbf098bd2365711e22623c52" + }, + { + "path": "crates/oa-desktop/src/semantic_review/ordered.rs", + "bytes": 9705, + "sha256": "6a1ed894d1b9d0110bc784a75c49444f1d14f1f74620d701f22203b2d8d0a813" + }, + { + "path": "crates/oa-desktop/src/semantic_review/ordered_tests.rs", + "bytes": 22383, + "sha256": "5c8ea3a69e3da3b94d13f50f12aa7dc53246ccba25ffcace9552a0eb76b0bf36" + }, + { + "path": "crates/oa-desktop/src/semantic_review/recovery.rs", + "bytes": 28769, + "sha256": "88e69044d90c481593bab7cc125f0401c05202fccdde07698cec9483947fe8be" + }, + { + "path": "crates/oa-desktop/src/semantic_review/row.rs", + "bytes": 38159, + "sha256": "b08fdc503c6c4d2ff99adac7e18c9baa861bf86155e00b55d1e492430980d0f2" + }, + { + "path": "crates/oa-desktop/src/semantic_review/scalar.rs", + "bytes": 15153, + "sha256": "9ad202174934dd9a63fbf9cba43135aead571db60846c8b7b1d3019a11df26c2" + }, + { + "path": "crates/oa-desktop/src/semantic_review/source7_tests.rs", + "bytes": 11665, + "sha256": "5e8221d77b068fa30c1571988448cb8829711735881d810f3d333cbc95d34a9f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/tests.rs", + "bytes": 32480, + "sha256": "077ec6501dfaab0b05ea3987943b204f08352952296d313555051d998ccd232e" + }, + { + "path": "crates/oa-desktop/src/semantic_review/view.rs", + "bytes": 57626, + "sha256": "7cc7dd213ab01dadad5debaee868c30a1099466602869a799ebdf9b680e8eaf0" + }, + { + "path": "crates/oa-desktop/src/semantic_review/view_reserved_artifact_tests.rs", + "bytes": 4737, + "sha256": "6c766b29c8664d15cb113d2cc71bba9b60ae4ccf7e44c9c5d3c41e1dc4b7ed90" + }, + { + "path": "crates/oa-desktop/src/source_navigation.rs", + "bytes": 3938, + "sha256": "c1da10882f35f8eb0675e68c642c9a209dde09679cded414cfb9903a4e49ec77" + }, + { + "path": "crates/oa-desktop/src/source_tree.rs", + "bytes": 21816, + "sha256": "4d55e0110a1eb128a5d26c28f3aae5853d79b7245812b7c82bd275f38440a5aa" + }, + { + "path": "crates/oa-desktop/src/source_workspace.rs", + "bytes": 15522, + "sha256": "30f63a6b8d65a38d66061f90d864b5746cbacc0fbd65abc028a8f3071c47d358" + }, + { + "path": "crates/oa-desktop/src/style.rs", + "bytes": 3015, + "sha256": "05d61bec16141612ccafa0988e8c4827f41754509efdb3b961eab69127ded896" + }, + { + "path": "crates/oa-desktop/src/tests.rs", + "bytes": 58557, + "sha256": "b017218195eea2c96aba12eba8a99a38945c8ca910a652e272d34883bdb98691" + }, + { + "path": "crates/oa-desktop/src/view_copy.rs", + "bytes": 9043, + "sha256": "5630f31c942e1226aafd67eabdace6a5c5494875bdc6f7f077019e8110ba41a9" + }, + { + "path": "crates/oa-desktop/src/views.rs", + "bytes": 51734, + "sha256": "1d89f902d645b9cbd95b86ff9a4f72d7bcc5dc2b8a478ed0f7ea9e0f88803cde" + }, + { + "path": "crates/oa-desktop/src/views/traceability.rs", + "bytes": 7501, + "sha256": "4c89dcf35c25e737d8cce4d543a5989ca104a5678e6cf40df47e457773d2ef94" + }, + { + "path": "crates/oa-desktop/src/workflow.rs", + "bytes": 82963, + "sha256": "d9e7b11a86fd3ec79d91f0c9bc9cebd5a2043cdaa7261622454fb7730ad8e060" + }, + { + "path": "crates/oa-desktop/src/workflow/communication.rs", + "bytes": 11084, + "sha256": "34d121ad97706012722e4bb6210072ecc3a5b4718b0ceab0c3d0f14d4cd780a1" + }, + { + "path": "crates/oa-desktop/src/workflow/recovery.rs", + "bytes": 9859, + "sha256": "0849b0f34dba5e8761be5fa05784d134ac74e4e9db395d6b9b7d6cff71e3f3dc" + }, + { + "path": "crates/oa-desktop/src/workflow/transition_tests.rs", + "bytes": 8553, + "sha256": "589b1b2dbadca74a52c2cfcfd4fe620bd4790abd113ac02182e91616c52d793c" + }, + { + "path": "crates/oa-server/Cargo.toml", + "bytes": 778, + "sha256": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982" + }, + { + "path": "crates/oa-server/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-server/src/error.rs", + "bytes": 5610, + "sha256": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368" + }, + { + "path": "crates/oa-server/src/lib.rs", + "bytes": 7743, + "sha256": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664" + }, + { + "path": "crates/oa-server/src/main.rs", + "bytes": 4163, + "sha256": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3" + }, + { + "path": "crates/oa-server/src/preparation_http_tests.rs", + "bytes": 5523, + "sha256": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07" + }, + { + "path": "crates/oa-server/src/routes.rs", + "bytes": 46053, + "sha256": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b" + }, + { + "path": "crates/oa-server/src/store.rs", + "bytes": 25524, + "sha256": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5" + }, + { + "path": "crates/oa-server/src/store_preparation_gate.rs", + "bytes": 4440, + "sha256": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec" + }, + { + "path": "crates/oa-server/tests/http.rs", + "bytes": 71892, + "sha256": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975" + }, + { + "path": "crates/oa-server/tests/http/communication_limits.rs", + "bytes": 5790, + "sha256": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16" + }, + { + "path": "crates/oa-server/tests/http/data_contracts.rs", + "bytes": 25949, + "sha256": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b" + }, + { + "path": "crates/oa-server/tests/http/port_anchors.rs", + "bytes": 15086, + "sha256": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258" + }, + { + "path": "crates/oa-server/tests/http/semantic_transitions.rs", + "bytes": 22832, + "sha256": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920" + }, + { + "path": "crates/oa-server/tests/http/source6_views.rs", + "bytes": 13023, + "sha256": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07" + }, + { + "path": "crates/oa-server/tests/http/source7_contracts.rs", + "bytes": 11000, + "sha256": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8" + }, + { + "path": "crates/oa-server/tests/http/source_projects.rs", + "bytes": 30907, + "sha256": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a" + }, + { + "path": "crates/oa-server/tests/semantic_http_contract.py", + "bytes": 7251, + "sha256": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2" + }, + { + "path": "crates/oa-server/tests/semantic_schema.py", + "bytes": 25111, + "sha256": "cacca116c42ffbc097f1419c0f89921fa0dfd3faa864d46820ff744cfe6967f9" + }, + { + "path": "crates/oa-server/tests/state_representation.rs", + "bytes": 12241, + "sha256": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61" + }, + { + "path": "docs/acceptance.md", + "bytes": 3463, + "sha256": "32ed3e4fed63f5c464e0937221f401d71623b276dd70f083531ac6ccebbf9050" + }, + { + "path": "docs/api.html", + "bytes": 72515, + "sha256": "a06126cb741da57e9c06e83fc4137ccde0de05562673546bc9d405878f51ea07" + }, + { + "path": "docs/api.rst", + "bytes": 41929, + "sha256": "ca7d310138c3b4d429d80a1d03d1ac8d4a9296069e205da573034256d10438a7" + }, + { + "path": "docs/architecture.md", + "bytes": 10974, + "sha256": "a50bd1645222ef3e574fa07a6ab9aa213431ee8833c6c0158ad91ce0f799543c" + }, + { + "path": "docs/language.html", + "bytes": 175111, + "sha256": "67dcfa3477b48a0b07298ec81741840cc3ccff12c7d58164873d746d41d611c8" + }, + { + "path": "docs/language.rst", + "bytes": 134663, + "sha256": "12229dd7d52fbaba80fe599d499f29b535f4c37c7be0585664d17edf0466ba33" + }, + { + "path": "docs/linux-packaging.md", + "bytes": 8671, + "sha256": "41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0" + }, + { + "path": "docs/openapi.json", + "bytes": 346920, + "sha256": "bc5825a3182a4df5f6710a80262f4a09b4c15f0e4cda7ca74e1746ceca81a89b" + }, + { + "path": "docs/research-v2-architecture.md", + "bytes": 40445, + "sha256": "1b3809f2dabe6b1805dbf3d3f2625c471cd21356c7bd603916466a8c4ced8090" + }, + { + "path": "docs/research-v2-semantics.md", + "bytes": 31535, + "sha256": "b7ec3677300248926a88b84da3e7ffe52f5b73524c7712c927a0e951569db04f" + }, + { + "path": "docs/research-v2-service.md", + "bytes": 36209, + "sha256": "4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e" + }, + { + "path": "docs/research-v2-ui.md", + "bytes": 3245, + "sha256": "894e721b59a8ca85f0d95b6706ed5f130a0372def460cf33aeefc9e5e38cde0a" + }, + { + "path": "docs/scope.md", + "bytes": 16690, + "sha256": "a1d0cfbfc06fc8bc2bf0f71343aacc8853cbbbfc00a1fc9852ddf41c8245ffca" + }, + { + "path": "docs/server.md", + "bytes": 23361, + "sha256": "4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48" + }, + { + "path": "docs/source-cli.md", + "bytes": 3374, + "sha256": "34f12b72cc6d6ead4f47c7818c1897db592f8ad493c70776db2ab48c24d8f051" + }, + { + "path": "docs/v2-interface.md", + "bytes": 11807, + "sha256": "c7fbaf0ebd3fc9f6c11f818db2b0b9d68a33f580cfced22bde83ce08ae790bc7" + }, + { + "path": "docs/validation.md", + "bytes": 6505, + "sha256": "f46ea950ed1a54409aa07c4f9e90f39f8e2d00c1dd1b6cb805caa3993845967f" + }, + { + "path": "docs/windows-packaging.md", + "bytes": 10406, + "sha256": "2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8" + }, + { + "path": "examples/coastal-rescue.arcadia", + "bytes": 33107, + "sha256": "7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17" + }, + { + "path": "examples/coastal-rescue.json", + "bytes": 49715, + "sha256": "242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195" + }, + { + "path": "examples/legacy-v1-coastal-rescue.arcadia", + "bytes": 3449, + "sha256": "4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a" + }, + { + "path": "examples/legacy-v1-coastal-rescue.oa.json", + "bytes": 5976, + "sha256": "fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24" + }, + { + "path": "examples/release1/README.md", + "bytes": 11137, + "sha256": "113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5" + }, + { + "path": "examples/release1/evidence/repair-check.md", + "bytes": 1419, + "sha256": "f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5" + }, + { + "path": "examples/release1/expected-diagnostics.json", + "bytes": 288, + "sha256": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e" + }, + { + "path": "examples/release1/model.json", + "bytes": 134520, + "sha256": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727" + }, + { + "path": "examples/release1/model.rs", + "bytes": 28762, + "sha256": "15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5" + }, + { + "path": "examples/release1/oa/activities/activity_oa_restore_work.arcadia", + "bytes": 1307, + "sha256": "83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4" + }, + { + "path": "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia", + "bytes": 697, + "sha256": "172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d" + }, + { + "path": "examples/release1/oa/behavior/process_oa_field_procedure.arcadia", + "bytes": 1781, + "sha256": "d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324" + }, + { + "path": "examples/release1/oa/behavior/process_oa_response.arcadia", + "bytes": 3225, + "sha256": "cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc" + }, + { + "path": "examples/release1/oa/behavior/scenario_oa_conversation.arcadia", + "bytes": 1795, + "sha256": "b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6" + }, + { + "path": "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia", + "bytes": 1261, + "sha256": "00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c" + }, + { + "path": "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia", + "bytes": 2022, + "sha256": "447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5" + }, + { + "path": "examples/release1/oa/capabilities.arcadia", + "bytes": 781, + "sha256": "fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936" + }, + { + "path": "examples/release1/oa/model.arcadia", + "bytes": 661, + "sha256": "f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15" + }, + { + "path": "examples/release1/oa/participants.arcadia", + "bytes": 1834, + "sha256": "951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3" + }, + { + "path": "examples/release1/oa/types.arcadia", + "bytes": 788, + "sha256": "9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49" + }, + { + "path": "examples/release1/project.arcadia", + "bytes": 1958, + "sha256": "b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda" + }, + { + "path": "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia", + "bytes": 706, + "sha256": "73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088" + }, + { + "path": "examples/release1/sa/behavior/process_sa_field_procedure.arcadia", + "bytes": 1790, + "sha256": "886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768" + }, + { + "path": "examples/release1/sa/behavior/process_sa_response.arcadia", + "bytes": 3234, + "sha256": "041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a" + }, + { + "path": "examples/release1/sa/behavior/scenario_sa_conversation.arcadia", + "bytes": 2127, + "sha256": "97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85" + }, + { + "path": "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia", + "bytes": 1256, + "sha256": "e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74" + }, + { + "path": "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia", + "bytes": 2022, + "sha256": "05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736" + }, + { + "path": "examples/release1/sa/capabilities.arcadia", + "bytes": 781, + "sha256": "b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f" + }, + { + "path": "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia", + "bytes": 297, + "sha256": "e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f" + }, + { + "path": "examples/release1/sa/functions/function_sa_restore_work.arcadia", + "bytes": 2576, + "sha256": "fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6" + }, + { + "path": "examples/release1/sa/model.arcadia", + "bytes": 661, + "sha256": "d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4" + }, + { + "path": "examples/release1/sa/participants.arcadia", + "bytes": 4012, + "sha256": "780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8" + }, + { + "path": "examples/release1/sa/types.arcadia", + "bytes": 1227, + "sha256": "101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660" + }, + { + "path": "examples/release1/traceability.arcadia", + "bytes": 29506, + "sha256": "48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f" + }, + { + "path": "examples/release1/transition-before.json", + "bytes": 35801, + "sha256": "2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d" + }, + { + "path": "examples/release1/transition-request.json", + "bytes": 4276, + "sha256": "43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a" + }, + { + "path": "examples/release1/views/diagram_oa_allocation_view.arcadia", + "bytes": 2176, + "sha256": "dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7" + }, + { + "path": "examples/release1/views/diagram_sa_allocation_view.arcadia", + "bytes": 2173, + "sha256": "b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389" + }, + { + "path": "examples/release1/views/diagram_sa_capability_view.arcadia", + "bytes": 1620, + "sha256": "75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649" + }, + { + "path": "examples/release1/views/diagram_sa_service_view.arcadia", + "bytes": 2209, + "sha256": "b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b" + }, + { + "path": "examples/release1/views/diagram_sa_state_view.arcadia", + "bytes": 1931, + "sha256": "5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869" + }, + { + "path": "examples/routing-workshop.arcadia", + "bytes": 66431, + "sha256": "dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a" + }, + { + "path": "examples/routing-workshop.json", + "bytes": 100281, + "sha256": "8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14" + }, + { + "path": "examples/source-project/oa.arcadia", + "bytes": 2142, + "sha256": "5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c" + }, + { + "path": "examples/source-project/project.arcadia", + "bytes": 606, + "sha256": "787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d" + }, + { + "path": "examples/source-project/sa/assurance.arcadia", + "bytes": 682, + "sha256": "ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f" + }, + { + "path": "examples/source-project/sa/participants.arcadia", + "bytes": 1231, + "sha256": "1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88" + }, + { + "path": "examples/source-project/sa/reporting.arcadia", + "bytes": 2839, + "sha256": "f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058" + }, + { + "path": "examples/source-project/views.arcadia", + "bytes": 3508, + "sha256": "e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f" + }, + { + "path": "examples/text-first/README.md", + "bytes": 1367, + "sha256": "4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e" + }, + { + "path": "examples/text-first/project.arcadia", + "bytes": 480, + "sha256": "f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a" + }, + { + "path": "harness/fixtures/basic-editing/README.md", + "bytes": 12012, + "sha256": "3545d9695e7c62e0caa818efd7f4dc426f04876a3626e0f3b1bad606b258cb26" + }, + { + "path": "harness/fixtures/basic-editing/base/expected-baseline.json", + "bytes": 4524, + "sha256": "f239e728d650b0af32bb8f3dcaf6b27c99b9c5041132ac14e51756ea6563d978" + }, + { + "path": "harness/fixtures/basic-editing/base/project.arcadia", + "bytes": 3077, + "sha256": "045cb047d7bfbca72c3fb30db4c81a30ad463d3af7fc51604906ad7fa75a1ff8" + }, + { + "path": "harness/fixtures/basic-editing/base/rationale.arcadia", + "bytes": 57, + "sha256": "c01867c9dc0d40726853119fac3c6ad24a40d8d362a93a8b9d20df04ec2e273f" + }, + { + "path": "harness/fixtures/basic-editing/manifest.json", + "bytes": 447, + "sha256": "d23c21b02064ddb85e051e10e16ff089daba8d9910bb1a695dfabe2db3757734" + }, + { + "path": "harness/fixtures/behavior-creation/README.md", + "bytes": 5954, + "sha256": "9e5fc751424d12cfe76a84abb1da45b2d38947409179451bb90ffe7e7ddc8723" + }, + { + "path": "harness/fixtures/interface-operation-probe/README.md", + "bytes": 2604, + "sha256": "088f0bdb3375deb8f2c7e3b749ca8d210ea828ca4dece69b3871b674e3110175" + }, + { + "path": "harness/fixtures/interface-operation-probe/hashes.json", + "bytes": 977, + "sha256": "f6d3e8aa42f40f64ce2ecba7b9cf112eb9091f3cccde3a592b0434e834cf2a6a" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/after-reset-deletion.arcadia", + "bytes": 4218, + "sha256": "c0fe9570684c0061efc4cad65e339fede6961b04ca90c6f324c787bd65e61226" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/after-reset-deletion.json", + "bytes": 7835, + "sha256": "93187f7a1b476a44185725c6b15f2e1767482b6911ab1280144348d033eb51f0" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/boundary-only.arcadia", + "bytes": 4771, + "sha256": "02f85e39957ebe6d56336fa729a5c8b10f51865face9d3b2c9679200571fcfc7" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/boundary-only.json", + "bytes": 8840, + "sha256": "756f9710336e6734ce3592ca774c6f104bba5a37c9e165540eb39326682393d1" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.arcadia", + "bytes": 8635, + "sha256": "ac5b629ba5596464f9f8a975b8bc2764e3007ceb7342de3f828d4b18e4f069b7" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.json", + "bytes": 16160, + "sha256": "78a47c978dc667aa1c45af711f06aa2a0d3c581003013e30c3e02fb0faae2e64" + }, + { + "path": "harness/fixtures/interface-operation-probe/probe.rs", + "bytes": 11274, + "sha256": "72b1b443e25eb20420dec4477b0fb5ef5d1c705e3882c81df88dd578ab96a426" + }, + { + "path": "harness/fixtures/release1-native/README.md", + "bytes": 2564, + "sha256": "5f5ba040fd2df9261a29bcab3f9a7ae27c3683265411ad3dda0b467d5df8590e" + }, + { + "path": "harness/fixtures/release1-native/artifacts/README.md", + "bytes": 4155, + "sha256": "24200c84ccc2ef3e17c029744074e5cea785188f5549ac54e44cf89682643f81" + }, + { + "path": "harness/fixtures/release1-native/artifacts/generate-semantic-artifacts.rs", + "bytes": 9275, + "sha256": "444f360b78df52c5e42046f77b148781e0c9bddc2a09c0b7bd65c7a4f376cfe6" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.arcadia", + "bytes": 7768, + "sha256": "84b22e95c213018612e6e8a84cad68b35a8b495ff3515b0f978c5e7a3d196d79" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.json", + "bytes": 7330, + "sha256": "13a6f99ec2df1dd35ee8b2613f183918cd9537eda4a5da085ad52e65c033db59" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.arcadia", + "bytes": 1446, + "sha256": "1e0d662ba33071b122ad9206d2d559a8e748c9431eb3ac1b759bde3760ca877c" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.json", + "bytes": 2216, + "sha256": "fa6a2e3643c0f909b92407abec3edc897033162eeaa501f8d4616f79d41fa044" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.manifest.json", + "bytes": 567, + "sha256": "65cb70b0d697a055363ba01bf30bed7e412d43c9978a033549c378d117719ae7" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.request.json", + "bytes": 3991, + "sha256": "ed905267263e7f8a0cd2dbe833196b30118b6a246815216932fae661ad650699" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.arcadia", + "bytes": 6837, + "sha256": "e50fc462ec22dbf98011929931dd2489430001c3e6433608685b9d88bceb9acb" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.json", + "bytes": 6433, + "sha256": "f27a7b38d59c7cefe58cb36783d3d4dd8d8ae1168d9aed1eb61d343c18758908" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.arcadia", + "bytes": 1807, + "sha256": "eba2aec39e6efb405eace4bc8ab0c5563907c26d449e71a4aa750df9f73233b4" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.json", + "bytes": 2673, + "sha256": "2ef777f19b94f08b5e5ca2ef727777897e1018f1426eee291408b3c69101f596" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.manifest.json", + "bytes": 519, + "sha256": "3af7232ed3056ca84dcaf0f266ead3faaa512a0dc0051c7ba68791c20dbae0cf" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.request.json", + "bytes": 1246, + "sha256": "8af21b00b62e620256fbf50e47c6c5836cdb6922d9549cc4b3d86bc03b008073" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.arcadia", + "bytes": 4200, + "sha256": "20bb30473830e44228958e78fb7480269cdcc0580c6c90c718da75f34ca5a43f" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.json", + "bytes": 4552, + "sha256": "44f4b05db49758dcf344788f57cecc0250fd029099b1c54e4e1e3e972f6cf039" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.arcadia", + "bytes": 1808, + "sha256": "b0fd031671c9f755756922ec5c40a0ce3f40164d22c3c389aec9fd0705344da7" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.json", + "bytes": 2673, + "sha256": "1acf81e08c51c85aceb14a3efbc39ec680552a19c7824aab4611ac3cf71b9c6d" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.manifest.json", + "bytes": 610, + "sha256": "a07978f4b0a3ca83e5ae5f35e7b66b26473b24431fc90e5889d755f1816d52dd" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.request.json", + "bytes": 2352, + "sha256": "5ff844a038b0030adb5a83d13d81e60f30627543388f6199b6a0e026fc42ea58" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-native.md", + "bytes": 4075, + "sha256": "a51ffbc45b6c172cbfed3b16c249296e6a28d457fea57393dd958cdcfbafbca1" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts.hashes.json", + "bytes": 2367, + "sha256": "3ad8b7428b3ed7585a91e7f5d9d5f4880caccfd0b08dca25d05af523e62e0a10" + }, + { + "path": "harness/fixtures/release1-native/communication-means/README.md", + "bytes": 15091, + "sha256": "015c16010c212af283f9def118c6d263ba65a3bc6e81a750f180624ca69bb311" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/entry.arcadia", + "bytes": 6098, + "sha256": "a6976e7c21031e7cc3cb731e20c3075cf89cf85144dc8d3f52930f8521ea196f" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/expected.json", + "bytes": 10480, + "sha256": "60c4419415c546f06c9972ac7bb0e530ada7b30a200b59e75ddda231a24f9a3d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/traceability.arcadia", + "bytes": 407, + "sha256": "3c41459f2b0706a767988738bf8126f76540415bb5940d9c5db19cbe8c18182d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.request.json", + "bytes": 1331, + "sha256": "b16e673b29c96b5aed681389ff7669110abe552939e86dd0ec6011c9a45ed860" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-draw.arcadia", + "bytes": 5239, + "sha256": "a511a4d817d9c5c80233bce83e84a7056b7dce7afd9fcc25696e333f8f4df055" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-draw.json", + "bytes": 8424, + "sha256": "7140114926228b1c378c450535f7a70992c71a879a8d2270c49e8d5f04a2f484" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/entry.arcadia", + "bytes": 5710, + "sha256": "910e6dfe609467047ce629ec9c626f4e927cada74bfbfa164414a8fe6783ea87" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/expected.json", + "bytes": 9868, + "sha256": "567259e20c9f6278776e8fa99b8b2fdbbc9a883ad875c5d39dae1b53de3a2924" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/traceability.arcadia", + "bytes": 407, + "sha256": "997f72fe9258012df66e88344cf39c1a2cebf2327f604056b67f7f2a8ebcfbfa" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.request.json", + "bytes": 1127, + "sha256": "cb3fe05859cfffec6f8846c19983dc462413bc0ea4f6e19204f09c259919c4b1" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/cm-reverse-scenario.arcadia", + "bytes": 8209, + "sha256": "ec826b9b84616507490ac30e4d57100dd6338dba2f7071e879a8fb58820a85c5" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/expected.json", + "bytes": 19735, + "sha256": "ef07e4d2d3fc36004ff01739838281581d9a703c747611eacc01bb9cc672489f" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/oa/behavior/scenario_oa_cm_200.arcadia", + "bytes": 1488, + "sha256": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/request.json", + "bytes": 1090, + "sha256": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/traceability.arcadia", + "bytes": 2068, + "sha256": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/entry.arcadia", + "bytes": 9827, + "sha256": "86dd8a355f6c9dadfea56d06e5247c9b0f820819d7df17ef5690671c7c81324b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/expected.json", + "bytes": 21877, + "sha256": "980489ec2c483d4f9efada61358c1f29bafb2572fd5b804c656b91b8e9bb4f9a" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/oa/behavior/scenario_oa_cm_200.arcadia", + "bytes": 1488, + "sha256": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/traceability.arcadia", + "bytes": 2068, + "sha256": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.arcadia", + "bytes": 7698, + "sha256": "1abc4c4cac37cfb06ed3b12a115f9e7e6a2d3affd34b25c355309e5ee465fa40" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.json", + "bytes": 13130, + "sha256": "a5cf4cb2ef390113dd752f4054d43fb789da2ca77799efb5782805ae8aa2dfd5" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.request.json", + "bytes": 1090, + "sha256": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-transition-ready.arcadia", + "bytes": 5454, + "sha256": "b761c4c2af5f7064aaf1f887ffd6094eb6ae834b2c8057ecdbc4aa97c042066b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-transition-ready.json", + "bytes": 8852, + "sha256": "2536b000de361fb131787e32b466b9123d4e98abf00c099ad32f6cb8e7fb530b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/generate-communication-means.rs", + "bytes": 28035, + "sha256": "003521404b702332082e01f2be7676fda1dd7b5bcf220bb81d25120c8984c75d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/hashes.json", + "bytes": 3133, + "sha256": "39b4dc02fc8b074015c59354fd1c1061c25832fde25065c7151f36eb0455e6f6" + }, + { + "path": "harness/fixtures/release1-native/communication-means/manifest.json", + "bytes": 1237, + "sha256": "fb921f42f2c4a4f8a67d1266f17f8c7750b6a2619554b713aa92b17918f0c43e" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40-oracle.json", + "bytes": 26264, + "sha256": "74edca148583f42c269e51f135662f65ef1c9ea1c94516d63e2a5091967dc99b" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40.arcadia", + "bytes": 28947, + "sha256": "00b87736b82c5afd33b311df7aebe9a6c8c51b6de66221181b5ea8bc8ca221a3" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40.json", + "bytes": 54938, + "sha256": "5dd4f22453330cab3abc059881660190e689a22619853f77cf6d0b52735d97ad" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments-native.md", + "bytes": 2624, + "sha256": "28906924b05f75bbf432389517aef65f1df474d2f2bff79a3586564f7f7328ef" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.after.arcadia", + "bytes": 6795, + "sha256": "9d084dd75a0251d349cc31f9ee98df58d0bc76859dc3cb1503f242e2f759888a" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.after.json", + "bytes": 9618, + "sha256": "f09be41afd85c18fd52fdf997e9b81c4b7cb2c41e78d167abcd14caea8110333" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.arcadia", + "bytes": 4990, + "sha256": "8740f27be99624013d9be876639c0411e1b8c14f0f9a843f43dc71d769efd79a" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.hashes.json", + "bytes": 963, + "sha256": "00fc9e2c709bdcd9ee98012176cb0edb635c112153d963cd169bf4bf69a9e010" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.json", + "bytes": 8146, + "sha256": "9c188f2890630c7feec2be719a7104af9690da7ea836df18fa78da3ff2acfc1b" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.manifest.json", + "bytes": 1045, + "sha256": "46b40f221ffad614733b615208814ace63947e96b80bbfdec63853ccd4f4e8c8" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.request.json", + "bytes": 3075, + "sha256": "b57f656f0b9cf2c595e83150c683301909e20f15684d35d108d3c57ee0dc5909" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch-native.md", + "bytes": 2637, + "sha256": "dddca2b85f892b05881c75ef3cd62437396cc086a09909b621e02bad0cbe56ff" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.after.arcadia", + "bytes": 3134, + "sha256": "d3315bba762395205ae761e6e64029e8b4070c15a1299c6114075581db7b0974" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.after.json", + "bytes": 3927, + "sha256": "8f36119c7e893a4af374b13b85b1c2cb3df0196df8d06a551386628fc8b8646d" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.arcadia", + "bytes": 1787, + "sha256": "5e1f433e04621424edac43e53411624059e873f88dd531bfdb39093953485ed7" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.hashes.json", + "bytes": 933, + "sha256": "1bd87700b04e4f169ab5f8aceaa3b0c3ec3a1cc43e1bce135a1cee506fc75d38" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.json", + "bytes": 2816, + "sha256": "1972242d2a8677d004dc3af1081feb292de65fe26128d877dded8661f9906619" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.manifest.json", + "bytes": 647, + "sha256": "1e440efa02e2ccc27585d9a49c7864d53e3e3e7645ccb219f040e00d95331b8e" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.request.json", + "bytes": 2197, + "sha256": "71f23474614aab90398ce24f00f2cf61d6cb9a3a34faa3e12e0c8104e0a71073" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-repair.arcadia", + "bytes": 15635, + "sha256": "e3ce0347746584f503b825a8b6bd23a7eebf0827940112ef8f36d500c1d0a043" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-repair.json", + "bytes": 25736, + "sha256": "29736f2a619f7f2d0e795229f6e8c3645a1b4eca6292043cd604aa01b1ec9170" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-take.arcadia", + "bytes": 15631, + "sha256": "9ab573c92be66e3bae659dd826923ba6066979b1651edda7bd469056632cd77e" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-take.json", + "bytes": 25736, + "sha256": "828c990c6129692cd31c7f6ed0dd6c952f9cfffdd90bc80171df82d4d929afba" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.arcadia", + "bytes": 15617, + "sha256": "49214be2ca9c8bb6195c3b39737c053847021839f70f0bb2921d35a1fbd2ac83" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.invalid-request.json", + "bytes": 2225, + "sha256": "8b02d4739b1be2c8a64da76423b4a6cae7d89c60f4d30723b94f1da3779cbcca" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.invalid.txt", + "bytes": 78, + "sha256": "aa536e18bc65325163e9b645a4ad031ab599fcb05948dcf741b725d0f0c8b602" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.json", + "bytes": 25722, + "sha256": "995dd72f5c1f07f998233ae9847e337cb82de0c2a9053d3905be021d5f8124b9" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.manifest.json", + "bytes": 1059, + "sha256": "ad315359bfd68ce0d265976dc9e4ea6a502ebbb87d7339dd1af5ef27dd01e433" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.repair-plan.json", + "bytes": 15016, + "sha256": "27bf316ad66ffa91f6323e75b0c280baf5caec298645793dea72c5d42aa3b782" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.repair-request.json", + "bytes": 2225, + "sha256": "f4f6b5480ec8927033ea469ea82c1e8411cb6dba95d2da680f15bc193914c9b4" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.steps.md", + "bytes": 3897, + "sha256": "7d7e38d93641a5f22a2738baa4dbacc392eebb477a855cdce0641961980a19ad" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.take-plan.json", + "bytes": 18557, + "sha256": "74dd68ba686b8928054480f0bfed55aad91f6f1208803399dc9878e894f57ecb" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.take-request.json", + "bytes": 1508, + "sha256": "d19a53002a6bf95af3123a3ef9f78baaf7ce1085d4f06f0f4a9d5e5d5accbc0e" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.arcadia", + "bytes": 6935, + "sha256": "90277f1780d43a6f0b2184bf00b87e7a4f3518d67c6f10d4793daafe1aabf493" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.json", + "bytes": 11286, + "sha256": "5a3c8494f6976c23b990c14b40760fb2f32ca9973caf6f31dab5632310663591" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous-request.json", + "bytes": 1379, + "sha256": "6a86fde194faa55f2d1bdb982571e0e711e5401b53a960e6acb8cf3e17f506c8" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.arcadia", + "bytes": 6195, + "sha256": "e7c30c5a5c3ba7209c8e223f02da55821d7af10a2f09844a7065ae6cd8f22aa5" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-plan.json", + "bytes": 19156, + "sha256": "d1e5c2ed08e0aa6274a0421a39876d1ba99f4e441c7a0a68660a83b9e017da14" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-request.json", + "bytes": 2418, + "sha256": "433f723252598994dac7184da61f95344b528156cc5a0fba1a7864b2ec9f002b" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.json", + "bytes": 10441, + "sha256": "9e4e2ce1c7879935ad0860a3ae720506c929a8422b51491b719d88af3fd3ff2d" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.manifest.json", + "bytes": 1042, + "sha256": "87e8899c7d4e54faedeef32afb7592fb65278d1bd7390850ab198dcf62068329" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.arcadia", + "bytes": 6280, + "sha256": "6c77ed42bbf9f4ebe08bfa233197a4020e5587ce33747f7914430aa0c662d9a3" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.json", + "bytes": 10009, + "sha256": "1dd7ca2bcfc84ac23369c506302b39569d2ebc41e5a4edc99378a1fe01923b7e" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous-request.json", + "bytes": 1390, + "sha256": "e0ea7aeb25687ae63c65128f1aab78273f14030d179d3fbea63fe91ab5430136" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.arcadia", + "bytes": 5529, + "sha256": "563c36162050c8564ffa25a85c726462ecdaebdb87659b3f3610506bfd5581e6" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.final-plan.json", + "bytes": 18821, + "sha256": "f96c43fc58dbe48a044b628b31bb3f0b59171dad5b6982ec6c34a5597e474130" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.final-request.json", + "bytes": 2438, + "sha256": "d38fdb13612b07254edad80848f79c1e097d5f868c020feae9ba072aa697a50d" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.json", + "bytes": 9153, + "sha256": "2ed0daed118f2df13dcad738dab174ad34d44a15921cf8097415e707978b0968" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.manifest.json", + "bytes": 1058, + "sha256": "c79bd12a85d8d4f25cc3ee43581b3e5e74ae9ad7e4de0c72764975ba2b89c279" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.arcadia", + "bytes": 5026, + "sha256": "98020e048ac01f285c6ad8c10ce22bef05e193b5ba0f5558be1fb26a7bf82620" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.json", + "bytes": 7851, + "sha256": "ea3783992488bc6ee944eb91a26ccf3dbc05a3909528fc32ec8023a76765cee6" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous-request.json", + "bytes": 1379, + "sha256": "ea3cfd25f7a50481805956fb88ab851516dcd602dd6564502a0cc55f7de6a54f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.arcadia", + "bytes": 4295, + "sha256": "2b7c3694623bbea3e36dcc6f674d4adcd91e23c8e1005ded21e5a69648a048e5" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.final-plan.json", + "bytes": 17912, + "sha256": "95a23bd334cffcaef0c3b1012b7555efd2a077ef6f9140d58020910ef8a76723" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.final-request.json", + "bytes": 2081, + "sha256": "1e2433ed5821bf65443f56cb27381ee935db81b1955d3a539b7952898312a410" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.json", + "bytes": 7012, + "sha256": "0033f8780c2ba69779b811bca792340c25a092f887e5811c6839f0a691d744f2" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.manifest.json", + "bytes": 1046, + "sha256": "e3b4a60a56abee779ca8356605c968aa2d99256a3bd3c5601b14b5c5502a1a05" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.arcadia", + "bytes": 5467, + "sha256": "e265cab35097acc46f5123107c13bc35b9f71931ff650557fc1c85779141b327" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.json", + "bytes": 8482, + "sha256": "9b777828d3681138de6bbd08de8bf922bed92c27be60b103d8ff73ce7ddd0a48" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous-request.json", + "bytes": 1379, + "sha256": "7d124256730bf2feee772c7d0118b87eb288e8aaa9179d69ceb9259dbceb2c71" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.arcadia", + "bytes": 4727, + "sha256": "87a5a3665dab2dd6e595867dcebb1586e93dd067c85d6e24b1a4d3ff0ad6d4ba" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.final-plan.json", + "bytes": 18803, + "sha256": "1888ca51e0923866a9afea99cad069fe5d3f19f0a1b24328e20ac1b9f52d8bad" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.final-request.json", + "bytes": 2294, + "sha256": "5070a5b85feb1bc7b1fc648cd5d35ef26663492c8666dcd471950c06ec3a6052" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.json", + "bytes": 7641, + "sha256": "725b35e36640c81c70c7efea5c3304bf61b49ef9664194ca0d491782cc62191a" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.manifest.json", + "bytes": 1038, + "sha256": "1b43abf8fed3061c65a7b7cb103d31ea7ece333a2da83c645f8d228448c4dbb2" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.after-order.arcadia", + "bytes": 5019, + "sha256": "65a6217f474b5085f37b511151185c2c08ff7a1998e924f1fe01f29c410f6ced" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.after-order.json", + "bytes": 7835, + "sha256": "8a53bb9b43eab5b6dca5e08deef20c14c96e134b9ee816a99b7960bb5255e008" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.ambiguous-request.json", + "bytes": 1379, + "sha256": "c704f99245f00d5c3be0562d91931b4e7f1fb3fb36f41991eb76656ffbd6129f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.arcadia", + "bytes": 4279, + "sha256": "c59ec1233d5a9fbb8e386f6d9b13f398be21baf813ba215efb51bfc1bb98db36" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.final-plan.json", + "bytes": 17938, + "sha256": "30c5c3f614a74708763df612016483623792f4c65e2ed2fa662ac417cfb852eb" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.final-request.json", + "bytes": 2098, + "sha256": "3b6c35ef78133f0980cb6fb53fbc29c5d3c4deb5dc4be01c2c3384e221987b9b" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.json", + "bytes": 6996, + "sha256": "c159c60403abcf8fefab7f19cbad9989488e8ccc20b82c57597b22a0ae254802" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.manifest.json", + "bytes": 1038, + "sha256": "af8a314a9b1d85a8f98affa5a6649f43d252851158798e1ad687bb1b6966b14f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.steps.md", + "bytes": 4549, + "sha256": "6004894e9d9f478b7fe1c3c3e0706dcc546d5df8557cff91b4cf26f8a4badf24" + }, + { + "path": "harness/fixtures/release1-native/source5-recovery/15000000-0000-4000-8000-000000000010.json", + "bytes": 1933, + "sha256": "71cca2a59f36b2a07d11dedbe9101226aa1a4a00d8ac244b5565202e56709f51" + }, + { + "path": "harness/fixtures/release1-native/source5-recovery/generate.py", + "bytes": 1496, + "sha256": "e44986c1d563499f25917441220b23883fc9cb0f89faf409873191f0212fbd2f" + }, + { + "path": "harness/fixtures/release1-native/state-actions.arcadia", + "bytes": 6224, + "sha256": "9cde82608110e56aa9e14c9e33eb38976f53aed74ab013145d411d5743a0ec26" + }, + { + "path": "harness/fixtures/rest-coverage/README.md", + "bytes": 1870, + "sha256": "df4a391312e0c8b20ccdcc850199443b08547be1b10b1f2447a067bf4bf544e6" + }, + { + "path": "harness/fixtures/rest-coverage/coverage-probe.json", + "bytes": 7951, + "sha256": "2d1ef7bdb5d7bf17b9fda33b1d1790d1d88289b3fd1e725f89b83a69771f9a43" + }, + { + "path": "harness/fixtures/rest-coverage/run-coverage-probe.ps1", + "bytes": 9381, + "sha256": "f24f19fca418b76a7249894a08c116e16b465a02f8f899d12b808ccfdd90a3bd" + }, + { + "path": "harness/fixtures/run-timed-bundle-oracle.ps1", + "bytes": 7466, + "sha256": "fab696486a574f9867c6e69a8a8b960e7e9722206441b9cc5f36d41f285f1a25" + }, + { + "path": "harness/fixtures/scenario-authoring/README.md", + "bytes": 14700, + "sha256": "6b651b180b76d10b00bc49d77a8f5e0b3ba0317446978f41b541f5bb23fedad8" + }, + { + "path": "harness/fixtures/scenario-authoring/base/expected-baseline.json", + "bytes": 38589, + "sha256": "abd8246c939ebb8a2162ef82e23d0fb322ee1a8b4d0d7c28a34037e42e86e841" + }, + { + "path": "harness/fixtures/scenario-authoring/base/project.arcadia", + "bytes": 19470, + "sha256": "9b1afbe96b0bf8fa613451b00929492f05a59b9eb2ca74c2c374a8b7bb7cba9e" + }, + { + "path": "harness/fixtures/scenario-authoring/base/rationale.arcadia", + "bytes": 86, + "sha256": "82df210f22f6aa336a3e7e00240977d671c7c3923db7bc58fb29e6d98b67ef49" + }, + { + "path": "harness/fixtures/source7-native/README.md", + "bytes": 7235, + "sha256": "7abccbc3da0980d1d099761d1a66d12c403a0f543954134537ecd4930d182b4b" + }, + { + "path": "harness/fixtures/source7-native/base/expected-baseline.json", + "bytes": 26428, + "sha256": "e2882a58f841f460f45d9d67db1606440e0d7997b9b29a784569ae48e4b23bfb" + }, + { + "path": "harness/fixtures/source7-native/base/project.arcadia", + "bytes": 13616, + "sha256": "5474d8ca05fd1375220dc0ad40d913631fde51159e9632bb9f290d1ecdab8dd7" + }, + { + "path": "harness/fixtures/source7-native/base/rationale.arcadia", + "bytes": 59, + "sha256": "e6a600e13036d4ad594a65380ed1b3d82d1772d583041bb0a624c9588a73047a" + }, + { + "path": "harness/fixtures/source7-native/manifest.json", + "bytes": 410, + "sha256": "6c57164a796234d83818d462d0a25f10e77062d405769e602ae2a7bec251e3b6" + }, + { + "path": "harness/fixtures/staged-source-authoring/README.md", + "bytes": 6876, + "sha256": "502be5e3bf9112447dc07b1a51fe0fa301754b47128a9b81877c185c6e797fee" + }, + { + "path": "harness/fixtures/staged-source-authoring/base/notes.arcadia", + "bytes": 63, + "sha256": "ad9de02963c20d1f43856455a797deb05ca674659e45f2c4b96b52783024f8bd" + }, + { + "path": "harness/fixtures/staged-source-authoring/base/project.arcadia", + "bytes": 593, + "sha256": "aa844950ec4fb86f262a257e1fc370a26557ea7978d8a4cab78265037660234c" + }, + { + "path": "rust-toolchain.toml", + "bytes": 66, + "sha256": "a6a0bbd29ffaa8182dc22d1d9149709f1091e47df40ed96eb8a78a711c66a4ce" + } + ] +} diff --git a/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.log b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.log new file mode 100644 index 00000000..3d80bc50 --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.log @@ -0,0 +1,26 @@ + Checking oa-desktop v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\crates\oa-desktop) +error: variant `Focus` is never constructed + --> crates\oa-desktop\src\behavior\scenario.rs:133:5 + | +126 | pub enum CanvasEvent { + | ----------- variant in this enum +... +133 | Focus(Context), + | ^^^^^ + | + = note: `CanvasEvent` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis + = note: `-D dead-code` implied by `-D warnings` + = help: to override `-D warnings` add `#[expect(dead_code)]` or `#[allow(dead_code)]` + +error: variant `Focus` is never constructed + --> crates\oa-desktop\src\behavior\topology\direct.rs:65:5 + | +29 | pub enum CanvasEvent { + | ----------- variant in this enum +... +65 | Focus(Context), + | ^^^^^ + | + = note: `CanvasEvent` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis + +error: could not compile `oa-desktop` (bin "arcadia-studio") due to 2 previous errors diff --git a/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.result.json b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.result.json new file mode 100644 index 00000000..b1502265 --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/clippy-e2c027e.result.json @@ -0,0 +1,19 @@ +{ + "source": "e2c027e54c6be0d051820374f669c52278d90f97", + "start": "2026-09-12T14:20:12.264374+00:00", + "end": "2026-09-12T21:53:39.024944+00:00", + "exit": 101, + "command": [ + "cargo", + "clippy", + "--locked", + "-p", + "oa-desktop", + "--all-targets", + "--", + "-D", + "warnings" + ], + "inputs": "clippy-e2c027e.inputs.json", + "changed_inputs": [] +} diff --git a/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.inputs.json b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.inputs.json new file mode 100644 index 00000000..0a1158d8 --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.inputs.json @@ -0,0 +1,2660 @@ +{ + "source": "24bb24839b14353c1a2b668f3bac34235d39f7a7", + "inputs": [ + { + "path": "Cargo.lock", + "bytes": 119973, + "sha256": "065c23c94908fe499d32ed91d55a70946ed5b08ecfda3b483ec1e635572257bf" + }, + { + "path": "Cargo.toml", + "bytes": 400, + "sha256": "369f5b4b2b60705a94623c8c0b68f8e0b048f263280ce07ae0629ad353797d62" + }, + { + "path": "build/windows.manifest", + "bytes": 354, + "sha256": "9c19c5a02f858ece84c44839ad2b145d9c1d90442da0b15c87fd045f975974eb" + }, + { + "path": "build/windows.rc", + "bytes": 24, + "sha256": "a27385edcae0bcf96f55361056cb7be5f36d76fcddcaefd20647c91959563e1e" + }, + { + "path": "build/windows_manifest.rs", + "bytes": 1460, + "sha256": "168da2c42ecccfebc11ee3e1b455e653a68fe9c6d30a9842a8b9e7441d086c80" + }, + { + "path": "crates/oa-cli/Cargo.toml", + "bytes": 279, + "sha256": "49c567f1af74a826683b4d96845feb3806fd9bcb7dc2767e16b5509d4e5e1cde" + }, + { + "path": "crates/oa-cli/src/lib.rs", + "bytes": 15498, + "sha256": "97bebab63b4a611a1d36ad0c20fe452cbe1985fe3a6fbd39c954603da11410fc" + }, + { + "path": "crates/oa-cli/src/main.rs", + "bytes": 2984, + "sha256": "de964f9b6c59c0f31c080afbd3b31d442b07b1b44f6a187a248d3409c45d35fb" + }, + { + "path": "crates/oa-cli/tests/source_cli.rs", + "bytes": 16600, + "sha256": "a3a1b856c7a9fd3d80bc8074150a24fbb0ef0e9ddf736c7cea036725fc3dc2b8" + }, + { + "path": "crates/oa-core/Cargo.toml", + "bytes": 408, + "sha256": "6b5c062474ebb62d5082e07dabed99ee85e4a833edf26690fb4f887028d3416f" + }, + { + "path": "crates/oa-core/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-core/examples/generate_demo.rs", + "bytes": 795, + "sha256": "e26f432c95331aeca50985dbb3ad2c558affd43023b585811f0f7bfaa59f6661" + }, + { + "path": "crates/oa-core/examples/generate_release1.rs", + "bytes": 1798, + "sha256": "1d5f11165d74893e4bc18dbf3a2f2111f4026bd89fd06ee7f0bae69e45c4d4b5" + }, + { + "path": "crates/oa-core/examples/release_dense_views.rs", + "bytes": 14664, + "sha256": "a83158488ef9b7394f136c52b1496719be935c4e5bdfe457cab5c9894f5f9412" + }, + { + "path": "crates/oa-core/examples/routing_workshop.rs", + "bytes": 17248, + "sha256": "571307b18b6d4fa04700c5a4d4b0c2154c419e93a21292b2028e7b6f46a2faa7" + }, + { + "path": "crates/oa-core/src/analysis_numeric.rs", + "bytes": 3735, + "sha256": "6c88eef3119162aeb6c07b9e75812c3af9fbfe75554b0503ad00f103cb478408" + }, + { + "path": "crates/oa-core/src/analysis_numeric/dimension.rs", + "bytes": 3045, + "sha256": "d4ad8e5307a1620e31791d724a0e31fdba860d00dc83e3e1f2209d9c5e22a340" + }, + { + "path": "crates/oa-core/src/analysis_numeric/exact.rs", + "bytes": 17338, + "sha256": "4eb8cb0f66b10e5da204899af82ee26adfec74bab47b1a6c9842b5488ee04c4d" + }, + { + "path": "crates/oa-core/src/analysis_numeric/fixtures/r7-literal-boundaries.json", + "bytes": 6085, + "sha256": "3b959dec5e100a6f03817f5314bef497347ba579ebd235476516d4bd83399181" + }, + { + "path": "crates/oa-core/src/analysis_numeric/meter.rs", + "bytes": 7129, + "sha256": "1f7174beb992935b4c399acdef91114af73faf041070feab968455ac827e8ee4" + }, + { + "path": "crates/oa-core/src/analysis_numeric/quantity.rs", + "bytes": 12257, + "sha256": "ead5142d6eeea8f99399d57e02d8f7d819980923de76387cd454694d6a747aee" + }, + { + "path": "crates/oa-core/src/analysis_numeric/tests.rs", + "bytes": 27486, + "sha256": "323ce82fc057d36f44463569fd8ea324c7d700fddfbf32bce15e04bd2a66970b" + }, + { + "path": "crates/oa-core/src/data.rs", + "bytes": 42696, + "sha256": "7f9c7c7dd8353cb5a38597b92cde6d3e890203d392473187eb387d41ff37414a" + }, + { + "path": "crates/oa-core/src/demo.rs", + "bytes": 20657, + "sha256": "ad62123f96c20ff023cafc1a9849b0fa06bc62edd1fb9701799e4599b458600c" + }, + { + "path": "crates/oa-core/src/language.rs", + "bytes": 99938, + "sha256": "638f08a42e9cf4996b5d07f69b4d6f517a518369f3604d25be1006e40e080765" + }, + { + "path": "crates/oa-core/src/language/semantic_source.rs", + "bytes": 7326, + "sha256": "584b5bb59d87a7b8d44d5dd2d124c3a1323b21492b138a17bc9526c0087c9e29" + }, + { + "path": "crates/oa-core/src/language_nesting_tests.rs", + "bytes": 20639, + "sha256": "bd061611e8cb6f28ab203c73e544ac98bf275eb464cd314ad5fbd25f773df33b" + }, + { + "path": "crates/oa-core/src/lib.rs", + "bytes": 549, + "sha256": "ea1d9bf5acba8381ba204db12ff5b5fe1f320417d17af517e46b90fd6bcb241c" + }, + { + "path": "crates/oa-core/src/migration_v2/README.md", + "bytes": 1515, + "sha256": "fb61d3faa33d7bdfba73415415a0882c0fbd3e0b45df42f972a19aec6da927b9" + }, + { + "path": "crates/oa-core/src/migration_v2/adapter.rs", + "bytes": 9490, + "sha256": "66741b4c8354a23b8a932ecc5bf1bc3bb6e74279558757b8c35bc2157a7e51b5" + }, + { + "path": "crates/oa-core/src/migration_v2/mod.rs", + "bytes": 1158, + "sha256": "857d8bb13b6814daba6780ca770c16352943c01cb130245d055f11b3b957b3e9" + }, + { + "path": "crates/oa-core/src/migration_v2/model.rs", + "bytes": 52059, + "sha256": "8ac63eb59b2e57bdecff2477ee0634096090924d3dd1851e1c454880a889dacb" + }, + { + "path": "crates/oa-core/src/migration_v2/references.rs", + "bytes": 13369, + "sha256": "33a6819abc83139fdaebeebd1b553238a328637106cce7dd5a535f1791d43e20" + }, + { + "path": "crates/oa-core/src/migration_v2/source.rs", + "bytes": 21946, + "sha256": "74fee9b24e7c912182c998ab9d9aeec125e2009c3214959229e844c67afe2bf6" + }, + { + "path": "crates/oa-core/src/migration_v2/state_validation.rs", + "bytes": 15769, + "sha256": "e29ef071bab0a68460ddf55c46131c6f66c022d52c3c602c37c013c3649da1b0" + }, + { + "path": "crates/oa-core/src/migration_v2/transitions.rs", + "bytes": 704, + "sha256": "f74174c532ba56b57c80b719a11fb4adea0a78ccc2828fff72fe2b9eda5a10b1" + }, + { + "path": "crates/oa-core/src/migration_v2/validation.rs", + "bytes": 98736, + "sha256": "6d5e4a4e2805ae5045bf789a0485e14a61c63346587bace2b4a91173a688f780" + }, + { + "path": "crates/oa-core/src/migration_v3/README.md", + "bytes": 2128, + "sha256": "3755a63f840d7f0eadf68afa7a9d587877a9468ff982d3610539e8a0bb067a82" + }, + { + "path": "crates/oa-core/src/migration_v3/mod.rs", + "bytes": 23023, + "sha256": "f4edb6a0b50ecfe8670973776d703047b064420cb1f05913129c00fc656b3722" + }, + { + "path": "crates/oa-core/src/migration_v4.rs", + "bytes": 4020, + "sha256": "50c652964f0f309e7f3f54b6ef12c40d42fcecc0490f005995c713df1179af70" + }, + { + "path": "crates/oa-core/src/model.rs", + "bytes": 66352, + "sha256": "4585c895c64c4a183941c92cf047a9e52ff0cbe41971e16e78d229ea9dc101fb" + }, + { + "path": "crates/oa-core/src/operations.rs", + "bytes": 11405, + "sha256": "a5ffbbf54cd440316a106d1188bfb699b57dae59f466edcb33618c333cd19f41" + }, + { + "path": "crates/oa-core/src/persistence.rs", + "bytes": 31774, + "sha256": "1c01474f906a63e552c0d590b272c95821c00a100b3e79e58e67dbbeac341a14" + }, + { + "path": "crates/oa-core/src/ports.rs", + "bytes": 45413, + "sha256": "5cac12eea70a54ebebbd6be77b63ce92e3195325c4bc7d27705c518686cbac80" + }, + { + "path": "crates/oa-core/src/projection.rs", + "bytes": 21374, + "sha256": "69ed12bace2cc5024e151752a174ab14034ac2d05eb741fcf13e9a27521c059b" + }, + { + "path": "crates/oa-core/src/projection/port_layout.rs", + "bytes": 13474, + "sha256": "a08d17d10a58bb8b206dd001b19b91d5aa3a9f743b298a4da57d503223c20079" + }, + { + "path": "crates/oa-core/src/projection/state.rs", + "bytes": 5233, + "sha256": "73a607bac713ec7ff49a509fefb1a53c7686dca93ee241ffc835564d743afb28" + }, + { + "path": "crates/oa-core/src/references.rs", + "bytes": 21957, + "sha256": "93553c234f32da35f1f41a7b83ad81c471c9803efa78ca222cf7de3c2f86c0bb" + }, + { + "path": "crates/oa-core/src/routing.rs", + "bytes": 50309, + "sha256": "c5ebb350ba76f731f5c48d968bfbba4b6ef68ec046eb5893d116c4637ef15080" + }, + { + "path": "crates/oa-core/src/semantic.rs", + "bytes": 540, + "sha256": "f9895dd5b8fb27d10d4cfbb41c3542ef2018365a589b8d5778e5674ae5a1f239" + }, + { + "path": "crates/oa-core/src/semantic/catalog.rs", + "bytes": 49407, + "sha256": "1ff74fcca18084d178681d7ff38ee1ccac632c27c4de0595ba1ceab8067ab3a4" + }, + { + "path": "crates/oa-core/src/semantic/historical.rs", + "bytes": 15271, + "sha256": "eaf3284bf234312698514cdb636bc8348e1b5d746cb16b18df777e77d312abfb" + }, + { + "path": "crates/oa-core/src/semantic/linked.rs", + "bytes": 6035, + "sha256": "6f335b14e809aecfc35defcaf77cb821b080d1506dbc46297912b25af98c07a2" + }, + { + "path": "crates/oa-core/src/semantic/mutate.rs", + "bytes": 22683, + "sha256": "dc2b4c4a6eb156fe468eaa8c85fd37a505c0cd8ea1f226cb69cd01689afd3d9d" + }, + { + "path": "crates/oa-core/src/semantic/review.rs", + "bytes": 51116, + "sha256": "0c157d2c327e72e89cca3b423e71ee73798105c5bb7271439c1a101642c91e3e" + }, + { + "path": "crates/oa-core/src/semantic/types.rs", + "bytes": 10405, + "sha256": "6922fe35089f12fad43ab0ce1c6886d01a3855f90b8e2543e99802ac5e6f1bbb" + }, + { + "path": "crates/oa-core/src/session.rs", + "bytes": 35237, + "sha256": "1eb77b329b2986fc6f5dc0171e77fd860375cdfd8c769a1367b445d6c49ebe00" + }, + { + "path": "crates/oa-core/src/source_files.rs", + "bytes": 74803, + "sha256": "669491dbddb8e8e6556161426dffa1a49ac1c826d31020bff0956d81a4d84683" + }, + { + "path": "crates/oa-core/src/source_project.rs", + "bytes": 61843, + "sha256": "1394370bcc5908873b830c2c11312e6e1611af41f46c4f43ca0a6bcb713bb466" + }, + { + "path": "crates/oa-core/src/source_project/source_migration.rs", + "bytes": 4700, + "sha256": "add463ae85c420f853d324b00a221f0f874164cc3f3ed6bbb07557a9ed7a8c95" + }, + { + "path": "crates/oa-core/src/source_project/source_structure.rs", + "bytes": 20225, + "sha256": "9f1f83315856a7025fe662c0fbb13452f31613224a03663150d6225d1ddc162f" + }, + { + "path": "crates/oa-core/src/state_validation.rs", + "bytes": 15665, + "sha256": "e28d7f74385e2a78763716b34491bd73a00bfeccc085970ceb130627e3faee18" + }, + { + "path": "crates/oa-core/src/topology_context.rs", + "bytes": 13734, + "sha256": "16de69b297de95d93c73808621607833b713af811dd082f0169186ae1e5c3e2d" + }, + { + "path": "crates/oa-core/src/topology_context/analysis.rs", + "bytes": 20036, + "sha256": "dead6194f0aa60cc46045c0e5ee10dbdbb689158c38634dfbbbc45d2ba88ac65" + }, + { + "path": "crates/oa-core/src/topology_context/analysis_tests.rs", + "bytes": 5258, + "sha256": "17839263410815e96fe027d4eba3aae0a9ab3b82b16947e2b29ebe0d09782b56" + }, + { + "path": "crates/oa-core/src/transitions.rs", + "bytes": 51998, + "sha256": "fadd1b07b89cae4117b91abb4f1ac9ea81ff818ef20f2175e76ee8cf21fb708d" + }, + { + "path": "crates/oa-core/src/transitions/communication.rs", + "bytes": 8634, + "sha256": "2b476630a88edd9021b9156ca12a5402e01604095f0d4002afb452671903a028" + }, + { + "path": "crates/oa-core/src/validation.rs", + "bytes": 112792, + "sha256": "7c1b4ae5e4ebba13e99af9158ccde138dfc5e9a7afb580e76fba72d0b64ba74e" + }, + { + "path": "crates/oa-core/src/validation/coverage.rs", + "bytes": 6478, + "sha256": "b08e4b344ecad055714168c83beff7fe29ba4edc53edbffa2eae04e5580a4d5f" + }, + { + "path": "crates/oa-core/src/view_options.rs", + "bytes": 24481, + "sha256": "421ede0a04c593ca1df0e6e0d06fabcfcc8113cdbcfb0adc7f5c8ef4d1724208" + }, + { + "path": "crates/oa-core/src/view_options_tests.rs", + "bytes": 21433, + "sha256": "64aac44de2df42a1012239a3dd75c473daf0c8990b3170b7bf7e78a556080208" + }, + { + "path": "crates/oa-core/tests/communication_boundary_scenarios.rs", + "bytes": 8816, + "sha256": "e1100b8f363910a487d90c73acc7df543dc6d532158c3c63ad11cd3d40d8e12b" + }, + { + "path": "crates/oa-core/tests/communication_means.rs", + "bytes": 18102, + "sha256": "a25f2749180bc6f4beb1445bfad3351eedf0669131a7439b633ab804439e95a4" + }, + { + "path": "crates/oa-core/tests/coverage_diagnostics.rs", + "bytes": 20527, + "sha256": "e2e9c3996daab47f2bd23f5d8c48b4e372af33331152f5fc85b76f06d04fcdf4" + }, + { + "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.arcadia", + "bytes": 29220, + "sha256": "f0df129c1914bfc01d0b047b0cd4b520d8cf0c249ea9ced085de400c0be87ff3" + }, + { + "path": "crates/oa-core/tests/fixtures/v2-coastal-rescue.json", + "bytes": 43990, + "sha256": "3ed53508eb544bbd788832f7bebea2ec31b3d66191f24f45098cc9750ec4c005" + }, + { + "path": "crates/oa-core/tests/fixtures/v3-data-contract.arcadia", + "bytes": 2450, + "sha256": "305f19d1b79f99f8d4cf627ba2e9ca6836bb7959cc0070227815937a699eafea" + }, + { + "path": "crates/oa-core/tests/fixtures/v3-data-contract.json", + "bytes": 8240, + "sha256": "1b41299c53204e6232397d25a58d5bccdbbc16e770c75e8edb55ce36ccfe58a2" + }, + { + "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia", + "bytes": 1222, + "sha256": "5fa53a26a5ad010c8e59eb56d9b2b52003569e66c0377ffb58840590168ad0c1" + }, + { + "path": "crates/oa-core/tests/fixtures/v4-reviewed-prose.json", + "bytes": 1734, + "sha256": "2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47" + }, + { + "path": "crates/oa-core/tests/language.rs", + "bytes": 56482, + "sha256": "77f6cb2a69976bfb5f60b243b71c07fb0edc7505002c1e9e73fcd6ddf6d9496e" + }, + { + "path": "crates/oa-core/tests/port_anchors.rs", + "bytes": 26893, + "sha256": "efbc0fa18733b1aaac501f9785a4c392fc49c05c45a5778d26e9b5dd951ca6fa" + }, + { + "path": "crates/oa-core/tests/port_migration.rs", + "bytes": 15620, + "sha256": "1801c376a5435ac7efb2a8342348b2c7ffef930bba65deca4acb66b06e0483d7" + }, + { + "path": "crates/oa-core/tests/port_source.rs", + "bytes": 4858, + "sha256": "8d2ddaca4045d330f6eda2591561497b858aad53769a823249d0bea4f5916e12" + }, + { + "path": "crates/oa-core/tests/prepared_commands.rs", + "bytes": 9555, + "sha256": "52cab1c668064777412df0a6a3c20d74d579b33794b4b00525b9f151c06eac9b" + }, + { + "path": "crates/oa-core/tests/process_diagnostics.rs", + "bytes": 1104, + "sha256": "1dbbc590239ef7542be4a2bdc9543aaa64d108417b03dd312a0894e364745906" + }, + { + "path": "crates/oa-core/tests/r3_constructor_ack.rs", + "bytes": 24163, + "sha256": "e5c44676ea0aab97f2e091ddac2f4bc4a4a90f5877f7bbf08b61229600944dd0" + }, + { + "path": "crates/oa-core/tests/r3_migration.rs", + "bytes": 6590, + "sha256": "ebd04120f5215b3956fdc79ee78f6e38734c7d13392f1fc28aaba957912265bd" + }, + { + "path": "crates/oa-core/tests/r3_semantic.rs", + "bytes": 77473, + "sha256": "49c3763eaf2131070a7c46cc23a84f917d292d41610b6404510e5607f8890c32" + }, + { + "path": "crates/oa-core/tests/r3_source.rs", + "bytes": 15311, + "sha256": "f31f60659df3c7ef601650d1cff140589d8729f01a3f65a4a6a6c2272f15c408" + }, + { + "path": "crates/oa-core/tests/r6_data.rs", + "bytes": 41437, + "sha256": "5f7ffb3bc73c3c85423623fe56f8680646dc97040327bdbead9d47a37e80f155" + }, + { + "path": "crates/oa-core/tests/r6_migration.rs", + "bytes": 9174, + "sha256": "81519bc1512f5e069432e9a1cdad04c10216d492df01b4b75b02102480ebd6a1" + }, + { + "path": "crates/oa-core/tests/r6_source.rs", + "bytes": 9519, + "sha256": "88a0aa087a7678e2898ff6057538072ca92072190712f05fff08372cc56ebed6" + }, + { + "path": "crates/oa-core/tests/release1_teaching.rs", + "bytes": 10010, + "sha256": "be179290d871125dc97cfd2a3067c7ac89c8a538fdb0afafc5b825bcdfb2bef2" + }, + { + "path": "crates/oa-core/tests/release_capabilities.rs", + "bytes": 19422, + "sha256": "b92cba2a562e78287ddd7dc3e94557848d17faa0c8a102601b50286b9af48a30" + }, + { + "path": "crates/oa-core/tests/release_diagrams.rs", + "bytes": 7689, + "sha256": "cefcc0582d91266d5de6ee5daefcfe41b606ab971ab235b59034a8e1dbc24b7d" + }, + { + "path": "crates/oa-core/tests/release_language_limits.rs", + "bytes": 5204, + "sha256": "8578da4f76bbd2d0e1bfe295ab1259e2162a3fe3d0d2ba8901915d7a40942806" + }, + { + "path": "crates/oa-core/tests/release_ports.rs", + "bytes": 32740, + "sha256": "506e62beab0c7ec0cece83e9e0c1a810fa1f99285c9e1cab0c77f06de55a40e1" + }, + { + "path": "crates/oa-core/tests/release_routing.rs", + "bytes": 23165, + "sha256": "ae168faaba23769b7ca1fd65f217b9db671726e67276eb5a04e5e72b1447a462" + }, + { + "path": "crates/oa-core/tests/release_scenarios.rs", + "bytes": 41067, + "sha256": "0f5d876badeec653fc7b12610a77d867e9a53582e605253deff8d379da21572f" + }, + { + "path": "crates/oa-core/tests/release_states.rs", + "bytes": 26873, + "sha256": "b1a26acee95eaba7f9920f9da738a1e33606552eb078e6d298895daff7e3d811" + }, + { + "path": "crates/oa-core/tests/release_topology.rs", + "bytes": 17643, + "sha256": "c51dbe5aa5a038f9ed830daa02aa67714472179eb7fd6da5ce36dc6931c8b3a9" + }, + { + "path": "crates/oa-core/tests/review_regressions.rs", + "bytes": 21823, + "sha256": "f154e5c88d35e31512e2b07733a1327ea3e2fcfd1ef8eb23066a4e9573f387c1" + }, + { + "path": "crates/oa-core/tests/route_source.rs", + "bytes": 7270, + "sha256": "1a73fdbac0d0ae0e84d8d67b6ad398e11223958f5dca007f73757c91827decfb" + }, + { + "path": "crates/oa-core/tests/routing_geometry.rs", + "bytes": 31890, + "sha256": "2d8eea4a2bba535ed0ea6daabccdaf87b375828c404baa10518c7bd7fd6253d3" + }, + { + "path": "crates/oa-core/tests/routing_labels.rs", + "bytes": 5530, + "sha256": "dff884d799c3c5c9257210248c55767e294e3cb317c605cbd0ddc9600c216eb6" + }, + { + "path": "crates/oa-core/tests/semantic_artifact_absence_oracle.rs", + "bytes": 4640, + "sha256": "d93eaf9667f4221232168bef0fe9f069e5be1b1f23410bda5dd67010b96e5c8a" + }, + { + "path": "crates/oa-core/tests/semantic_attachments_gui_oracle.rs", + "bytes": 14957, + "sha256": "7f526d363ba05e7ac89faf0fead0796e419c34ee204edf44a1b46c78308b0970" + }, + { + "path": "crates/oa-core/tests/source6_view_contract.rs", + "bytes": 14307, + "sha256": "fa566de53946d40bbbd9033edfeed177180c4dc44afa2f2f4667ffdc622eb3bb" + }, + { + "path": "crates/oa-core/tests/source7_contract.rs", + "bytes": 43262, + "sha256": "cad4f1a135ddbd947bdf3c71d1b44f1e438725095ea8c4d893464bc721c2363f" + }, + { + "path": "crates/oa-core/tests/source_files.rs", + "bytes": 13168, + "sha256": "f0429a0b89a443458ea9af7083c1e4e7411417a7e6b47e618bfbb9266dc164f9" + }, + { + "path": "crates/oa-core/tests/source_identity_updates.rs", + "bytes": 5139, + "sha256": "f52aa38b4d317e532c641ad7463472e4b40e802e60052cf0017556ffc63da06c" + }, + { + "path": "crates/oa-core/tests/source_nested_updates.rs", + "bytes": 16892, + "sha256": "9ac3390936c0d250651ea94a1b8faf0adfb680f061ececc56f2a52909b5ba855" + }, + { + "path": "crates/oa-core/tests/source_project.rs", + "bytes": 45910, + "sha256": "cef58adb16aa4d2527ddc0628aec3e26f0b42b4be70014a7e360fafdac13a942" + }, + { + "path": "crates/oa-core/tests/state_diagrams.rs", + "bytes": 23973, + "sha256": "6b02b387a3ae559cb3ad72de24292a5abcb76aaac0adbab5d2aa5211b22cd2e5" + }, + { + "path": "crates/oa-core/tests/workflows.rs", + "bytes": 33426, + "sha256": "bd843dfddbd5724ec08f657571f887496203056fe2fa5864ef50a168a613b89b" + }, + { + "path": "crates/oa-desktop/Cargo.toml", + "bytes": 842, + "sha256": "f3547b2b924d5db6706c0a8e069014b440ff65315d82fc8aced0360af4b3cdc9" + }, + { + "path": "crates/oa-desktop/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-desktop/src/allocation_drag.rs", + "bytes": 29634, + "sha256": "6b93290627a8697dd529ecf12b6e99196a11783afff1ca7aaf75c6e2762f3d94" + }, + { + "path": "crates/oa-desktop/src/allocation_drag/tests.rs", + "bytes": 60311, + "sha256": "13b7d055a516c8a9f0bd13f03abe3b81423bde9d121c51778a129ff485f4f102" + }, + { + "path": "crates/oa-desktop/src/allocation_input.rs", + "bytes": 8391, + "sha256": "c7825c43383e81b7eb1b78bd902950c8a2206e0387d26002a80ddbe4dc2b6c73" + }, + { + "path": "crates/oa-desktop/src/app.rs", + "bytes": 221462, + "sha256": "6e8e12bebf4aa922aab81d0614edac1ffcc7c3a92e372f0f51ee51b7dad656a1" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag.rs", + "bytes": 24452, + "sha256": "218726dcd2e6809cb6f3660f575e586806360456e6b4fac61b9e361b411aeee9" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag_full_tree_tests.rs", + "bytes": 28288, + "sha256": "ff4c3d07f885f242b71160c09e2c457c4a746073fd89030781da306730c5db44" + }, + { + "path": "crates/oa-desktop/src/app/allocation_drag_tests.rs", + "bytes": 42677, + "sha256": "3c6908f8a677921245932252ab38806f16012becbbc082ac11e7871ff7bdeeb4" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring.rs", + "bytes": 27835, + "sha256": "37c7db33e99dd4adcc5a51f09ee4878af94fd32413359890a541690080885f65" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring/palette.rs", + "bytes": 8887, + "sha256": "8f9937cb30b48b83759fd084a8a5990a2daa3920280f1210abe048560241985a" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring/tests.rs", + "bytes": 14565, + "sha256": "174e184f1baf872c3be1cf70d9a7f4bc5569a9623000b3ab0e71e2b82e249cf5" + }, + { + "path": "crates/oa-desktop/src/app/architecture_authoring_tests.rs", + "bytes": 18551, + "sha256": "ba913f7d7cbf586708d65c9f1db25b9b9ed7846f9d2e75a546b4ac69d8d19c6a" + }, + { + "path": "crates/oa-desktop/src/app/behavior_lifecycle_tests.rs", + "bytes": 13672, + "sha256": "f9a0b030faca5deaf3f55d9f5efcafdf1a7cb1a663001aa20a61baba4f92d080" + }, + { + "path": "crates/oa-desktop/src/app/behavior_removal_tests.rs", + "bytes": 23958, + "sha256": "ef09843a7daeb91afab0b76e83c5679351a1635a84a26d80a194dea744ea5874" + }, + { + "path": "crates/oa-desktop/src/app/checkpoints.rs", + "bytes": 29576, + "sha256": "55e5babdcabef767af3bc8be9cc3153b3f5cc0695701b890820ec0225643852e" + }, + { + "path": "crates/oa-desktop/src/app/diagram_focus_tests.rs", + "bytes": 6047, + "sha256": "65f3f841e1295ae4878b3ae2cf45ff64003d42e26e450e9a1de1c36dbd771bd8" + }, + { + "path": "crates/oa-desktop/src/app/diagram_removal.rs", + "bytes": 8778, + "sha256": "addb51604f41d680b06586bb362362ee3c2603a334f33022ce9abc281295ac85" + }, + { + "path": "crates/oa-desktop/src/app/diagram_removal_tests.rs", + "bytes": 45996, + "sha256": "88ecd8240c1621bf08be551cf19c4976ce68d0738d14d5e0e3c17bd3870314e5" + }, + { + "path": "crates/oa-desktop/src/app/diagram_selection_tests.rs", + "bytes": 5582, + "sha256": "4fa507adbc23db3a6eb202d809c695ec0ebd6181356930c4fa7528a9a0c7be57" + }, + { + "path": "crates/oa-desktop/src/app/hosted.rs", + "bytes": 25059, + "sha256": "2f7094c078e1d7cbccd6c0d310afa6c400a7e031f12918bbfce65ba62754e316" + }, + { + "path": "crates/oa-desktop/src/app/hosted/tests.rs", + "bytes": 30344, + "sha256": "fa118f64d04b400ccc01e4e67adaf3541975288882afa265a9e7f092cdbda232" + }, + { + "path": "crates/oa-desktop/src/app/process_canvas.rs", + "bytes": 31677, + "sha256": "7259f093bed5cb7aa00ce39e45204a62c7ce248a00043e912cb3e186b2351365" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring.rs", + "bytes": 11250, + "sha256": "38e033e23e8135032f70117a376a5fe7bc68127c466559a35d7ec200932e3f77" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring/tests.rs", + "bytes": 20067, + "sha256": "b96ddc6bff7f8fde97720e18a92070f891c1340348d2e19c7c9c5a7bda650ce8" + }, + { + "path": "crates/oa-desktop/src/app/reference_authoring/tests/mounted.rs", + "bytes": 32805, + "sha256": "14a4914a1c86e50c395672dab8fe80d7af679a79c9082890b509fad7b7c543d9" + }, + { + "path": "crates/oa-desktop/src/app/repair_save_state_tests.rs", + "bytes": 10745, + "sha256": "5543dcba853bb1513acf824b860249729a6004747e7e320b46efe60ea19e2d83" + }, + { + "path": "crates/oa-desktop/src/app/review_navigation_tests.rs", + "bytes": 7049, + "sha256": "872fa91479dad5436e139ffcaece270323e9f5daeeb7a4d80c2c2534f48bc21b" + }, + { + "path": "crates/oa-desktop/src/app/save_as_tests.rs", + "bytes": 4113, + "sha256": "f8b915793f1a36fd152569c4781a4bdc17f4af404a8ceb373330053413087a1c" + }, + { + "path": "crates/oa-desktop/src/app/state_diagram.rs", + "bytes": 10050, + "sha256": "9ae3d533a20963a2bd1d485d357ac04319f336cd9f4c16305aa2a67d833573a8" + }, + { + "path": "crates/oa-desktop/src/app/state_diagram_tests.rs", + "bytes": 39957, + "sha256": "612e414b1a2cab12cbfd8fce23745559ff27577700694d53af67ad1f2883ee2c" + }, + { + "path": "crates/oa-desktop/src/app/transition_context_tests.rs", + "bytes": 11508, + "sha256": "47002fb025f3a2f8c53871f9509bfe8611a61db6fb0e1b3125eb6e875425cb1d" + }, + { + "path": "crates/oa-desktop/src/app/view_copy_tests.rs", + "bytes": 7846, + "sha256": "296821c51dcde568e7d717039aa26bfc1b56a9074aa16051007bb351b33a4d44" + }, + { + "path": "crates/oa-desktop/src/behavior.rs", + "bytes": 132758, + "sha256": "465d8cfad58f5a35d30cd2856d024e75821dd291d74a04a98132a98c53fd85b5" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace.rs", + "bytes": 7931, + "sha256": "a8fab209b62e2fa1cceb23195502394806e4543de18305ec86da50af8d8fa654" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/control.rs", + "bytes": 7804, + "sha256": "2b8d97b8c0e3ff1b1a2c32187b1d0eb25edf39ba582b5fb3303bc880f674f7ba" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/focus.rs", + "bytes": 8943, + "sha256": "cc58cb3838f546150d22fe4dd83a3ffd52504c279febaeb8d0b4a6a3b8a73950" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/tests.rs", + "bytes": 27121, + "sha256": "573fe3a53929faf427b7b24f9537b44f1726e2963aa299f7e4cd1ca466b9885c" + }, + { + "path": "crates/oa-desktop/src/behavior/canvas_workspace/viewport.rs", + "bytes": 15164, + "sha256": "41ff9c50fa9fb89ab9fdb2d18dadc21585aafa1ee008cfcd1e0b731dce645eaf" + }, + { + "path": "crates/oa-desktop/src/behavior/contextual_source_tests.rs", + "bytes": 49518, + "sha256": "044bd412dc45ffe440b1e251993946942dc3759dcb2d5dfe71bd8d6ef61cbcc7" + }, + { + "path": "crates/oa-desktop/src/behavior/creation.rs", + "bytes": 28978, + "sha256": "33ae9aaf4ba90de9432870cc8e99708ef39e3638ae8283a9253c333785c91299" + }, + { + "path": "crates/oa-desktop/src/behavior/creation/app_tests.rs", + "bytes": 13181, + "sha256": "e9c5bf2b07357b7a2f679ae0d8f6904c1c1461aaeb94fa0db478b54d4641ae3e" + }, + { + "path": "crates/oa-desktop/src/behavior/creation/tests.rs", + "bytes": 22793, + "sha256": "a0d1daf9fb3920f7e6181a9802d84fbe056cbf0043b9e41dba5fdda687d9818a" + }, + { + "path": "crates/oa-desktop/src/behavior/form_session.rs", + "bytes": 3941, + "sha256": "f5027fb3a5a5599a182e7d1a10dba56dd66eb1f23a4ba4c4a1744c9a6a5b6e61" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario.rs", + "bytes": 153353, + "sha256": "fb69e052343aeeba9d5763689d09ada736a67b52bad61ff3c42e2e06b4c96b73" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/focus.rs", + "bytes": 9728, + "sha256": "73a9ea10ad7312086081b8688396a21ab4251c9faecc2df6d984b702f3963533" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/workspace.rs", + "bytes": 25995, + "sha256": "29f3bc14aa19ad110e60baaaea644a53daabc0cfa7c8ca4542e9d5a2c11cb9d0" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario/workspace/tests.rs", + "bytes": 80083, + "sha256": "57649638930e4b47dcbc3f9f6a2f991da4393dbc1ef243bbc09e01d40932f5ba" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_lifecycle.rs", + "bytes": 9324, + "sha256": "758d244c2e8de61f515d540baa4d967275f49720e0253c6c9159eb9acd71c859" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_lifecycle/tests.rs", + "bytes": 15430, + "sha256": "01b576993b329810cd78a859b45ac52c66f5a14549065661dd1308196e0b724d" + }, + { + "path": "crates/oa-desktop/src/behavior/scenario_operation_tests.rs", + "bytes": 10087, + "sha256": "89fb71c690e07eac314f7a5e05862d5c1e2f9c21039673bf22c4ac894d21c977" + }, + { + "path": "crates/oa-desktop/src/behavior/source_draft.rs", + "bytes": 18031, + "sha256": "08190823090bd8b0305809099abadcc0de431175f7044f1d5abdceda52612ee1" + }, + { + "path": "crates/oa-desktop/src/behavior/state_canvas.rs", + "bytes": 96098, + "sha256": "5844d2abf4a3fe3bb07c707865ee3f8303d213b0fe1871765ac468c11e140da7" + }, + { + "path": "crates/oa-desktop/src/behavior/state_edit.rs", + "bytes": 35843, + "sha256": "4e67321ab0cf88e6200061873086841244c4d610ddd5f88d70c69ac0cc6bf270" + }, + { + "path": "crates/oa-desktop/src/behavior/state_menu.rs", + "bytes": 8530, + "sha256": "9d0a3c29516efa79553c559274848f12101330dbf93ffbbefab398cbc1906790" + }, + { + "path": "crates/oa-desktop/src/behavior/state_view.rs", + "bytes": 7158, + "sha256": "464cbd7b17ace86ad5aa3abd0b95a6d517a317cbd924c9267b51f33db13965c9" + }, + { + "path": "crates/oa-desktop/src/behavior/states.rs", + "bytes": 26986, + "sha256": "8986ed9492960e20f1254e9dfe3ff91d79ce9fef66f3bda738f9933278043954" + }, + { + "path": "crates/oa-desktop/src/behavior/topology.rs", + "bytes": 84212, + "sha256": "26e24ad0f781a3304c46299b3bd906917e57fac262e7f52fba4adc80a4358ec5" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/contextual.rs", + "bytes": 28432, + "sha256": "5d0ac5b3e258fc70987a00ede1e603681d99746596f2fcc46ad2b3667d65203a" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/contextual_routing.rs", + "bytes": 16731, + "sha256": "d914b0e82aa8d253fe64be2ef74443d1fd2e6cec26d1cf30620a57646e1d426c" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/direct.rs", + "bytes": 39108, + "sha256": "261e27f50dd1e32687e113ffd29a1cb5ae4421628e0aef3abd17a77ac180597c" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/direct_tests.rs", + "bytes": 51170, + "sha256": "edccfe3ce8b224065a3540aa53c6340f13db0cecd48ecc0a3904cd832a483964" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/layout_tests.rs", + "bytes": 37479, + "sha256": "10f7936b951d1e54ed49840cde0972a3b62fbd051c59bc3696deb4dd365b094d" + }, + { + "path": "crates/oa-desktop/src/behavior/topology/view.rs", + "bytes": 23136, + "sha256": "b2d502c11426bffb8763515f2a56aa4c9f8e203bb36d65eb34f81c123fc406a6" + }, + { + "path": "crates/oa-desktop/src/connection_edit.rs", + "bytes": 5301, + "sha256": "020581e077f82b43c936b623cc51733b02b88428df4e5f25df74b9705819fa37" + }, + { + "path": "crates/oa-desktop/src/connection_tool.rs", + "bytes": 27023, + "sha256": "649da93677d52dae495b0e19bc32f3122ab05a6d84de8402578ff5ce3f6ee1d3" + }, + { + "path": "crates/oa-desktop/src/context_menu.rs", + "bytes": 52955, + "sha256": "629354b34dc232763700251f2695b4d4e53d6251c0b1432ecc0dfe424f7dfeac" + }, + { + "path": "crates/oa-desktop/src/data_values.rs", + "bytes": 23877, + "sha256": "e1deb1cad551f0a9fdef9653aad257cfb36e6d9c0f93b6245061ec3fab8fd365" + }, + { + "path": "crates/oa-desktop/src/data_view.rs", + "bytes": 38871, + "sha256": "158b852be5d3db450aa5cda8b68a35bd96bddce1d8d053a7a23582095c06362d" + }, + { + "path": "crates/oa-desktop/src/diagram.rs", + "bytes": 111242, + "sha256": "e5260a39e19fc3df19bd16898ff1f0abd60ede7584f595c035b5e86a12ecef93" + }, + { + "path": "crates/oa-desktop/src/diagram/focus.rs", + "bytes": 9197, + "sha256": "b88a7c43123b08cf6228d8e32257f6ed7fe361f7278f427ec138e233e1ea6ccf" + }, + { + "path": "crates/oa-desktop/src/diagram/lifecycle_tests.rs", + "bytes": 9342, + "sha256": "03dd13106f3fdd06a26699bfdfba006fad086a0711cad2ba1aeb09a4e8f8656e" + }, + { + "path": "crates/oa-desktop/src/diagram/pointer_tests.rs", + "bytes": 11859, + "sha256": "ae68e091032fe2cf71559ff7e671b3b6d657ee8279330345f0c7a57edfa472ef" + }, + { + "path": "crates/oa-desktop/src/diagram/port_hit_tests.rs", + "bytes": 5650, + "sha256": "c3728f127711cb6d7f80a4670a798808b6e4239dd29c273445de81706ab6f39e" + }, + { + "path": "crates/oa-desktop/src/diagram/port_labels.rs", + "bytes": 13574, + "sha256": "6643f0cbde7a59d4772ae5284a488083e3b81f2fefabc43619d75738f474646f" + }, + { + "path": "crates/oa-desktop/src/diagram/view_options_tests.rs", + "bytes": 2815, + "sha256": "cf0c98a7715558baf17b59f67a80556f98ad30262b4434635e617c6601775433" + }, + { + "path": "crates/oa-desktop/src/diagram/work_drag.rs", + "bytes": 7059, + "sha256": "9757534a7ba47dc0df5d41c8d7366b1d90f3d50b24344580ff3c783667bf66f0" + }, + { + "path": "crates/oa-desktop/src/document.rs", + "bytes": 31807, + "sha256": "7c87280b5b8d112c34865253f8ba0f80d43bc9897771943b15dc7b5608eb17a4" + }, + { + "path": "crates/oa-desktop/src/document_save_as_tests.rs", + "bytes": 5781, + "sha256": "83dc243a25f4e97674ff0d86c794a490cc923e98f1f9fb05bb038f622f11e20b" + }, + { + "path": "crates/oa-desktop/src/explorer.rs", + "bytes": 14764, + "sha256": "fa01c59219564ba9ae5553abc2b6f94e9849f9148d5812ef99b40318fe5dcf9a" + }, + { + "path": "crates/oa-desktop/src/explorer_view.rs", + "bytes": 13773, + "sha256": "a720d7484bcc3a24729332a00e005d1cc6f5f945a9cc3965134e0024dffb581f" + }, + { + "path": "crates/oa-desktop/src/forms.rs", + "bytes": 105544, + "sha256": "ea124f479fcd2d3978ac3cb8eb81fec4a7aae5e4f4414c4bdd54849e954dedf9" + }, + { + "path": "crates/oa-desktop/src/forms/context_fields.rs", + "bytes": 10831, + "sha256": "eaacd474f6500dd344d5a8b63ccb1d1dd86fe2aea78ab708afa8a80d62ce69bf" + }, + { + "path": "crates/oa-desktop/src/forms/data_fields.rs", + "bytes": 49285, + "sha256": "a540a0d451bff56a96b1d28643b2e8c0649f3846350c25c5b154729c0538e77c" + }, + { + "path": "crates/oa-desktop/src/forms/history_fields.rs", + "bytes": 27414, + "sha256": "e7100474cde18bdfe95562bcb3c055f29b4b15aa64788a578194464aebcd046e" + }, + { + "path": "crates/oa-desktop/src/forms/history_fields/tests.rs", + "bytes": 33950, + "sha256": "16d3c308138c063f45986d53c621ad83c7dc2ce853edd31b7204e2939a382df9" + }, + { + "path": "crates/oa-desktop/src/forms/port_fields.rs", + "bytes": 30554, + "sha256": "3fe684d651d5be6203fd9db3979c772913e1af5ac1514e67be386ffd88dc8127" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser.rs", + "bytes": 12130, + "sha256": "b60af363be333af048859e51c28e8c989cb5c95d696cad16c8eec15f78d57a12" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/adapter.rs", + "bytes": 10447, + "sha256": "87ab4bc3bf27fd4b5a458791cf62c7ba8e44e9ebf846d8b851b8b6ffb454cd64" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/tests.rs", + "bytes": 27835, + "sha256": "8e98f8a3fcb814d4a201cc85b3db87a689fd3d2ce487f8a2fe312fc296f93377" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/trigger.rs", + "bytes": 13336, + "sha256": "34d0acecfe6bed193970aa473cc3313984971264b86d7b362a6b84c23d013c0a" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/trigger/focus.rs", + "bytes": 9923, + "sha256": "f1e79f4b03b2f9fd1cdc335054d4ae177dc9e759b6ea3d334b2bcca39b57191b" + }, + { + "path": "crates/oa-desktop/src/forms/reference_chooser/widget.rs", + "bytes": 33804, + "sha256": "d66cc17af7a48bb8598be683f084bb08fa7af7304f9636f0a1bea94c5cf6c727" + }, + { + "path": "crates/oa-desktop/src/forms/view_fields.rs", + "bytes": 24987, + "sha256": "5184d438f0dfd4e29f284ff048e19da73e71be1f24a6e9f123c7e922aecb85fa" + }, + { + "path": "crates/oa-desktop/src/guide.rs", + "bytes": 118111, + "sha256": "c23ac5b587950a8ffd7978a47ffe462898f2a0b795607bc12b6fa637762e7f60" + }, + { + "path": "crates/oa-desktop/src/highlight.rs", + "bytes": 2751, + "sha256": "da7c254fff7052e5fd9ec7469f473b91a819406028d7c304f6e22c4169561600" + }, + { + "path": "crates/oa-desktop/src/home.rs", + "bytes": 17587, + "sha256": "f03c1071334894f586a5a7c86026602a694db3c2faf902822e1dbe5156a859c2" + }, + { + "path": "crates/oa-desktop/src/home/tests.rs", + "bytes": 8167, + "sha256": "3b03ccfc97dfb75954e1e0ed568bb87a632295c07b96cedc05ed381f87b378f3" + }, + { + "path": "crates/oa-desktop/src/hosted/client.rs", + "bytes": 21912, + "sha256": "54b24b4b50f8d87d7c92946ea5a2cff4c98760e70555b3ce3d90be27115e95d4" + }, + { + "path": "crates/oa-desktop/src/hosted/client_tests.rs", + "bytes": 23009, + "sha256": "3ef70907ca75e098d631c41b90badd4cff1e1eb1b3c78e15a9f811c13ba8ffbe" + }, + { + "path": "crates/oa-desktop/src/hosted/mod.rs", + "bytes": 3744, + "sha256": "1b75e11c80fcb38fd20bb3487e3f88729fdac73e471c5ae64da28c249f77c63b" + }, + { + "path": "crates/oa-desktop/src/hosted/view.rs", + "bytes": 9281, + "sha256": "fc0c7b7ce3a5f05c49713df6661067751f81e810af11c614ca265ea9490e6463" + }, + { + "path": "crates/oa-desktop/src/main.rs", + "bytes": 1554, + "sha256": "5228743f361f9239e4584780bfa9b65d36207d0288624e1fb42b721146bcff1c" + }, + { + "path": "crates/oa-desktop/src/model_menu.rs", + "bytes": 36340, + "sha256": "d2f836661f43fa1bc8830b1e51cc736948b3d261796c3fa877df02ae15568c4b" + }, + { + "path": "crates/oa-desktop/src/navigation.rs", + "bytes": 8839, + "sha256": "71355a12e1b4791106426d83fe5ebf0b29bce8e1dc594f0655ab85695469669e" + }, + { + "path": "crates/oa-desktop/src/port_edit.rs", + "bytes": 7809, + "sha256": "70b99f577c4fdeda8780c8dc1ee7b1639fd77aaca06658f06d725139fb3efb6d" + }, + { + "path": "crates/oa-desktop/src/port_preview.rs", + "bytes": 35855, + "sha256": "069487c4ece737d52e8ae4a84dcfb132236aca6799e841c91c8e7244320cf871" + }, + { + "path": "crates/oa-desktop/src/port_workflow.rs", + "bytes": 40582, + "sha256": "ccc15f97c3272145a67bb5857b4faeaf7437561bd61912fa27ab26e8824146a0" + }, + { + "path": "crates/oa-desktop/src/recovery.rs", + "bytes": 21041, + "sha256": "57e22e5fbb0e994e64ae03e69450271fe9f04a951db1670c2a018abe99db4489" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/README.md", + "bytes": 1587, + "sha256": "a90002df1e087d2dac7be26926864243568a0de7c4103e4927435b34178e8016" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/profiles.json", + "bytes": 473, + "sha256": "2c12ae96b50e6da5d60ce2b7fa00204be71dfbe2fd51311fc337a0de6a4332ff" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source5-bundle.json", + "bytes": 80974, + "sha256": "12715995e6f7f35414aea53b3ad720b9b31873ffdeaf4444231db1a5ac3c463e" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source5-model.json", + "bytes": 86191, + "sha256": "5535a706df9ec21715e8b6a5aa6dbd79636ae461450aee61305559016167612b" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source6-bundle.json", + "bytes": 85286, + "sha256": "ea88890a33f47d67dfb06d6dbbcc179058cf28dad76ae7d615c00aaf30dbbbfe" + }, + { + "path": "crates/oa-desktop/src/recovery/fixtures/source6-model.json", + "bytes": 90629, + "sha256": "5bb8db0b6394276666323483f977ac3586f88554c81a148c6d508fca0ef4576f" + }, + { + "path": "crates/oa-desktop/src/recovery/source5.rs", + "bytes": 6956, + "sha256": "0f0a763f0c98c2c908d4c2b95d8a4c042b6a255ee1cc16260e5404669691f642" + }, + { + "path": "crates/oa-desktop/src/recovery/source5_tests.rs", + "bytes": 12146, + "sha256": "cfd17a742f1f27b523fce7cd9309f0a07a30413395f6c58659fb91d02834a7a3" + }, + { + "path": "crates/oa-desktop/src/recovery/source7_tests.rs", + "bytes": 18213, + "sha256": "7ee61de66c75bf949489ba51ddc9677e2b4efc68801cf27909c9b894bfdc9288" + }, + { + "path": "crates/oa-desktop/src/route_edit.rs", + "bytes": 2941, + "sha256": "457ae59c2761a43a8620b4d336a7cf0f54b965997110ecaf968756a88b6b0374" + }, + { + "path": "crates/oa-desktop/src/semantic_review.rs", + "bytes": 3432, + "sha256": "8dd1e93783d63a663c7e56c28775a5c389cfd7a6b562013d6a95c891afa21ed8" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts.rs", + "bytes": 24201, + "sha256": "a79236a8150597ff808597e59cf4f1e9e61c74c4901d9c8cf42d3427bb52a9a8" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_recovery_falsifier_tests.rs", + "bytes": 11034, + "sha256": "3f255d04e4bffa5a467b75e3cbf6f7149aa3269a02f2a89fbaa1db0e5df9ae62" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_tests.rs", + "bytes": 20798, + "sha256": "04d0dd2ac453705185663f705282aa4a3a31433466a5be305764248da1a03c32" + }, + { + "path": "crates/oa-desktop/src/semantic_review/artifacts_view.rs", + "bytes": 6447, + "sha256": "2100ff73565765d8293c84f6ce2d8e566610c1524c50e32ce3c37dc33b6686e4" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments.rs", + "bytes": 18160, + "sha256": "de0ec0c740895b160ff5b847332c087c3f1a48931583464069470cc61315ed59" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments_tests.rs", + "bytes": 29389, + "sha256": "8b26be0324e0f33b1e7cf7af340350df8ed98963002d6da8589ee0e6f6900bea" + }, + { + "path": "crates/oa-desktop/src/semantic_review/attachments_view.rs", + "bytes": 3032, + "sha256": "932f231554d77c7cb119d33bb06b9879db5e12127aed187e67013e77b6458e78" + }, + { + "path": "crates/oa-desktop/src/semantic_review/batch.rs", + "bytes": 34485, + "sha256": "a462eb627ae19348072775cf8e60b17d62f6b682b74cc413906d493fba1f0b3c" + }, + { + "path": "crates/oa-desktop/src/semantic_review/batch_tests.rs", + "bytes": 27546, + "sha256": "b67c4d7dcabac710cf3d30730a8db323180a558a415e2d117c868cdfa4804619" + }, + { + "path": "crates/oa-desktop/src/semantic_review/compose.rs", + "bytes": 27155, + "sha256": "c6adcc9882dde65e9f04f6eda7f0c855c5cbb285cf421123029169112793ce9b" + }, + { + "path": "crates/oa-desktop/src/semantic_review/compose_diagnostic_tests.rs", + "bytes": 9809, + "sha256": "440daf8d43278ef981c620d1818d0daaed8fb83193b8e8ff67b2e42fbf882938" + }, + { + "path": "crates/oa-desktop/src/semantic_review/constructor_tests.rs", + "bytes": 54132, + "sha256": "85149521ad7df62918f6f2fab6da2b3346c342ab4bce7100de3f6206c1e81096" + }, + { + "path": "crates/oa-desktop/src/semantic_review/constructors.rs", + "bytes": 12258, + "sha256": "0982163439b06a42d9af1643530364109282e63f05b323a35a76d8241f3caa32" + }, + { + "path": "crates/oa-desktop/src/semantic_review/history.rs", + "bytes": 3211, + "sha256": "df038c2464eab8093a983f3104f0d04ca8f602010a50e1d3eeb8e53f2309e201" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed.rs", + "bytes": 14175, + "sha256": "bdd6c0fdc7108056bc5d7433254503449eed2209813680e717ead24b9d0ce834" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_rows.rs", + "bytes": 13222, + "sha256": "4b7bf25806471ad22d89253b9af8000f5acff53b4cc0aa1c1a83138e7b270eca" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_rows_tests.rs", + "bytes": 30804, + "sha256": "1a3b09e7ed100411cdf8043f9a78defc664a873ee0201117709185c201a5c57f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/keyed_tests.rs", + "bytes": 31163, + "sha256": "9dc9b989e5a9d408427ca1baf86b2454f9dd3baf40a551c70ca2359dc18a1227" + }, + { + "path": "crates/oa-desktop/src/semantic_review/message_kind.rs", + "bytes": 789, + "sha256": "4ed19952ea511d1b3226564a138e3322f994371d6b49794c14bc3689d1393e7f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/message_kind_tests.rs", + "bytes": 23424, + "sha256": "5fcf9930e949aebeb12eab0327264f32a2388d62dbf098bd2365711e22623c52" + }, + { + "path": "crates/oa-desktop/src/semantic_review/ordered.rs", + "bytes": 9705, + "sha256": "6a1ed894d1b9d0110bc784a75c49444f1d14f1f74620d701f22203b2d8d0a813" + }, + { + "path": "crates/oa-desktop/src/semantic_review/ordered_tests.rs", + "bytes": 22383, + "sha256": "5c8ea3a69e3da3b94d13f50f12aa7dc53246ccba25ffcace9552a0eb76b0bf36" + }, + { + "path": "crates/oa-desktop/src/semantic_review/recovery.rs", + "bytes": 28769, + "sha256": "88e69044d90c481593bab7cc125f0401c05202fccdde07698cec9483947fe8be" + }, + { + "path": "crates/oa-desktop/src/semantic_review/row.rs", + "bytes": 38159, + "sha256": "b08fdc503c6c4d2ff99adac7e18c9baa861bf86155e00b55d1e492430980d0f2" + }, + { + "path": "crates/oa-desktop/src/semantic_review/scalar.rs", + "bytes": 15153, + "sha256": "9ad202174934dd9a63fbf9cba43135aead571db60846c8b7b1d3019a11df26c2" + }, + { + "path": "crates/oa-desktop/src/semantic_review/source7_tests.rs", + "bytes": 11665, + "sha256": "5e8221d77b068fa30c1571988448cb8829711735881d810f3d333cbc95d34a9f" + }, + { + "path": "crates/oa-desktop/src/semantic_review/tests.rs", + "bytes": 32480, + "sha256": "077ec6501dfaab0b05ea3987943b204f08352952296d313555051d998ccd232e" + }, + { + "path": "crates/oa-desktop/src/semantic_review/view.rs", + "bytes": 57626, + "sha256": "7cc7dd213ab01dadad5debaee868c30a1099466602869a799ebdf9b680e8eaf0" + }, + { + "path": "crates/oa-desktop/src/semantic_review/view_reserved_artifact_tests.rs", + "bytes": 4737, + "sha256": "6c766b29c8664d15cb113d2cc71bba9b60ae4ccf7e44c9c5d3c41e1dc4b7ed90" + }, + { + "path": "crates/oa-desktop/src/source_navigation.rs", + "bytes": 3938, + "sha256": "c1da10882f35f8eb0675e68c642c9a209dde09679cded414cfb9903a4e49ec77" + }, + { + "path": "crates/oa-desktop/src/source_tree.rs", + "bytes": 21816, + "sha256": "4d55e0110a1eb128a5d26c28f3aae5853d79b7245812b7c82bd275f38440a5aa" + }, + { + "path": "crates/oa-desktop/src/source_workspace.rs", + "bytes": 15522, + "sha256": "30f63a6b8d65a38d66061f90d864b5746cbacc0fbd65abc028a8f3071c47d358" + }, + { + "path": "crates/oa-desktop/src/style.rs", + "bytes": 3015, + "sha256": "05d61bec16141612ccafa0988e8c4827f41754509efdb3b961eab69127ded896" + }, + { + "path": "crates/oa-desktop/src/tests.rs", + "bytes": 58557, + "sha256": "b017218195eea2c96aba12eba8a99a38945c8ca910a652e272d34883bdb98691" + }, + { + "path": "crates/oa-desktop/src/view_copy.rs", + "bytes": 9043, + "sha256": "5630f31c942e1226aafd67eabdace6a5c5494875bdc6f7f077019e8110ba41a9" + }, + { + "path": "crates/oa-desktop/src/views.rs", + "bytes": 51734, + "sha256": "1d89f902d645b9cbd95b86ff9a4f72d7bcc5dc2b8a478ed0f7ea9e0f88803cde" + }, + { + "path": "crates/oa-desktop/src/views/traceability.rs", + "bytes": 7501, + "sha256": "4c89dcf35c25e737d8cce4d543a5989ca104a5678e6cf40df47e457773d2ef94" + }, + { + "path": "crates/oa-desktop/src/workflow.rs", + "bytes": 82963, + "sha256": "d9e7b11a86fd3ec79d91f0c9bc9cebd5a2043cdaa7261622454fb7730ad8e060" + }, + { + "path": "crates/oa-desktop/src/workflow/communication.rs", + "bytes": 11084, + "sha256": "34d121ad97706012722e4bb6210072ecc3a5b4718b0ceab0c3d0f14d4cd780a1" + }, + { + "path": "crates/oa-desktop/src/workflow/recovery.rs", + "bytes": 9859, + "sha256": "0849b0f34dba5e8761be5fa05784d134ac74e4e9db395d6b9b7d6cff71e3f3dc" + }, + { + "path": "crates/oa-desktop/src/workflow/transition_tests.rs", + "bytes": 8553, + "sha256": "589b1b2dbadca74a52c2cfcfd4fe620bd4790abd113ac02182e91616c52d793c" + }, + { + "path": "crates/oa-server/Cargo.toml", + "bytes": 778, + "sha256": "527ff5e15010a8b560a6659aa1ae4bf0c8df0d9e019f03c47529ec6a750c0982" + }, + { + "path": "crates/oa-server/build.rs", + "bytes": 45, + "sha256": "ab1be6ae1fd8bf3ebaeef6348347a9d5e666bde693126f199e041659e0b094a9" + }, + { + "path": "crates/oa-server/src/error.rs", + "bytes": 5610, + "sha256": "93817f1502386e4662c96ee1c7d1c4afc4e33bda6fd64e46c86c8e1afd5a9368" + }, + { + "path": "crates/oa-server/src/lib.rs", + "bytes": 7743, + "sha256": "20bef350350ed6339588b23af684abf745f97916c7edf3853ee042abe687e664" + }, + { + "path": "crates/oa-server/src/main.rs", + "bytes": 4163, + "sha256": "d59a6a2b5c7034bd2e00a516d2d49abb16391bf0316c1c357ddafb9c82d2d1e3" + }, + { + "path": "crates/oa-server/src/preparation_http_tests.rs", + "bytes": 5523, + "sha256": "454b90d0055d35644c8d990cd7576ddf675a9b271ca07fe9b0efce25d8ddbc07" + }, + { + "path": "crates/oa-server/src/routes.rs", + "bytes": 46053, + "sha256": "3f9a0c22043dbf28f7a8e587d2fc3abf869f76f4d23a46fe0aeb9c4392454a4b" + }, + { + "path": "crates/oa-server/src/store.rs", + "bytes": 25524, + "sha256": "37dcfb845b7993d5bced2bcf25fedfcd2a9c20a748f9315afe6cca1f41f89ae5" + }, + { + "path": "crates/oa-server/src/store_preparation_gate.rs", + "bytes": 4440, + "sha256": "427c390da3c0281ba1fe115a93ea90800e3b45fce6bcb9185e71982ddd885fec" + }, + { + "path": "crates/oa-server/tests/http.rs", + "bytes": 71892, + "sha256": "50daa6a90e96ad6fe3c6a27df2eaebe486270599c203892d09769c547a194975" + }, + { + "path": "crates/oa-server/tests/http/communication_limits.rs", + "bytes": 5790, + "sha256": "ba5474dd8e494a0176fffb4548c8e3deb2081b15de33bfce82394c764e0a2c16" + }, + { + "path": "crates/oa-server/tests/http/data_contracts.rs", + "bytes": 25949, + "sha256": "8cd456db83f301baca380acf025a5a99db4edf7d8839537dfbd02c4307e10e6b" + }, + { + "path": "crates/oa-server/tests/http/port_anchors.rs", + "bytes": 15086, + "sha256": "7199d0a208ddad9e1518b6e3fb390d64da111716d7505ba5c995deae19ad1258" + }, + { + "path": "crates/oa-server/tests/http/semantic_transitions.rs", + "bytes": 22832, + "sha256": "856d1c9b633ffb581e3e631f4e5a607789a02181dbf060667f208a569bfa4920" + }, + { + "path": "crates/oa-server/tests/http/source6_views.rs", + "bytes": 13023, + "sha256": "867bccda0e030eeeb9976b4ceeb47b21ab5044d700278022d5fb495bbb64ca07" + }, + { + "path": "crates/oa-server/tests/http/source7_contracts.rs", + "bytes": 11000, + "sha256": "0e0a467186da7263c0754890aff69ebd0d92d36b5224e4865bb6854b18dab7e8" + }, + { + "path": "crates/oa-server/tests/http/source_projects.rs", + "bytes": 30907, + "sha256": "8ff580f317ec267d1cd72ae14d8638f74a77cdf99ca4c78f66f4290c2d77460a" + }, + { + "path": "crates/oa-server/tests/semantic_http_contract.py", + "bytes": 7251, + "sha256": "4737ff94f10761f94151a694414c5c62737e0391ec820bca132830652bc4cca2" + }, + { + "path": "crates/oa-server/tests/semantic_schema.py", + "bytes": 25111, + "sha256": "cacca116c42ffbc097f1419c0f89921fa0dfd3faa864d46820ff744cfe6967f9" + }, + { + "path": "crates/oa-server/tests/state_representation.rs", + "bytes": 12241, + "sha256": "6686c826f28248ae4b63ec3f2112e193d4a347724b87974483217fcfee49cd61" + }, + { + "path": "docs/acceptance.md", + "bytes": 3463, + "sha256": "32ed3e4fed63f5c464e0937221f401d71623b276dd70f083531ac6ccebbf9050" + }, + { + "path": "docs/api.html", + "bytes": 72515, + "sha256": "a06126cb741da57e9c06e83fc4137ccde0de05562673546bc9d405878f51ea07" + }, + { + "path": "docs/api.rst", + "bytes": 41929, + "sha256": "ca7d310138c3b4d429d80a1d03d1ac8d4a9296069e205da573034256d10438a7" + }, + { + "path": "docs/architecture.md", + "bytes": 10974, + "sha256": "a50bd1645222ef3e574fa07a6ab9aa213431ee8833c6c0158ad91ce0f799543c" + }, + { + "path": "docs/language.html", + "bytes": 175111, + "sha256": "67dcfa3477b48a0b07298ec81741840cc3ccff12c7d58164873d746d41d611c8" + }, + { + "path": "docs/language.rst", + "bytes": 134663, + "sha256": "12229dd7d52fbaba80fe599d499f29b535f4c37c7be0585664d17edf0466ba33" + }, + { + "path": "docs/linux-packaging.md", + "bytes": 8671, + "sha256": "41a1bb1095801df37a1411341c5791d55ea8c365739314d599a60269ac4bc7a0" + }, + { + "path": "docs/openapi.json", + "bytes": 346920, + "sha256": "bc5825a3182a4df5f6710a80262f4a09b4c15f0e4cda7ca74e1746ceca81a89b" + }, + { + "path": "docs/research-v2-architecture.md", + "bytes": 40445, + "sha256": "1b3809f2dabe6b1805dbf3d3f2625c471cd21356c7bd603916466a8c4ced8090" + }, + { + "path": "docs/research-v2-semantics.md", + "bytes": 31535, + "sha256": "b7ec3677300248926a88b84da3e7ffe52f5b73524c7712c927a0e951569db04f" + }, + { + "path": "docs/research-v2-service.md", + "bytes": 36209, + "sha256": "4828df5bc679e7c71f49b4b85c9e7dacbec52f46d416fed48af70e08886d4e4e" + }, + { + "path": "docs/research-v2-ui.md", + "bytes": 3245, + "sha256": "894e721b59a8ca85f0d95b6706ed5f130a0372def460cf33aeefc9e5e38cde0a" + }, + { + "path": "docs/scope.md", + "bytes": 16690, + "sha256": "a1d0cfbfc06fc8bc2bf0f71343aacc8853cbbbfc00a1fc9852ddf41c8245ffca" + }, + { + "path": "docs/server.md", + "bytes": 23361, + "sha256": "4eb24937d424ba8b384e1734e02a6f8e963ae11d2715889c92b14b39ff2e4a48" + }, + { + "path": "docs/source-cli.md", + "bytes": 3374, + "sha256": "34f12b72cc6d6ead4f47c7818c1897db592f8ad493c70776db2ab48c24d8f051" + }, + { + "path": "docs/v2-interface.md", + "bytes": 11807, + "sha256": "c7fbaf0ebd3fc9f6c11f818db2b0b9d68a33f580cfced22bde83ce08ae790bc7" + }, + { + "path": "docs/validation.md", + "bytes": 6505, + "sha256": "f46ea950ed1a54409aa07c4f9e90f39f8e2d00c1dd1b6cb805caa3993845967f" + }, + { + "path": "docs/windows-packaging.md", + "bytes": 10406, + "sha256": "2c852ff7041713ffbff3c951ac98df647c51fb70b0feba9000f7bfd5bc2703a8" + }, + { + "path": "examples/coastal-rescue.arcadia", + "bytes": 33107, + "sha256": "7e183ef9fd8154d3074303f1956cd0d9871c19e3ffc630d333b0bffbd6e30e17" + }, + { + "path": "examples/coastal-rescue.json", + "bytes": 49715, + "sha256": "242f0b031229a87af5c4ebe5d651defe59c191a6b7a69dc0a77f7e203411f195" + }, + { + "path": "examples/legacy-v1-coastal-rescue.arcadia", + "bytes": 3449, + "sha256": "4dbbbdf8bc7e6cb8e0a81dd678069dae585a9e5187c59bc3665e1fdab3f1a86a" + }, + { + "path": "examples/legacy-v1-coastal-rescue.oa.json", + "bytes": 5976, + "sha256": "fd0e9dedfb7adb922dc0575cc2b820d40344d639f1d8052bd70363aa59de9c24" + }, + { + "path": "examples/release1/README.md", + "bytes": 11137, + "sha256": "113cfb1cf38a98b51bff60442d86a35d636a3d80ef206bece7d53d0aae67f2d5" + }, + { + "path": "examples/release1/evidence/repair-check.md", + "bytes": 1419, + "sha256": "f4db17bdca4ecbb1bf0caef01b2da5f1f7f798ab3152b648ce6dd8696a6a68e5" + }, + { + "path": "examples/release1/expected-diagnostics.json", + "bytes": 288, + "sha256": "3700393d76b940cfc076bf52861bd7b1f43370f8eabce3594531bd0bf1fc851e" + }, + { + "path": "examples/release1/model.json", + "bytes": 134520, + "sha256": "ef0ef4006c3e09d5db6e1b621256b3f7d6642f3a7b09cc34607cfbcca830c727" + }, + { + "path": "examples/release1/model.rs", + "bytes": 28762, + "sha256": "15f30f6bde655808fe754665c26d560e36f2a9bad340f346b09137d0d05045f5" + }, + { + "path": "examples/release1/oa/activities/activity_oa_restore_work.arcadia", + "bytes": 1307, + "sha256": "83e73d0a013d5c3e1a4af0d9139ab0cfa362d25a846671fc2dac59181061a9d4" + }, + { + "path": "examples/release1/oa/behavior/process_oa_assessment_procedure.arcadia", + "bytes": 697, + "sha256": "172c32c044ef4b5bc58a1f4635cc81f48dabb4014479b47dce7b25fedf2dbd0d" + }, + { + "path": "examples/release1/oa/behavior/process_oa_field_procedure.arcadia", + "bytes": 1781, + "sha256": "d2552dc5383e2e91cb302a790364e197f663c2edc013a2ab1978789825c9c324" + }, + { + "path": "examples/release1/oa/behavior/process_oa_response.arcadia", + "bytes": 3225, + "sha256": "cf86f46fa5c5d70592ef43f1bc1cb4d968efd8add384ba88036bef6b88aa4abc" + }, + { + "path": "examples/release1/oa/behavior/scenario_oa_conversation.arcadia", + "bytes": 1795, + "sha256": "b25be524e98a35ebac5e4481b7609c027b32baf9605e8097f807560f94a77ca6" + }, + { + "path": "examples/release1/oa/behavior/scenario_oa_full_scenario.arcadia", + "bytes": 1261, + "sha256": "00a1edf2c9707a0eb62ac070c2d02467874f2c9c1f273cc6ddb53d6d65999a1c" + }, + { + "path": "examples/release1/oa/behavior/state_machine_oa_monitor.arcadia", + "bytes": 2022, + "sha256": "447c9ad1359f4a31ecf975ad07c0b08d8e7e03191fb0858e2fc56f377b223cd5" + }, + { + "path": "examples/release1/oa/capabilities.arcadia", + "bytes": 781, + "sha256": "fc8012e5554350b12e1cb80080f8feab80d933c9b33c0f2a7bb500cb7d609936" + }, + { + "path": "examples/release1/oa/model.arcadia", + "bytes": 661, + "sha256": "f7cf914766ea73ec53b85e32d117ea9a9dba52d3e038246863541ae7069b1a15" + }, + { + "path": "examples/release1/oa/participants.arcadia", + "bytes": 1834, + "sha256": "951764c14179f27c10e315acf2ea37d1fff54c77b8441e23addd239e8c715ce3" + }, + { + "path": "examples/release1/oa/types.arcadia", + "bytes": 788, + "sha256": "9d0396fb82dd5733edd8d1cf52f968ca84906927c704f9cf0944a7fae215cf49" + }, + { + "path": "examples/release1/project.arcadia", + "bytes": 1958, + "sha256": "b2674e6bf77cfe0f6f0ba79c81d2e96d92f39c02ca2c6266d80e91723bfb9fda" + }, + { + "path": "examples/release1/sa/behavior/process_sa_assessment_procedure.arcadia", + "bytes": 706, + "sha256": "73928ced61c06cbc08728d7956676a50fd4c05aa5b7f1ff4f29ce27a0b0f2088" + }, + { + "path": "examples/release1/sa/behavior/process_sa_field_procedure.arcadia", + "bytes": 1790, + "sha256": "886d462af83110cbfa55dd232a667ea1446761234471357cbb878794e98e8768" + }, + { + "path": "examples/release1/sa/behavior/process_sa_response.arcadia", + "bytes": 3234, + "sha256": "041785fc22842423822431bd5e6e8d16094ebd0716965e7c765fb8c1d7549e8a" + }, + { + "path": "examples/release1/sa/behavior/scenario_sa_conversation.arcadia", + "bytes": 2127, + "sha256": "97276f5757ee9aa12a0dbd9d3ccd58174b3091162bb8bcce357cec20a45f5d85" + }, + { + "path": "examples/release1/sa/behavior/scenario_sa_full_scenario.arcadia", + "bytes": 1256, + "sha256": "e12fc406b99d60a2f7768aaa0b25ba560e8605f0b8e37f3a7cdd3b8443562b74" + }, + { + "path": "examples/release1/sa/behavior/state_machine_sa_monitor.arcadia", + "bytes": 2022, + "sha256": "05ce29af99424c491c47fe2450dc6f5f8ce995511c01ec7e17bb5855be3c9736" + }, + { + "path": "examples/release1/sa/capabilities.arcadia", + "bytes": 781, + "sha256": "b6912fb3ece439912345fa71724acd462e716a1e5a88203a1058a5c3b2c20a4f" + }, + { + "path": "examples/release1/sa/functions/function_sa_audit_thresholds.arcadia", + "bytes": 297, + "sha256": "e5a04325d52183956dca814dd90f4e56c96c6b7db0f4f202f203ecb49c3e0f4f" + }, + { + "path": "examples/release1/sa/functions/function_sa_restore_work.arcadia", + "bytes": 2576, + "sha256": "fddeb67308051325041fee641fe758ddf43345b7c47b66d433616ad07fdccdd6" + }, + { + "path": "examples/release1/sa/model.arcadia", + "bytes": 661, + "sha256": "d431509251acb859fbb98733b6d18add952495e10a78703fbe8f31e40bc083c4" + }, + { + "path": "examples/release1/sa/participants.arcadia", + "bytes": 4012, + "sha256": "780d2eb08b217b67b55febb3d34846f727b8ee9018df6c5741748647e36b2ff8" + }, + { + "path": "examples/release1/sa/types.arcadia", + "bytes": 1227, + "sha256": "101fc0fbd99f1101514aa7b6da4f8e535aae0bb94c9e2b9e7e6c151135b28660" + }, + { + "path": "examples/release1/traceability.arcadia", + "bytes": 29506, + "sha256": "48a96f543456c9b5a5798fc795594e4119147fe45f11a6f109f141b7f514560f" + }, + { + "path": "examples/release1/transition-before.json", + "bytes": 35801, + "sha256": "2253e6434f741687e22327c37d520ed15c043bc36025498650bc2366bb6a874d" + }, + { + "path": "examples/release1/transition-request.json", + "bytes": 4276, + "sha256": "43b9a22e5f95ad3bc0ebd2478ead0e14406854abc989ae94ded9367b013d812a" + }, + { + "path": "examples/release1/views/diagram_oa_allocation_view.arcadia", + "bytes": 2176, + "sha256": "dfc0eb61e0e2aa5bda45524571fbfa3494f44ce19696f3e15e07438074a07bc7" + }, + { + "path": "examples/release1/views/diagram_sa_allocation_view.arcadia", + "bytes": 2173, + "sha256": "b78b43a26a82efb8fbd5374b09c329fa341f57b29f635d397b9ef8aede71d389" + }, + { + "path": "examples/release1/views/diagram_sa_capability_view.arcadia", + "bytes": 1620, + "sha256": "75e8dc9fb30f25d6f8fd3c6b595593ab4f98958a25798f961e336e0fac557649" + }, + { + "path": "examples/release1/views/diagram_sa_service_view.arcadia", + "bytes": 2209, + "sha256": "b08c84f3ea633e7c78dfdad3272f75415f6256cf3614b6d99bfd4f0269076c9b" + }, + { + "path": "examples/release1/views/diagram_sa_state_view.arcadia", + "bytes": 1931, + "sha256": "5f42f4c605e57b817d8400ed21f2b14bfc4e1592aebe941ff113767504c2b869" + }, + { + "path": "examples/routing-workshop.arcadia", + "bytes": 66431, + "sha256": "dc6b75da72884d399132ed9e300fa5a26b73d802bb526c9af986ae9eeb0a646a" + }, + { + "path": "examples/routing-workshop.json", + "bytes": 100281, + "sha256": "8592714f75b271133f21ce017d87896b6cf91ea0e4837f1c2ed453e21be26b14" + }, + { + "path": "examples/source-project/oa.arcadia", + "bytes": 2142, + "sha256": "5f60642f211b2d352a951092faeeb7503d4fb7f6f7fca99e810347231101d31c" + }, + { + "path": "examples/source-project/project.arcadia", + "bytes": 606, + "sha256": "787f6b67b179ffd221f7e5faf1a4edd74cfd116aa1e3b5e9ed9f22fbff612d8d" + }, + { + "path": "examples/source-project/sa/assurance.arcadia", + "bytes": 682, + "sha256": "ab76044836e4dcd42a82d316846ec87da2108939aa2037640c5bca1d2ecdee0f" + }, + { + "path": "examples/source-project/sa/participants.arcadia", + "bytes": 1231, + "sha256": "1abad579812e77877b45a3d8e3c3e9da734be2d04a0254cc730a5257ebd2dc88" + }, + { + "path": "examples/source-project/sa/reporting.arcadia", + "bytes": 2839, + "sha256": "f0b7443f728912ca163de39b6055876b533a77feaa3219b2d40a2dd65712e058" + }, + { + "path": "examples/source-project/views.arcadia", + "bytes": 3508, + "sha256": "e29ad3f406a6a50d2f0ae2ca2a53ee3b0c18222cd4098704a46d4f48b64ea17f" + }, + { + "path": "examples/text-first/README.md", + "bytes": 1367, + "sha256": "4ec8250d5ed556f1d496e8c85137e973e802ecb11df1a36488411e8cdc5a9f9e" + }, + { + "path": "examples/text-first/project.arcadia", + "bytes": 480, + "sha256": "f441535c623e0cf20e1875eb2cd33b587ed00e078c37af39cb36d89bb5edc19a" + }, + { + "path": "harness/fixtures/basic-editing/README.md", + "bytes": 12012, + "sha256": "3545d9695e7c62e0caa818efd7f4dc426f04876a3626e0f3b1bad606b258cb26" + }, + { + "path": "harness/fixtures/basic-editing/base/expected-baseline.json", + "bytes": 4524, + "sha256": "f239e728d650b0af32bb8f3dcaf6b27c99b9c5041132ac14e51756ea6563d978" + }, + { + "path": "harness/fixtures/basic-editing/base/project.arcadia", + "bytes": 3077, + "sha256": "045cb047d7bfbca72c3fb30db4c81a30ad463d3af7fc51604906ad7fa75a1ff8" + }, + { + "path": "harness/fixtures/basic-editing/base/rationale.arcadia", + "bytes": 57, + "sha256": "c01867c9dc0d40726853119fac3c6ad24a40d8d362a93a8b9d20df04ec2e273f" + }, + { + "path": "harness/fixtures/basic-editing/manifest.json", + "bytes": 447, + "sha256": "d23c21b02064ddb85e051e10e16ff089daba8d9910bb1a695dfabe2db3757734" + }, + { + "path": "harness/fixtures/behavior-creation/README.md", + "bytes": 5954, + "sha256": "9e5fc751424d12cfe76a84abb1da45b2d38947409179451bb90ffe7e7ddc8723" + }, + { + "path": "harness/fixtures/interface-operation-probe/README.md", + "bytes": 2604, + "sha256": "088f0bdb3375deb8f2c7e3b749ca8d210ea828ca4dece69b3871b674e3110175" + }, + { + "path": "harness/fixtures/interface-operation-probe/hashes.json", + "bytes": 977, + "sha256": "f6d3e8aa42f40f64ce2ecba7b9cf112eb9091f3cccde3a592b0434e834cf2a6a" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/after-reset-deletion.arcadia", + "bytes": 4218, + "sha256": "c0fe9570684c0061efc4cad65e339fede6961b04ca90c6f324c787bd65e61226" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/after-reset-deletion.json", + "bytes": 7835, + "sha256": "93187f7a1b476a44185725c6b15f2e1767482b6911ab1280144348d033eb51f0" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/boundary-only.arcadia", + "bytes": 4771, + "sha256": "02f85e39957ebe6d56336fa729a5c8b10f51865face9d3b2c9679200571fcfc7" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/boundary-only.json", + "bytes": 8840, + "sha256": "756f9710336e6734ce3592ca774c6f104bba5a37c9e165540eb39326682393d1" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.arcadia", + "bytes": 8635, + "sha256": "ac5b629ba5596464f9f8a975b8bc2764e3007ceb7342de3f828d4b18e4f069b7" + }, + { + "path": "harness/fixtures/interface-operation-probe/output/explicit-functional-refinement.json", + "bytes": 16160, + "sha256": "78a47c978dc667aa1c45af711f06aa2a0d3c581003013e30c3e02fb0faae2e64" + }, + { + "path": "harness/fixtures/interface-operation-probe/probe.rs", + "bytes": 11274, + "sha256": "72b1b443e25eb20420dec4477b0fb5ef5d1c705e3882c81df88dd578ab96a426" + }, + { + "path": "harness/fixtures/release1-native/README.md", + "bytes": 2564, + "sha256": "5f5ba040fd2df9261a29bcab3f9a7ae27c3683265411ad3dda0b467d5df8590e" + }, + { + "path": "harness/fixtures/release1-native/artifacts/README.md", + "bytes": 4155, + "sha256": "24200c84ccc2ef3e17c029744074e5cea785188f5549ac54e44cf89682643f81" + }, + { + "path": "harness/fixtures/release1-native/artifacts/generate-semantic-artifacts.rs", + "bytes": 9275, + "sha256": "444f360b78df52c5e42046f77b148781e0c9bddc2a09c0b7bd65c7a4f376cfe6" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.arcadia", + "bytes": 7768, + "sha256": "84b22e95c213018612e6e8a84cad68b35a8b495ff3515b0f978c5e7a3d196d79" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.after.json", + "bytes": 7330, + "sha256": "13a6f99ec2df1dd35ee8b2613f183918cd9537eda4a5da085ad52e65c033db59" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.arcadia", + "bytes": 1446, + "sha256": "1e0d662ba33071b122ad9206d2d559a8e748c9431eb3ac1b759bde3760ca877c" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.json", + "bytes": 2216, + "sha256": "fa6a2e3643c0f909b92407abec3edc897033162eeaa501f8d4616f79d41fa044" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.manifest.json", + "bytes": 567, + "sha256": "65cb70b0d697a055363ba01bf30bed7e412d43c9978a033549c378d117719ae7" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-create.request.json", + "bytes": 3991, + "sha256": "ed905267263e7f8a0cd2dbe833196b30118b6a246815216932fae661ad650699" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.arcadia", + "bytes": 6837, + "sha256": "e50fc462ec22dbf98011929931dd2489430001c3e6433608685b9d88bceb9acb" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.after.json", + "bytes": 6433, + "sha256": "f27a7b38d59c7cefe58cb36783d3d4dd8d8ae1168d9aed1eb61d343c18758908" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.arcadia", + "bytes": 1807, + "sha256": "eba2aec39e6efb405eace4bc8ab0c5563907c26d449e71a4aa750df9f73233b4" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.json", + "bytes": 2673, + "sha256": "2ef777f19b94f08b5e5ca2ef727777897e1018f1426eee291408b3c69101f596" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.manifest.json", + "bytes": 519, + "sha256": "3af7232ed3056ca84dcaf0f266ead3faaa512a0dc0051c7ba68791c20dbae0cf" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-delete.request.json", + "bytes": 1246, + "sha256": "8af21b00b62e620256fbf50e47c6c5836cdb6922d9549cc4b3d86bc03b008073" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.arcadia", + "bytes": 4200, + "sha256": "20bb30473830e44228958e78fb7480269cdcc0580c6c90c718da75f34ca5a43f" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.after.json", + "bytes": 4552, + "sha256": "44f4b05db49758dcf344788f57cecc0250fd029099b1c54e4e1e3e972f6cf039" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.arcadia", + "bytes": 1808, + "sha256": "b0fd031671c9f755756922ec5c40a0ce3f40164d22c3c389aec9fd0705344da7" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.json", + "bytes": 2673, + "sha256": "1acf81e08c51c85aceb14a3efbc39ec680552a19c7824aab4611ac3cf71b9c6d" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.manifest.json", + "bytes": 610, + "sha256": "a07978f4b0a3ca83e5ae5f35e7b66b26473b24431fc90e5889d755f1816d52dd" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-move.request.json", + "bytes": 2352, + "sha256": "5ff844a038b0030adb5a83d13d81e60f30627543388f6199b6a0e026fc42ea58" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts-native.md", + "bytes": 4075, + "sha256": "a51ffbc45b6c172cbfed3b16c249296e6a28d457fea57393dd958cdcfbafbca1" + }, + { + "path": "harness/fixtures/release1-native/artifacts/semantic-artifacts.hashes.json", + "bytes": 2367, + "sha256": "3ad8b7428b3ed7585a91e7f5d9d5f4880caccfd0b08dca25d05af523e62e0a10" + }, + { + "path": "harness/fixtures/release1-native/communication-means/README.md", + "bytes": 15091, + "sha256": "015c16010c212af283f9def118c6d263ba65a3bc6e81a750f180624ca69bb311" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/entry.arcadia", + "bytes": 6098, + "sha256": "a6976e7c21031e7cc3cb731e20c3075cf89cf85144dc8d3f52930f8521ea196f" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/expected.json", + "bytes": 10480, + "sha256": "60c4419415c546f06c9972ac7bb0e530ada7b30a200b59e75ddda231a24f9a3d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.after-template/traceability.arcadia", + "bytes": 407, + "sha256": "3c41459f2b0706a767988738bf8126f76540415bb5940d9c5db19cbe8c18182d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-create.request.json", + "bytes": 1331, + "sha256": "b16e673b29c96b5aed681389ff7669110abe552939e86dd0ec6011c9a45ed860" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-draw.arcadia", + "bytes": 5239, + "sha256": "a511a4d817d9c5c80233bce83e84a7056b7dce7afd9fcc25696e333f8f4df055" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-draw.json", + "bytes": 8424, + "sha256": "7140114926228b1c378c450535f7a70992c71a879a8d2270c49e8d5f04a2f484" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/entry.arcadia", + "bytes": 5710, + "sha256": "910e6dfe609467047ce629ec9c626f4e927cada74bfbfa164414a8fe6783ea87" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/expected.json", + "bytes": 9868, + "sha256": "567259e20c9f6278776e8fa99b8b2fdbbc9a883ad875c5d39dae1b53de3a2924" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.after-template/traceability.arcadia", + "bytes": 407, + "sha256": "997f72fe9258012df66e88344cf39c1a2cebf2327f604056b67f7f2a8ebcfbfa" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reuse.request.json", + "bytes": 1127, + "sha256": "cb3fe05859cfffec6f8846c19983dc462413bc0ea4f6e19204f09c259919c4b1" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/cm-reverse-scenario.arcadia", + "bytes": 8209, + "sha256": "ec826b9b84616507490ac30e4d57100dd6338dba2f7071e879a8fb58820a85c5" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/expected.json", + "bytes": 19735, + "sha256": "ef07e4d2d3fc36004ff01739838281581d9a703c747611eacc01bb9cc672489f" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/oa/behavior/scenario_oa_cm_200.arcadia", + "bytes": 1488, + "sha256": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/request.json", + "bytes": 1090, + "sha256": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-behavior.after-template/traceability.arcadia", + "bytes": 2068, + "sha256": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/entry.arcadia", + "bytes": 9827, + "sha256": "86dd8a355f6c9dadfea56d06e5247c9b0f820819d7df17ef5690671c7c81324b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/expected.json", + "bytes": 21877, + "sha256": "980489ec2c483d4f9efada61358c1f29bafb2572fd5b804c656b91b8e9bb4f9a" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/oa/behavior/scenario_oa_cm_200.arcadia", + "bytes": 1488, + "sha256": "0ec8d7e38f5a5cd56ccf3979757b3a9f412ad0ae36ee6c2690b7872129046d70" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.after-template/traceability.arcadia", + "bytes": 2068, + "sha256": "dd5d356390089e4ec474374956f6219502733987e60ef8ff32920d8b33dce858" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.arcadia", + "bytes": 7698, + "sha256": "1abc4c4cac37cfb06ed3b12a115f9e7e6a2d3affd34b25c355309e5ee465fa40" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.json", + "bytes": 13130, + "sha256": "a5cf4cb2ef390113dd752f4054d43fb789da2ca77799efb5782805ae8aa2dfd5" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-reverse-scenario.request.json", + "bytes": 1090, + "sha256": "c0ac99ee186d126fe3ec57f2c0a4072984d39d36ad21ead357ab66a08ac0065c" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-transition-ready.arcadia", + "bytes": 5454, + "sha256": "b761c4c2af5f7064aaf1f887ffd6094eb6ae834b2c8057ecdbc4aa97c042066b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/cm-transition-ready.json", + "bytes": 8852, + "sha256": "2536b000de361fb131787e32b466b9123d4e98abf00c099ad32f6cb8e7fb530b" + }, + { + "path": "harness/fixtures/release1-native/communication-means/generate-communication-means.rs", + "bytes": 28035, + "sha256": "003521404b702332082e01f2be7676fda1dd7b5bcf220bb81d25120c8984c75d" + }, + { + "path": "harness/fixtures/release1-native/communication-means/hashes.json", + "bytes": 3133, + "sha256": "39b4dc02fc8b074015c59354fd1c1061c25832fde25065c7151f36eb0455e6f6" + }, + { + "path": "harness/fixtures/release1-native/communication-means/manifest.json", + "bytes": 1237, + "sha256": "fb921f42f2c4a4f8a67d1266f17f8c7750b6a2619554b713aa92b17918f0c43e" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40-oracle.json", + "bytes": 26264, + "sha256": "74edca148583f42c269e51f135662f65ef1c9ea1c94516d63e2a5091967dc99b" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40.arcadia", + "bytes": 28947, + "sha256": "00b87736b82c5afd33b311df7aebe9a6c8c51b6de66221181b5ea8bc8ca221a3" + }, + { + "path": "harness/fixtures/release1-native/dense-40/dense-40.json", + "bytes": 54938, + "sha256": "5dd4f22453330cab3abc059881660190e689a22619853f77cf6d0b52735d97ad" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments-native.md", + "bytes": 2624, + "sha256": "28906924b05f75bbf432389517aef65f1df474d2f2bff79a3586564f7f7328ef" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.after.arcadia", + "bytes": 6795, + "sha256": "9d084dd75a0251d349cc31f9ee98df58d0bc76859dc3cb1503f242e2f759888a" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.after.json", + "bytes": 9618, + "sha256": "f09be41afd85c18fd52fdf997e9b81c4b7cb2c41e78d167abcd14caea8110333" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.arcadia", + "bytes": 4990, + "sha256": "8740f27be99624013d9be876639c0411e1b8c14f0f9a843f43dc71d769efd79a" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.hashes.json", + "bytes": 963, + "sha256": "00fc9e2c709bdcd9ee98012176cb0edb635c112153d963cd169bf4bf69a9e010" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.json", + "bytes": 8146, + "sha256": "9c188f2890630c7feec2be719a7104af9690da7ea836df18fa78da3ff2acfc1b" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.manifest.json", + "bytes": 1045, + "sha256": "46b40f221ffad614733b615208814ace63947e96b80bbfdec63853ccd4f4e8c8" + }, + { + "path": "harness/fixtures/release1-native/semantic-attachments.request.json", + "bytes": 3075, + "sha256": "b57f656f0b9cf2c595e83150c683301909e20f15684d35d108d3c57ee0dc5909" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch-native.md", + "bytes": 2637, + "sha256": "dddca2b85f892b05881c75ef3cd62437396cc086a09909b621e02bad0cbe56ff" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.after.arcadia", + "bytes": 3134, + "sha256": "d3315bba762395205ae761e6e64029e8b4070c15a1299c6114075581db7b0974" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.after.json", + "bytes": 3927, + "sha256": "8f36119c7e893a4af374b13b85b1c2cb3df0196df8d06a551386628fc8b8646d" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.arcadia", + "bytes": 1787, + "sha256": "5e1f433e04621424edac43e53411624059e873f88dd531bfdb39093953485ed7" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.hashes.json", + "bytes": 933, + "sha256": "1bd87700b04e4f169ab5f8aceaa3b0c3ec3a1cc43e1bce135a1cee506fc75d38" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.json", + "bytes": 2816, + "sha256": "1972242d2a8677d004dc3af1081feb292de65fe26128d877dded8661f9906619" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.manifest.json", + "bytes": 647, + "sha256": "1e440efa02e2ccc27585d9a49c7864d53e3e3e7645ccb219f040e00d95331b8e" + }, + { + "path": "harness/fixtures/release1-native/semantic-batch.request.json", + "bytes": 2197, + "sha256": "71f23474614aab90398ce24f00f2cf61d6cb9a3a34faa3e12e0c8104e0a71073" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-repair.arcadia", + "bytes": 15635, + "sha256": "e3ce0347746584f503b825a8b6bd23a7eebf0827940112ef8f36d500c1d0a043" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-repair.json", + "bytes": 25736, + "sha256": "29736f2a619f7f2d0e795229f6e8c3645a1b4eca6292043cd604aa01b1ec9170" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-take.arcadia", + "bytes": 15631, + "sha256": "9ab573c92be66e3bae659dd826923ba6066979b1651edda7bd469056632cd77e" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.after-take.json", + "bytes": 25736, + "sha256": "828c990c6129692cd31c7f6ed0dd6c952f9cfffdd90bc80171df82d4d929afba" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.arcadia", + "bytes": 15617, + "sha256": "49214be2ca9c8bb6195c3b39737c053847021839f70f0bb2921d35a1fbd2ac83" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.invalid-request.json", + "bytes": 2225, + "sha256": "8b02d4739b1be2c8a64da76423b4a6cae7d89c60f4d30723b94f1da3779cbcca" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.invalid.txt", + "bytes": 78, + "sha256": "aa536e18bc65325163e9b645a4ad031ab599fcb05948dcf741b725d0f0c8b602" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.json", + "bytes": 25722, + "sha256": "995dd72f5c1f07f998233ae9847e337cb82de0c2a9053d3905be021d5f8124b9" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.manifest.json", + "bytes": 1059, + "sha256": "ad315359bfd68ce0d265976dc9e4ea6a502ebbb87d7339dd1af5ef27dd01e433" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.repair-plan.json", + "bytes": 15016, + "sha256": "27bf316ad66ffa91f6323e75b0c280baf5caec298645793dea72c5d42aa3b782" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.repair-request.json", + "bytes": 2225, + "sha256": "f4f6b5480ec8927033ea469ea82c1e8411cb6dba95d2da680f15bc193914c9b4" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.steps.md", + "bytes": 3897, + "sha256": "7d7e38d93641a5f22a2738baa4dbacc392eebb477a855cdce0641961980a19ad" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.take-plan.json", + "bytes": 18557, + "sha256": "74dd68ba686b8928054480f0bfed55aad91f6f1208803399dc9878e894f57ecb" + }, + { + "path": "harness/fixtures/release1-native/semantic-keyed.take-request.json", + "bytes": 1508, + "sha256": "d19a53002a6bf95af3123a3ef9f78baaf7ce1085d4f06f0f4a9d5e5d5accbc0e" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.arcadia", + "bytes": 6935, + "sha256": "90277f1780d43a6f0b2184bf00b87e7a4f3518d67c6f10d4793daafe1aabf493" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.after-order.json", + "bytes": 11286, + "sha256": "5a3c8494f6976c23b990c14b40760fb2f32ca9973caf6f31dab5632310663591" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous-request.json", + "bytes": 1379, + "sha256": "6a86fde194faa55f2d1bdb982571e0e711e5401b53a960e6acb8cf3e17f506c8" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.arcadia", + "bytes": 6195, + "sha256": "e7c30c5a5c3ba7209c8e223f02da55821d7af10a2f09844a7065ae6cd8f22aa5" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-plan.json", + "bytes": 19156, + "sha256": "d1e5c2ed08e0aa6274a0421a39876d1ba99f4e441c7a0a68660a83b9e017da14" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.final-request.json", + "bytes": 2418, + "sha256": "433f723252598994dac7184da61f95344b528156cc5a0fba1a7864b2ec9f002b" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.json", + "bytes": 10441, + "sha256": "9e4e2ce1c7879935ad0860a3ae720506c929a8422b51491b719d88af3fd3ff2d" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-branch-steps.manifest.json", + "bytes": 1042, + "sha256": "87e8899c7d4e54faedeef32afb7592fb65278d1bd7390850ab198dcf62068329" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.arcadia", + "bytes": 6280, + "sha256": "6c77ed42bbf9f4ebe08bfa233197a4020e5587ce33747f7914430aa0c662d9a3" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.after-order.json", + "bytes": 10009, + "sha256": "1dd7ca2bcfc84ac23369c506302b39569d2ebc41e5a4edc99378a1fe01923b7e" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous-request.json", + "bytes": 1390, + "sha256": "e0ea7aeb25687ae63c65128f1aab78273f14030d179d3fbea63fe91ab5430136" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.arcadia", + "bytes": 5529, + "sha256": "563c36162050c8564ffa25a85c726462ecdaebdb87659b3f3610506bfd5581e6" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.final-plan.json", + "bytes": 18821, + "sha256": "f96c43fc58dbe48a044b628b31bb3f0b59171dad5b6982ec6c34a5597e474130" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.final-request.json", + "bytes": 2438, + "sha256": "d38fdb13612b07254edad80848f79c1e097d5f868c020feae9ba072aa697a50d" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.json", + "bytes": 9153, + "sha256": "2ed0daed118f2df13dcad738dab174ad34d44a15921cf8097415e707978b0968" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-fragment.manifest.json", + "bytes": 1058, + "sha256": "c79bd12a85d8d4f25cc3ee43581b3e5e74ae9ad7e4de0c72764975ba2b89c279" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.arcadia", + "bytes": 5026, + "sha256": "98020e048ac01f285c6ad8c10ce22bef05e193b5ba0f5558be1fb26a7bf82620" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.after-order.json", + "bytes": 7851, + "sha256": "ea3783992488bc6ee944eb91a26ccf3dbc05a3909528fc32ec8023a76765cee6" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous-request.json", + "bytes": 1379, + "sha256": "ea3cfd25f7a50481805956fb88ab851516dcd602dd6564502a0cc55f7de6a54f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.arcadia", + "bytes": 4295, + "sha256": "2b7c3694623bbea3e36dcc6f674d4adcd91e23c8e1005ded21e5a69648a048e5" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.final-plan.json", + "bytes": 17912, + "sha256": "95a23bd334cffcaef0c3b1012b7555efd2a077ef6f9140d58020910ef8a76723" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.final-request.json", + "bytes": 2081, + "sha256": "1e2433ed5821bf65443f56cb27381ee935db81b1955d3a539b7952898312a410" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.json", + "bytes": 7012, + "sha256": "0033f8780c2ba69779b811bca792340c25a092f887e5811c6839f0a691d744f2" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-reverse.manifest.json", + "bytes": 1046, + "sha256": "e3b4a60a56abee779ca8356605c968aa2d99256a3bd3c5601b14b5c5502a1a05" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.arcadia", + "bytes": 5467, + "sha256": "e265cab35097acc46f5123107c13bc35b9f71931ff650557fc1c85779141b327" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.after-order.json", + "bytes": 8482, + "sha256": "9b777828d3681138de6bbd08de8bf922bed92c27be60b103d8ff73ce7ddd0a48" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous-request.json", + "bytes": 1379, + "sha256": "7d124256730bf2feee772c7d0118b87eb288e8aaa9179d69ceb9259dbceb2c71" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.arcadia", + "bytes": 4727, + "sha256": "87a5a3665dab2dd6e595867dcebb1586e93dd067c85d6e24b1a4d3ff0ad6d4ba" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.final-plan.json", + "bytes": 18803, + "sha256": "1888ca51e0923866a9afea99cad069fe5d3f19f0a1b24328e20ac1b9f52d8bad" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.final-request.json", + "bytes": 2294, + "sha256": "5070a5b85feb1bc7b1fc648cd5d35ef26663492c8666dcd471950c06ec3a6052" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.json", + "bytes": 7641, + "sha256": "725b35e36640c81c70c7efea5c3304bf61b49ef9664194ca0d491782cc62191a" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered-scenario.manifest.json", + "bytes": 1038, + "sha256": "1b43abf8fed3061c65a7b7cb103d31ea7ece333a2da83c645f8d228448c4dbb2" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.after-order.arcadia", + "bytes": 5019, + "sha256": "65a6217f474b5085f37b511151185c2c08ff7a1998e924f1fe01f29c410f6ced" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.after-order.json", + "bytes": 7835, + "sha256": "8a53bb9b43eab5b6dca5e08deef20c14c96e134b9ee816a99b7960bb5255e008" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.ambiguous-request.json", + "bytes": 1379, + "sha256": "c704f99245f00d5c3be0562d91931b4e7f1fb3fb36f41991eb76656ffbd6129f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.ambiguous.txt", + "bytes": 94, + "sha256": "0f938b23fcfce776a61a57de5a2c82b4a0720b5e5af6780fdb96f5f92b3edd21" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.arcadia", + "bytes": 4279, + "sha256": "c59ec1233d5a9fbb8e386f6d9b13f398be21baf813ba215efb51bfc1bb98db36" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.final-plan.json", + "bytes": 17938, + "sha256": "30c5c3f614a74708763df612016483623792f4c65e2ed2fa662ac417cfb852eb" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.final-request.json", + "bytes": 2098, + "sha256": "3b6c35ef78133f0980cb6fb53fbc29c5d3c4deb5dc4be01c2c3384e221987b9b" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.json", + "bytes": 6996, + "sha256": "c159c60403abcf8fefab7f19cbad9989488e8ccc20b82c57597b22a0ae254802" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.manifest.json", + "bytes": 1038, + "sha256": "af8a314a9b1d85a8f98affa5a6649f43d252851158798e1ad687bb1b6966b14f" + }, + { + "path": "harness/fixtures/release1-native/semantic-ordered.steps.md", + "bytes": 4549, + "sha256": "6004894e9d9f478b7fe1c3c3e0706dcc546d5df8557cff91b4cf26f8a4badf24" + }, + { + "path": "harness/fixtures/release1-native/source5-recovery/15000000-0000-4000-8000-000000000010.json", + "bytes": 1933, + "sha256": "71cca2a59f36b2a07d11dedbe9101226aa1a4a00d8ac244b5565202e56709f51" + }, + { + "path": "harness/fixtures/release1-native/source5-recovery/generate.py", + "bytes": 1496, + "sha256": "e44986c1d563499f25917441220b23883fc9cb0f89faf409873191f0212fbd2f" + }, + { + "path": "harness/fixtures/release1-native/state-actions.arcadia", + "bytes": 6224, + "sha256": "9cde82608110e56aa9e14c9e33eb38976f53aed74ab013145d411d5743a0ec26" + }, + { + "path": "harness/fixtures/rest-coverage/README.md", + "bytes": 1870, + "sha256": "df4a391312e0c8b20ccdcc850199443b08547be1b10b1f2447a067bf4bf544e6" + }, + { + "path": "harness/fixtures/rest-coverage/coverage-probe.json", + "bytes": 7951, + "sha256": "2d1ef7bdb5d7bf17b9fda33b1d1790d1d88289b3fd1e725f89b83a69771f9a43" + }, + { + "path": "harness/fixtures/rest-coverage/run-coverage-probe.ps1", + "bytes": 9381, + "sha256": "f24f19fca418b76a7249894a08c116e16b465a02f8f899d12b808ccfdd90a3bd" + }, + { + "path": "harness/fixtures/run-timed-bundle-oracle.ps1", + "bytes": 7466, + "sha256": "fab696486a574f9867c6e69a8a8b960e7e9722206441b9cc5f36d41f285f1a25" + }, + { + "path": "harness/fixtures/scenario-authoring/README.md", + "bytes": 14700, + "sha256": "6b651b180b76d10b00bc49d77a8f5e0b3ba0317446978f41b541f5bb23fedad8" + }, + { + "path": "harness/fixtures/scenario-authoring/base/expected-baseline.json", + "bytes": 38589, + "sha256": "abd8246c939ebb8a2162ef82e23d0fb322ee1a8b4d0d7c28a34037e42e86e841" + }, + { + "path": "harness/fixtures/scenario-authoring/base/project.arcadia", + "bytes": 19470, + "sha256": "9b1afbe96b0bf8fa613451b00929492f05a59b9eb2ca74c2c374a8b7bb7cba9e" + }, + { + "path": "harness/fixtures/scenario-authoring/base/rationale.arcadia", + "bytes": 86, + "sha256": "82df210f22f6aa336a3e7e00240977d671c7c3923db7bc58fb29e6d98b67ef49" + }, + { + "path": "harness/fixtures/source7-native/README.md", + "bytes": 7235, + "sha256": "7abccbc3da0980d1d099761d1a66d12c403a0f543954134537ecd4930d182b4b" + }, + { + "path": "harness/fixtures/source7-native/base/expected-baseline.json", + "bytes": 26428, + "sha256": "e2882a58f841f460f45d9d67db1606440e0d7997b9b29a784569ae48e4b23bfb" + }, + { + "path": "harness/fixtures/source7-native/base/project.arcadia", + "bytes": 13616, + "sha256": "5474d8ca05fd1375220dc0ad40d913631fde51159e9632bb9f290d1ecdab8dd7" + }, + { + "path": "harness/fixtures/source7-native/base/rationale.arcadia", + "bytes": 59, + "sha256": "e6a600e13036d4ad594a65380ed1b3d82d1772d583041bb0a624c9588a73047a" + }, + { + "path": "harness/fixtures/source7-native/manifest.json", + "bytes": 410, + "sha256": "6c57164a796234d83818d462d0a25f10e77062d405769e602ae2a7bec251e3b6" + }, + { + "path": "harness/fixtures/staged-source-authoring/README.md", + "bytes": 6876, + "sha256": "502be5e3bf9112447dc07b1a51fe0fa301754b47128a9b81877c185c6e797fee" + }, + { + "path": "harness/fixtures/staged-source-authoring/base/notes.arcadia", + "bytes": 63, + "sha256": "ad9de02963c20d1f43856455a797deb05ca674659e45f2c4b96b52783024f8bd" + }, + { + "path": "harness/fixtures/staged-source-authoring/base/project.arcadia", + "bytes": 593, + "sha256": "aa844950ec4fb86f262a257e1fc370a26557ea7978d8a4cab78265037660234c" + }, + { + "path": "rust-toolchain.toml", + "bytes": 66, + "sha256": "a6a0bbd29ffaa8182dc22d1d9149709f1091e47df40ed96eb8a78a711c66a4ce" + } + ] +} diff --git a/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.log b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.log new file mode 100644 index 00000000..883b8b3c --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.log @@ -0,0 +1,44 @@ + Compiling oa-desktop v0.2.0 (C:\Users\User\Documents\Git\ARCADIA-Studio\crates\oa-desktop) + Finished `test` profile [unoptimized] target(s) in 17m 48s + Running unittests src\main.rs (target\debug\deps\arcadia_studio-e358a5ed59b1de41.exe) + +running 23 tests +test app::diagram_focus_tests::mounted_f2_requires_canvas_focus_and_yields_to_clean_inspector ... ok +test app::diagram_removal_tests::captured_confirmation_rejects_selection_document_revision_and_placement_changes ... ok +test app::diagram_removal_tests::mounted_allocation_work_click_then_delete_without_redraw_removes_placement_once ... ok +test app::diagram_removal_tests::mounted_bend_delete_has_priority_and_semantic_edge_delete_is_confirmed ... ok +test app::diagram_removal_tests::mounted_clean_text_programmatic_focus_and_tab_remove_canvas_keyboard_ownership ... ok +test app::diagram_removal_tests::mounted_inspector_can_take_focus_during_passive_save ... ok +test app::diagram_removal_tests::mounted_oa_sa_delete_hides_exact_placement_and_round_trips_source_and_model ... ok +test app::diagram_removal_tests::mounted_passive_save_never_grants_canvas_focus_or_restores_window_lost_focus ... ok +test app::diagram_removal_tests::mounted_passive_save_retires_held_canvas_drag_but_allows_a_fresh_drag ... ok +test app::diagram_removal_tests::mounted_placement_properties_selection_supports_hide_and_model_delete ... ok +test app::diagram_removal_tests::mounted_programmatic_canvas_entry_needs_no_mouse_focus_boolean ... ok +test app::diagram_removal_tests::mounted_removal_intents_reject_stale_selection_revision_owner_and_document ... ok +test app::diagram_removal_tests::mounted_revision_and_history_preserve_the_actual_canvas_or_inspector_focus_owner ... ok +test app::diagram_removal_tests::mounted_shift_delete_captures_target_cancel_escape_and_confirmation_replay ... ok +test app::diagram_removal_tests::mounted_state_action_and_internal_rows_delete_relations_and_preserve_reused_work ... ok +test app::diagram_removal_tests::mounted_state_delete_uses_state_placement_and_preserves_architecture_placement ... FAILED +test app::diagram_removal_tests::mounted_window_modal_dirty_and_modifier_boundaries_retire_delete_focus ... ok +test app::diagram_selection_tests::changing_visible_view_follows_its_clean_inspector_without_a_model_edit ... ok +test app::diagram_selection_tests::diagram_switch_preserves_an_independent_semantic_inspection ... ok +test app::diagram_selection_tests::diagram_uuid_edit_follows_the_same_view_or_a_different_picker_target ... ok +test app::diagram_selection_tests::invalid_view_draft_blocks_the_switch_and_retains_raw_input ... ok +test app::diagram_selection_tests::stale_diagram_choice_never_applies_an_unrelated_valid_draft ... ok +test app::diagram_selection_tests::valid_pending_view_edit_applies_to_old_view_then_inspects_the_new_view ... ok + +failures: + +---- app::diagram_removal_tests::mounted_state_delete_uses_state_placement_and_preserves_architecture_placement stdout ---- + +thread 'app::diagram_removal_tests::mounted_state_delete_uses_state_placement_and_preserves_architecture_placement' (6984) panicked at crates\oa-desktop\src\app\diagram_removal_tests.rs:1065:36: +called `Option::unwrap()` on a `None` value +note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace + + +failures: + app::diagram_removal_tests::mounted_state_delete_uses_state_placement_and_preserves_architecture_placement + +test result: FAILED. 22 passed; 1 failed; 0 ignored; 0 measured; 799 filtered out; finished in 271.47s + +error: test failed, to rerun pass `-p oa-desktop --bin arcadia-studio` diff --git a/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.result.json b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.result.json new file mode 100644 index 00000000..bd8a6cef --- /dev/null +++ b/harness/experiments/diagram-removal-windows-20260912/focus-24bb248.result.json @@ -0,0 +1,20 @@ +{ + "source": "24bb24839b14353c1a2b668f3bac34235d39f7a7", + "start": "2026-09-12T13:41:39.248143+00:00", + "end": "2026-09-12T14:04:09.176393+00:00", + "exit": 101, + "command": [ + "cargo", + "test", + "--locked", + "-p", + "oa-desktop", + "--bin", + "arcadia-studio", + "app::diagram", + "--", + "--test-threads=1" + ], + "inputs": "focus-24bb248.inputs.json", + "changed_inputs": [] +} diff --git a/harness/release-canvas-followup-20260912.md b/harness/release-canvas-followup-20260912.md new file mode 100644 index 00000000..6def4d89 --- /dev/null +++ b/harness/release-canvas-followup-20260912.md @@ -0,0 +1,77 @@ +# Canvas correction evidence — 2026-09-12 + +This is a branch-specific correction checkpoint, not release acceptance. Live +ownership and acceptance remain in Gitea [15](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/15), +[21](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/21) and +[25](http://217.177.34.108:3000/sorokin.oleg.edu/ARCADIA-Studio/issues/25). + +## Implementation and evidence boundary + +- `24bb248` preserves an existing diagram keyboard owner across revision changes + and passive Save, while suspended input cannot acquire ownership or retain a + held gesture. The Windows `app::diagram` gate passed 22 tests and failed the + persisted state-placement Save/Undo regression. That failure remains archived; + this source did not satisfy the focus acceptance criterion. +- `e2c027e` fixes the underlying state view's positional Iced tree replacement: + optional placement controls now occupy a stable child slot ahead of the canvas. + Hide/Undo no longer changes the canvas widget's position in its parent. The + strengthened test keeps the actual Save/Undo/Delete sequence and observes focus + through each intermediate redraw. Runtime acceptance is pending. +- `956a584` derives activation segments from typed call/receiver/scope identities + and compatible reply correlations. It uses distinct columns for overlapping + calls and exact activation endpoints for replies, including self-calls. The + source includes twelve production-scene tests; their execution and native + legibility/selection checks are pending. Hit tests at small zoom do not establish + raster legibility. The 12-unit bar width and 6-unit offset remain a visual + candidate until the actual application has been inspected. +- `b25065c` removes the redundant Canvas and Focus canvas/Restore panels buttons. + Pointer editing already worked without activation. Strict all-target Clippy at + combined source `e2c027e54c6be0d051820374f669c52278d90f97` failed on two obsolete + `CanvasEvent::Focus` variants used only by tests. The 533 recorded inputs were + unchanged. Removing the stale panel-mode paths and updating dependent tests is + required before a new gate; warnings are not suppressed. + +The [closed gate receipts](experiments/diagram-removal-windows-20260912/archive-manifest.json) +identify the exact commands, input bytes, source commits, failures and logs. +Earlier full-suite and native results in +[the deletion report](release-delete-native-f7-20260912.md) do not establish +acceptance of these production changes. + +## Scenario evaluator preparation + +The [26-payload archive](experiments/canvas-editing-followup-20260912/manifest.json) +preserves design/review notes, fixture builders, exact build/run receipts and +generated source. Builders link the identified existing core artifacts only +after verifying their source inputs against the completed core-containing gate; +this is not a desktop build or desktop rendering check. + +The draft fixture passes core validation and complete canonical round trip with +132 elements and 77 completeness warnings. It covers OA/SA nested, sequential, +crossed, self, reentrant, open, ALT and PAR cases. It deliberately lacks exchange +bindings and values, so a separate bound fixture supplies those checks. + +The corrected bound fixture compiles with warnings denied and generates three +scenarios with 34 elements, 6 relations, zero errors and two completeness warnings. +It preserves complete Project canonical round trip and exact SA operation +resolution. OA uses an Operation information item carried by an Interaction; SA +uses standard component ports, required/provided interfaces, synchronous item +allocation, a boundary exchange and explicit Call operation use. Replies derive +the exact correlated Call allocation. A third OA scenario exercises reentrant +calls using the explicit reverse Interaction. + +The nested sequence is C1, C2, R2, R1. Requests are 420.0 and 380.0 kPa; replies +are 418.0 and 378.0 kPa. Unicode labels are preserved. The generated +[identity table](experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/scenario-identities.tsv) +and [model](experiments/canvas-editing-followup-20260912/bound-nested-fixture-r1-20260912/bound-nested-calls.arcadia) +make native selection and value inspection reproducible. + +The first bound builder compiled but failed during fixture construction: it used +the OA Actor kind for SA and attempted a generic Port constructor. Its exact +source and failure receipts are preserved. The correction uses SystemActor and +the dedicated port constructor; validation assertions were retained. + +Full desktop tests, strict lint, matching GUI build, native Save/Undo focus, +bound nested-call rendering and direct pointer/text-focus workflows remain +required. Broader process/scenario free placement, resizing and the Details +redesign are separate outstanding requirements; these corrections do not close +them. Linux/WSL checking remains deferred by the user. diff --git a/harness/release-diagram-removal-windows-20260912.md b/harness/release-diagram-removal-windows-20260912.md index 84cea4c9..8e3336f6 100644 --- a/harness/release-diagram-removal-windows-20260912.md +++ b/harness/release-diagram-removal-windows-20260912.md @@ -12,6 +12,8 @@ This records source-specific Windows evidence, not a completed release or whole- | `cb46ef40543bff12634e7fa823a588224d54f3cf` | complete desktop binary suite | compile failed: scenario tool accessor visibility | 531 | | `4c387ccd640976ba89dd03ee922a3f63ff92b07c` | complete desktop binary suite | 817 passed, 1 failed | 531 | | `42511f0f8ae46f29e11ae18c1030face654c2994` | complete desktop binary suite | 818 passed, 0 failed/ignored | 531 | +| `24bb24839b14353c1a2b668f3bac34235d39f7a7` | filter `app::diagram` after native focus correction | 22 passed, 1 failed | 531 | +| `e2c027e54c6be0d051820374f669c52278d90f97` | strict all-target desktop Clippy after combined canvas corrections | failed: two obsolete Focus event variants | 533 | All ran through `.local/run-allocation-gate.py` with `.local/toolchain/env.ps1`, Rust/Cargo 1.98.1 Windows GNU LLVM, LLVM-MinGW 20260908, serialized compilation. Full command omits the filter. Exact start/end, exit codes, commands, source SHA and file hashes are in the [archive manifest](experiments/diagram-removal-windows-20260912/archive-manifest.json) and linked receipt files. @@ -32,3 +34,5 @@ Clippy at 42511f0 found two cloned single-item test slices. The exact borrowed-s At **f7d84faf30cdb5e3695c2dc16ee0a5f2eac91e71**, `cargo clippy --locked -p oa-desktop --all-targets -- -D warnings` and `cargo build --locked -p oa-desktop --bin arcadia-studio` both passed. Each identified all 531 inputs and observed no changes; manifest SHA256 `8c35625a7ba22f210219e8f4e0d61605cf09625e752796f1eb48921e4c2edc0c`. The full 818-test evidence remains scoped to 42511f0; staging verified that the only intervening tested-code changes were the two borrowed test slices and test-only accessor annotation. No full f7 test run is claimed. Native f7 testing subsequently found lost canvas keyboard focus across Save/Undo: Shift+Delete required another click. Successful exact saved-model checks do not excuse that interaction defect. Native acceptance and the complete OA/SA goal remain open; current ownership and correction work are recorded in Gitea #15. + +The reviewed focus correction at 24bb248 built successfully, then its targeted run ended on 2026-09-12 at 14:04:09 UTC with 22 passes and one failure. The exact allocation Save/Undo/Redo/Undo/Shift+Delete regression, real Inspector ownership during Save, window loss and interrupted/fresh drag cases passed. The persisted-state placement Save/Undo/Shift+Delete sequence did not open its confirmation (`diagram_removal_tests.rs:1065`). The test remains unchanged as a required regression. All 531 inputs remained fixed, manifest SHA256 `53c3c1cb5b0766324ad9338b8101f7317610c182916e18d1debda20b8c8af08d`; compile 17m48s and tests 271.47s. This failed gate cannot be reused as native or full-suite acceptance.