Verify compact source editing in the native application

Preserve raw include diagnostic provenance and derive bands from the existing shaped editor. Retain deferred tooltip paragraphs through rendering. Include source, regression, failure and native-trial evidence; corrected native acceptance remains pending.

.gitattributes

@@ -15,77 +15,94 @@
 
 # Exact source/recovery oracles and archived ledgers retain their measured bytes.
 # Keep ordinary text diffs; only disable checkout/check-in newline conversion.
-PROJECT_GOAL.md -text whitespace=cr-at-eol
 harness/fixtures/release1-native/** -text
 harness/fixtures/interface-operation-probe/** -text
 harness/history/2026-09-06-ledgers-before-consolidation/** -text
-harness/history/2026-09-10-ledgers-before-continuation-refresh/** -text
 harness/history/2026-09-10-ledgers-before-second-consolidation/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
 harness/experiments/textual-authoring-20260911-local/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
-crates/oa-desktop/src/recovery/fixtures/*.json -text
-crates/oa-core/src/analysis_numeric/fixtures/** -text whitespace=cr-at-eol
-harness/fixtures/source7-native/** -text
-harness/fixtures/basic-editing/** -text
-harness/fixtures/scenario-authoring/base/** -text whitespace=cr-at-eol
+harness/experiments/constructor-defaults-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/constructor-defaults-20260911/results/*.arcadia whitespace=-blank-at-eol,cr-at-eol
+harness/experiments/behavior-creation-native-20260911/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol
+harness/experiments/analysis-context-20260911/** -text whitespace=cr-at-eol
 harness/experiments/textual-authoring-20260911/** -text whitespace=cr-at-eol
 harness/experiments/textual-authoring-20260911/observed/split-entry.arcadia whitespace=-blank-at-eol,cr-at-eol
-harness/experiments/analysis-context-20260911/** -text whitespace=cr-at-eol
-harness/experiments/analysis-baseline-20260911/** -text whitespace=cr-at-eol
-harness/experiments/library-compatibility-20260911/** -text whitespace=cr-at-eol
-harness/experiments/refined-contracts-review-20260911/** -text whitespace=cr-at-eol
+harness/fixtures/scenario-authoring/base/** -text whitespace=cr-at-eol
+crates/oa-desktop/src/recovery/fixtures/*.json -text
+harness/fixtures/source7-native/** -text
+harness/fixtures/basic-editing/** -text
 harness/behavior-creation-contract.rs -text whitespace=cr-at-eol
 harness/experiments/source-cli-independent-20260911/** -text whitespace=cr-at-eol
 harness/experiments/authoring-prerelease-20260911/** -text whitespace=cr-at-eol
 harness/experiments/cli-packaging-20260911/** -text whitespace=cr-at-eol
 harness/experiments/cli-prerelease-20260911/** -text whitespace=cr-at-eol
 harness/experiments/contextual-source-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-native-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-reopen-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-native-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-reboot-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-source-layout-reboot-20260911/run-gates2.ps1 whitespace=-blank-at-eof,cr-at-eol
 harness/experiments/contextual-source-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/scenario-native-local-20260911/** -text whitespace=cr-at-eol
+harness/experiments/scenario-native-local-20260911/**/*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/scenario-native-local-20260911/**/*.arcadia whitespace=-blank-at-eol,cr-at-eol
 harness/fixtures/staged-source-authoring/** -text whitespace=cr-at-eol
 harness/staged-source-authoring-contract.rs -text whitespace=cr-at-eol
 
 # Preserve checksum-bound font notices verbatim through Git round trips.
+harness/experiments/wsl-capacity-20260911/** -text whitespace=cr-at-eol
+harness/experiments/wsl-postboot-9e8r6t-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-postboot-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-verified-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-layout-full-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
 scripts/windows-notices/GNOME-Cantarell-61362600e104-COPYING -text
 scripts/windows-notices/Fira-OFL.txt -text
 scripts/windows-notices/FiraSans-Regular-NOTICE.txt -text
-harness/experiments/behavior-creation-native-20260911/** -text whitespace=cr-at-eol
-harness/experiments/constructor-defaults-20260911/** -text whitespace=cr-at-eol
-harness/experiments/constructor-defaults-20260911/results/*.arcadia whitespace=-blank-at-eol,cr-at-eol
-harness/release-scenario-native-9e8r6t-20260911.md -text whitespace=cr-at-eol
-harness/experiments/analysis-numeric-gate-20260911/** -text
-harness/experiments/chooser-correction-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/chooser-lint-gate-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/history/2026-09-11-behavior-wiki-before-refresh.md -text whitespace=cr-at-eol
-# Preserve the independently fingerprinted historical review verbatim.
-harness/release-behavior-canvas-phase1-review-20260911.md -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/scenario-native-3c9e6ee-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/scenario-native-3c9e6ee-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/analysis-codec-windows-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/history/2026-09-11-ledgers-before-gitea-migration/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/canvas-union-windows-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
-harness/experiments/canvas-a31b40d-windows-native-20260911/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/allocation-d9b3f0d-windows-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/allocation-3840ca2-pause-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-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
-harness/experiments/resize-port-policy-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/canvas-native-83f53c7-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/nested-lifecycle-union-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/canvas-native-d61f1f3-20260912/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/lifecycle-fixture-preflight-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/palette-readability-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/release-analysis-next-acceptance-20260913.md -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/runtime-notices-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/analysis-checked-save-windows-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/canvas-native-dd39e1f-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/navigation-palette-e124029-windows-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/navigation-native-preparation-e124029-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/analysis-source-s0-s1-windows-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/experiments/analysis-source3-bridge-windows-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-harness/scenario-analysis-version-integration-review-20260913.md -text whitespace=cr-at-eol
-harness/scenario-analysis-version-integration-inputs-20260913.json -text whitespace=cr-at-eol
-harness/experiments/analysis-source-s2a-windows-20260913/** -text whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
-
-# Preserve the pinned Iced dependency bytes and upstream manifest.
+harness/experiments/contextual-source-recovery-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-machine-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-lifeline-v2-20260911/** -text whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-lifeline-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-machine-v2-20260911/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-source-reopen-20260911/launch-method.ps1 whitespace=-blank-at-eof,cr-at-eol
+# Raw compact.exe output includes CR-CR-LF and incidental trailing spaces.
+harness/experiments/wsl-capacity-20260911/*.log -whitespace
+harness/experiments/contextual-prerelease-20260911/** -text whitespace=cr-at-eol
+harness/experiments/contextual-prerelease-publication-20260911/** -text whitespace=cr-at-eol
+harness/history/2026-09-11-state-before-gitea-migration/** -text whitespace=cr-at-eol
+harness/experiments/contextual-prerelease-20260911/native/**/*.arcadia whitespace=-blank-at-eol,-blank-at-eof,cr-at-eol
+harness/experiments/contextual-prerelease-20260911/producer/package*.log whitespace=-blank-at-eof,cr-at-eol
+harness/experiments/contextual-prerelease-20260911/producer/source-push.log -whitespace
+harness/experiments/source-alias-rename-native-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-completed-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-refresh-20260912/** -text whitespace=cr-at-eol
+harness/experiments/source-alias-rename-native-closure-20260912/** -text whitespace=cr-at-eol
+# Preserve Text-workspace input, native and review evidence at its recorded bytes.
+harness/experiments/text-workspace-initial-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-workspace-initial-review-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-find-selection-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-workspace-native2-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-workspace-followup-review-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-workspace-native3-20260913/** -text whitespace=cr-at-eol
+# These checksum-bound baseline/expected fixtures deliberately end with blank lines.
+harness/experiments/text-workspace-native2-20260913/fixtures/**/*.arcadia whitespace=-blank-at-eof,cr-at-eol
+# Captured process streams retain intentional blank lines and diagnostic spacing.
+harness/experiments/text-find-selection-20260913/**/*.log -whitespace
+harness/experiments/text-workspace-initial-20260913/**/*.log -whitespace
+harness/experiments/text-workspace-native2-20260913/**/*.log -whitespace
+harness/experiments/text-workspace-native3-20260913/**/*.log -whitespace
+# Preserve the pinned dependency and diagnostic verification records verbatim.
 crates/vendor/iced_widget/** -text whitespace=cr-at-eol
+harness/experiments/text-diagnostics-20260913/** -text whitespace=cr-at-eol
+harness/experiments/text-diagnostics-20260913/**/*.log -whitespace
+# Preserve default-omission failure evidence and captured input manifests verbatim.
+harness/experiments/default-omission-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-omission-20260913/**/*.log -whitespace
+harness/experiments/default-admission-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-admission-20260913/**/*.log -whitespace
+harness/experiments/default-policy-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-policy-20260913/**/*.log -whitespace
+harness/experiments/default-fidelity-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-fidelity-20260913/**/*.log -whitespace
+harness/experiments/default-production-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-followup-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-consumers-20260913/** -text whitespace=cr-at-eol
+harness/experiments/default-native-20260913/** -text whitespace=cr-at-eol

AGENTS.md

@@ -4,12 +4,12 @@
 
 - Follow `PROJECT_GOAL.md` and the user's current instructions. Work autonomously within scope. Resolve discoverable questions yourself; record, test, and revise reversible assumptions. Ask only when a consequential decision needs information or authorization not already available. Continue independent useful work while blocked elsewhere.
 - Map unfamiliar domains through primary sources, comparable systems, and real user workflows. Identify underlying needs, valuable concepts, and avoidable friction; evaluate improvements rather than merely reproducing features. Synthesize findings into decisions or experiments, and stop research when another action offers greater value.
-- Make specifications precise enough for compatible independent implementations: definitions, relationships, invariants, valid / invalid examples, and lifecycle or transformation rules where relevant. Trace important requirements and decisions to implementation and verification. Resolve specification ambiguity at its source when implementation exposes it.
+- Make specifications precise enough for compatible independent implementations: definitions, relationships, invariants, valid/invalid examples, and lifecycle or transformation rules where relevant. Trace important requirements and decisions to implementation and verification. Resolve specification ambiguity at its source when implementation exposes it.
 - For consequential uncertain choices, compare materially different candidates against explicit user-derived criteria. Ask independent critics to challenge assumptions and attempt to falsify proposals; refine or replace candidates as evidence warrants. Record the choice, evidence, tradeoffs, rejected approaches, and reasons to revisit it. Use proportionate effort for reversible local choices.
 - Plan milestones that resolve uncertainty or deliver useful capability, with explicit dependencies. Test foundational assumptions before substantial downstream work. At checkpoints, assess progress toward the actual objective and replan when evidence invalidates the strategy or progress stalls.
 - Define observable success and suitable evaluators before repeated improvement: invariants, examples, round trips, transformations, performance checks, realistic user tasks, or explicit review rubrics. Ensure the evaluator measures the intended outcome. For experiments, record the question, expectations, method, result, and implications; isolate exploratory prototypes from production architecture.
-- Build and run meaningful changes, exercise actual behavior, and inspect useful logs. Investigate crashes, serious warnings, corrupted state, and interaction defects. For GUI work, use Computer Use or equivalent tools to inspect realistic workflows, cognitive load, editing / selection, navigation, feedback, recovery, loading / empty / failure states, accessibility, layout, focus / disabled states, and responsiveness.
-- Match independent reviews to the artifact and risks. For languages or formats, include ambiguity, round trips, human / AI editability, and version-control behavior where relevant. Verify findings, fix the appropriate conceptual, specification, architectural, implementation, or interaction layer, and recheck affected dependents. Reuse valid evidence; repeat checks for concrete risks, changes, findings, or required gates. Compilation, screenshots, and worker reports alone do not establish correctness or usability.
+- Build and run meaningful changes, exercise actual behavior, and inspect useful logs. Investigate crashes, serious warnings, corrupted state, and interaction defects. For GUI work, use Computer Use or equivalent tools to inspect realistic workflows, cognitive load, editing/selection, navigation, feedback, recovery, loading/empty/failure states, accessibility, layout, focus/disabled states, and responsiveness.
+- Match independent reviews to the artifact and risks. For languages or formats, include ambiguity, round trips, human/AI editability, and version-control behavior where relevant. Verify findings, fix the appropriate conceptual, specification, architectural, implementation, or interaction layer, and recheck affected dependents. Reuse valid evidence; repeat checks for concrete risks, changes, findings, or required gates. Compilation, screenshots, and worker reports alone do not establish correctness or usability.
 - Favor the simplest maintainable design satisfying known requirements and justified extensibility. Avoid speculative abstraction, unrelated refactoring, and repeating approaches already invalidated by evidence.
 
 ## User input
@@ -24,10 +24,10 @@ Keep one authoritative home for each kind of information. Use links and brief sc
 
 | Information | Authoritative home |
 | --- | --- |
-| Live plans, priorities, dependencies, ownership, status, blockers, and handoffs | Gitea issues / milestones; linked PRs hold change review and validation. |
-| Specifications, architecture, interfaces, and build / run documentation | Established version-controlled project documents. |
+| Live plans, priorities, dependencies, ownership, status, blockers, and handoffs | Gitea issues/milestones; linked PRs hold change review and validation. |
+| Specifications, architecture, interfaces, and build/run documentation | Established version-controlled project documents. |
 | Durable decisions and reusable evidence | `harness/DECISIONS.md` and relevant topic notes, or existing equivalents. |
-| Navigation and integrated-state checkpoint | `harness/STATE.md`: links, verified code commit / release, capabilities, and material limitations. No live task ledger. |
+| Navigation and integrated-state checkpoint | `harness/STATE.md`: links, verified code commit/release, capabilities, and material limitations. No live task ledger. |
 | Shared entrypoint | Gitea Wiki: overview and links, without duplicating versioned documentation. |
 | Published deliverables | Gitea releases, tied to source commits and verification. |
 
@@ -38,9 +38,9 @@ Use Gitea for live coordination and the relevant code version for implementation
 All independent agents coordinating through Gitea run on completely separate machines, each with its own clone, filesystem, tools, processes, and runtime. Gitea and pushed Git history are the shared communication and delivery channels. Local files (including `harness`), unpushed commits, worktrees, test results, and localhost services are not accessible to peers. Matching branch names or paths do not imply synchronized contents.
 
 1. On starting or resuming, including after compaction, inspect the working branch, local changes, applicable instructions, relevant shared records, and existing implementation. Recover context from authoritative records. Check for newer shared instructions on the actual remote default branch without overwriting local work. Read what is relevant; avoid repeated full-history scans and constant polling.
-2. Search before creating tasks. Claim a meaningful outcome in its Gitea issue with a stable session identity, scope, remote repository / branch, and acceptance criteria. Keep small steps within that task. Recheck after claiming; comments are not atomic locks. Respect existing ownership and resolve overlapping claims before overlapping work.
-3. Independent sessions are peers. Each owns its contribution and delegated work on its own machine. Record one integration / release owner when a milestone needs shared coordination. Use distinct remote work branches, partition files / interfaces, and coordinate changes to shared specifications and documents. Worktrees provide local isolation only; they do not share work between machines.
-4. At meaningful checkpoints or handoffs, record changed results, commit / PR links, verification commands and environment, blockers, and next actions. Identify the tested code version and label uncommitted or unpublished work as local-only. Before asking peers to consume results, push the required code and versioned documentation, including relevant `harness` updates; publish other required artifacts in Gitea and link them. Use repository-relative paths with commit references, reproducible commands, and necessary environment details; local paths and localhost URLs alone are not handoffs. Do not assume another agent is running or has read a message; silence alone does not establish abandonment. Record evidence and preserve existing work when reassigning a task.
+2. Search before creating tasks. Claim a meaningful outcome in its Gitea issue with a stable session identity, scope, remote repository/branch, and acceptance criteria. Keep small steps within that task. Recheck after claiming; comments are not atomic locks. Respect existing ownership and resolve overlapping claims before overlapping work.
+3. Independent sessions are peers. Each owns its contribution and delegated work on its own machine. Record one integration/release owner when a milestone needs shared coordination. Use distinct remote work branches, partition files/interfaces, and coordinate changes to shared specifications and documents. Worktrees provide local isolation only; they do not share work between machines.
+4. At meaningful checkpoints or handoffs, record changed results, commit/PR links, verification commands and environment, blockers, and next actions. Identify the tested code version and label uncommitted or unpublished work as local-only. Before asking peers to consume results, push the required code and versioned documentation, including relevant `harness` updates; publish other required artifacts in Gitea and link them. Use repository-relative paths with commit references, reproducible commands, and necessary environment details; local paths and localhost URLs alone are not handoffs. Do not assume another agent is running or has read a message; silence alone does not establish abandonment. Record evidence and preserve existing work when reassigning a task.
 5. Follow project review and merge conventions. Fetch the relevant remote branches and inspect the identified commits before reviewing or integrating another machine's work. Resolve conflicts while preserving others' edits, and verify the combined result locally; report material environment differences. Local instruction-file edits reach peers only after publication and retrieval. Do not overwrite others' work or force-push shared history to resolve coordination problems.
 6. Close work when its acceptance criteria are met and the result is integrated or delivered as appropriate. Mark duplicates and superseded tasks explicitly with replacement links. Then choose further useful unowned work while the requested objective remains incomplete.
 
@@ -64,10 +64,10 @@ Preserve concise records of decisions and rationale, useful experiments, failed
 
 Consolidate duplicates, repair stale guidance, and remove obsolete temporary files alongside useful project work. Before removing material, check references, active ownership, and ongoing use; preserve unique knowledge and update affected links. Prefer closing, superseding, or archiving history over deletion. User input is excluded from autonomous cleanup.
 
-If legacy local task ledgers or plans duplicate Gitea, migrate their live content once into existing or appropriately scoped issues, preserve useful decisions / evidence, and mark the old records superseded. Record the migration so later sessions do not repeat it. Do not create empty documents or maintain records for ceremony.
+If legacy local task ledgers or plans duplicate Gitea, migrate their live content once into existing or appropriately scoped issues, preserve useful decisions/evidence, and mark the old records superseded. Record the migration so later sessions do not repeat it. Do not create empty documents or maintain records for ceremony.
 
 ## Delivery
 
-Publish versioned Gitea releases at meaningful working milestones; mark unfinished versions as prereleases. Check existing releases / tags and coordinate one owner and version before publishing. Build from an identified integrated commit and verify the packaged result and launch steps.
+Publish versioned Gitea releases at meaningful working milestones; mark unfinished versions as prereleases. Check existing releases/tags and coordinate one owner and version before publishing. Build from an identified integrated commit and verify the packaged result and launch steps.
 
-Include runnable builds or appropriate artifacts, concise release notes, build / run / deployment instructions as applicable, known limitations, tested platforms, and verification evidence. Confirm publication and artifact availability. Use existing authorized API access or project tooling when MCP lacks a needed release / upload operation. Do not silently replace published versions with different contents.
+Include runnable builds or appropriate artifacts, concise release notes, build/run/deployment instructions as applicable, known limitations, tested platforms, and verification evidence. Confirm publication and artifact availability. Use existing authorized API access or project tooling when MCP lacks a needed release/upload operation. Do not silently replace published versions with different contents.

Cargo.lock

@@ -2105,25 +2105,6 @@ dependencies = [
  "jni-sys 0.3.1",
 ]
 
-[[package]]
-name = "num-bigint"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2170,9 +2151,6 @@ name = "oa-core"
 version = "0.2.0"
 dependencies = [
  "libc",
- "num-bigint",
- "num-integer",
- "num-traits",
  "same-file",
  "serde",
  "serde_json",

PROJECT_GOAL.md

@@ -17,14 +17,14 @@ Apply these criteria to the scope requested by the user:
 - Consequential decisions have evidence and rationale. Major assumptions have been validated, explicitly accepted, or isolated without compromising required behavior.
 - The result builds, runs, and operates on the required platforms. Relevant tests and evaluators pass; integrations, edge cases, and failure states have been exercised against the actual result.
 - User-facing behavior and usability have been exercised directly, using representative data and workflows.
-- A fresh independent review covers requirements, domain / semantic consistency, usability, architecture, correctness, regressions, runtime behavior, documentation, and remaining risks. Valid material findings are addressed, blocking and high-impact issues resolved, and affected behavior reverified; no known blocker or high-severity defect remains.
+- A fresh independent review covers requirements, domain/semantic consistency, usability, architecture, correctness, regressions, runtime behavior, documentation, and remaining risks. Valid material findings are addressed, blocking and high-impact issues resolved, and affected behavior reverified; no known blocker or high-severity defect remains.
 - Deliverables are maintainable, appropriately extensible, documented, and published as required by `AGENTS.md`. Obsolete scaffolding is removed; documentation and shared state accurately describe the result. Another engineer or agent can reproduce the verification and continue the work.
 
 If required work or verification is blocked, record the specific gap and continue independent useful work without claiming completion.
 
 ## Final handoff
 
-Link the delivered result and summarize capabilities, discoveries, architecture and decisions, relevant rejected approaches, verification and independent review, remaining limitations, and exact build / run / deployment / verification instructions. Refer to authoritative records instead of repeating the project history.
+Link the delivered result and summarize capabilities, discoveries, architecture and decisions, relevant rejected approaches, verification and independent review, remaining limitations, and exact build/run/deployment/verification instructions. Refer to authoritative records instead of repeating the project history.
 
 ## USER-OWNED APPLICATION SPECIFICATION
 

README.md

@@ -94,13 +94,11 @@ Create named **Exchange categories** at the perspective root to group Work excha
 
 In **Select / move**, drag cards on a 10-unit grid, drag empty space to pan, and scroll to zoom. Drag ports along their owner's border or onto any of its four sides. Automatic sides account for direction and visible connections. Manual positions are per diagram and remain relative to the owner through movement or resize; right-click **Reset automatic position** restores automatic placement. **Arrange** changes the current view layout; **Fit** frames its projected bounds. SVG exports the current architecture diagram as a view, not an editable model file.
 
-In saved architecture and State views, **Shift+click** adds or removes an exact displayed item; its context menu also offers **Add to selection** and **Remove from selection**. Properties edits only the primary item. Drag a selected member to move a placement-only group in one operation, including visual descendants once and the authored pins of connections whose endpoint owners move together. A stationary click selects only that member; Escape during a drag cancels it and keeps the group. **Hide selected** removes only selected placements, preserving model elements, unselected descendant placements and other views; one Undo restores the operation. Groups containing connections, ports or State action/internal-transition rows cannot be moved or hidden as placement groups. State rows select their relation, never their owning placement. Dragging a group of allocated work cards and deleting a group from the model remain unavailable; these actions refuse the whole group instead of editing just its primary item. Selection itself is temporary and is not saved.
-
 Connections start with orthogonal routes that avoid cards and container headers. In Select mode, select a connection and drag a segment to add a bend, or right-click for **Add bend here**. Drag its circles to adjust the route; the menu offers **Remove bend** and **Reset routing**. With the canvas focused, Insert adds a bend and Delete removes the selected bend. Shift+F10 opens the selected item's menu; **Actions** in Properties provides the same commands. Drag the connection label independently. Each completed gesture is one undoable edit; Escape cancels a drag. Routes belong to the current diagram and persist in source, JSON, REST and SVG export. Folding an endpoint container temporarily uses an automatic route; expanding it restores your authored route. Dense diagrams can still need manual adjustment; automatic routing is bounded and does not guarantee an overlap-free result.
 
 For state diagrams, use **+ Region** inside a highlighted machine or State/Mode, then choose **+ State / symbol** and click its owning region. **Transition** supports dragging between compatible vertices or clicking the source and then the target. Select a drawn transition and drag its endpoint handle, or right-click **Reconnect source/target**. Right-click a state or the background for **New transition with details…** to create Local, Internal or timed transitions; an existing transition's **Edit transition** form edits its kind, triggers, guard and effects. EntryPoint outgoing transitions use Local.
 
-In the state view, **Select / move** drags vertices and containers without reparenting or grid snapping; container movement includes its descendants. Multiple selected placements share the same fractional displacement, including authored positions of boundary symbols. State route bends retain their separate 5-unit grid. Middle-button drag pans, scroll or **−/+** zooms, and **Fit** frames the view. Right-click for **Fold contents**, **Unfold contents**, **Placement properties**, or **Hide from this diagram**. The **Show an element not yet in this view…** selector restores missing placements. Escape cancels a gesture; **Undo** restores a completed edit. **+ View** creates an independent layout. The persisted diagram's machine reference and placements are the same records in source, JSON and REST; opening the page alone creates no diagram.
+In the state view, **Select / move** drags vertices and containers without reparenting; container movement includes its descendants. Middle-button drag pans, scroll or **−/+** zooms, and **Fit** frames the view. Right-click for **Fold contents**, **Unfold contents**, **Placement properties**, or **Hide from this diagram**. The **Show an element not yet in this view…** selector restores missing placements. Escape cancels a gesture; **Undo** restores a completed edit. **+ View** creates an independent layout. The persisted diagram's machine reference and placements are the same records in source, JSON and REST; opening the page alone creates no diagram.
 
 ## Edit the same model as text
 

crates/oa-core/Cargo.toml

@@ -12,9 +12,6 @@ uuid.workspace = true
 thiserror.workspace = true
 tempfile = "3"
 same-file = "1"
-num-bigint = "0.5.1"
-num-integer = "0.1.47"
-num-traits = "0.2.19"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libc = "0.2"

crates/oa-core/examples/allocation_multiselect_native.rs

@@ -1,768 +0,0 @@
-//! Deterministic native fixture and literal complete-Project Allocation oracle.
-//! No desktop planner, inferred output delta, or GUI input is used by this oracle.
-use oa_core::{source_project::*, *};
-use std::{collections::BTreeMap, fs, io::Write, path::Path};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-const MODES: [&str; 6] = [
-    "unchanged",
-    "oa-assigned",
-    "sa-assigned",
-    "oa-arranged",
-    "sa-arranged",
-    "oa-performers",
-];
-
-fn id(alias: &str) -> Id {
-    if alias == "oa_assign" {
-        return Id::from_u128(0x292609230001);
-    }
-    Id::new_v5(
-        &Id::from_u128(0xc1192026_0923_5000_8000_000000002931),
-        alias.as_bytes(),
-    )
-}
-fn xy(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-fn named(scope: &str, suffix: &str) -> String {
-    format!("{scope}_{suffix}")
-}
-fn need(ok: bool, message: impl Into<String>) -> Result<()> {
-    if ok {
-        Ok(())
-    } else {
-        Err(message.into().into())
-    }
-}
-fn element(p: &mut Project, alias: &str, name: &str, kind: Kind, layer: Layer) {
-    p.elements.insert(
-        id(alias),
-        Element {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: format!("Preserve engineering record {alias}."),
-            parent: None,
-            body: ElementBody::new(kind, layer).unwrap(),
-        },
-    );
-}
-fn diagram(p: &mut Project, alias: &str, name: &str, layer: Layer, projection: ProjectionKind) {
-    p.diagrams.insert(
-        id(alias),
-        Diagram {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: "Native group fixture; preserve unrelated records exactly.".into(),
-            layer,
-            projection,
-            layout: None,
-            view_options: Default::default(),
-            nodes: Default::default(),
-            routes: vec![],
-        },
-    );
-}
-fn place(p: &mut Project, scope: &str, suffix: &str, position: Position) {
-    let alias = named(scope, &format!("node_{suffix}"));
-    p.diagrams.get_mut(&id(scope)).unwrap().nodes.insert(
-        id(&alias),
-        NodePlacement {
-            id: id(&alias),
-            alias,
-            element: id(&named(scope, suffix)),
-            position,
-            size: Size {
-                width: 224.,
-                height: 94.,
-            },
-            collapsed: false,
-            port_anchors: vec![],
-        },
-    );
-}
-fn relation(
-    p: &mut Project,
-    scope: &str,
-    suffix: &str,
-    kind: RelationKind,
-    from: &str,
-    to: &str,
-) -> Result<()> {
-    let alias = named(scope, suffix);
-    let old = p.relate(
-        kind,
-        &format!("{scope} {suffix}"),
-        id(&named(scope, from)),
-        id(&named(scope, to)),
-    );
-    reidentify(p, old, id(&alias))?;
-    let r = p.relations.get_mut(&id(&alias)).unwrap();
-    r.alias = alias.clone();
-    r.description = format!("Reviewed identity and provenance {alias} must survive.");
-    // The actual constructor creates proper SA function contracts. Normalize
-    // every generated identity/alias; no random UUID can leak into the fixture.
-    let ports = match r.body {
-        RelationBody::FunctionalExchange {
-            source_port,
-            target_port,
-            ..
-        } => Some([source_port, target_port]),
-        _ => None,
-    };
-    if let Some(ports) = ports {
-        for (old_port, suffix) in ports.into_iter().zip(["output", "input"]) {
-            let alias = format!("{alias}_{suffix}");
-            reidentify(p, old_port, id(&alias))?;
-            let port = p.elements.get_mut(&id(&alias)).unwrap();
-            port.alias = alias.clone();
-            port.name = format!("{scope} {suffix}");
-            port.description = format!("Preserved typed endpoint {alias}.");
-        }
-    }
-    Ok(())
-}
-fn route(scope: &str, pins: [Position; 2]) -> EdgeRoute {
-    EdgeRoute {
-        edge: id(&named(scope, "exchange")),
-        waypoints: pins.to_vec(),
-        source_attachment: None,
-        target_attachment: None,
-        label: Some(EdgeLabel {
-            fraction: 0.45,
-            offset: xy(7., -19.),
-        }),
-    }
-}
-fn fixture() -> Result<Project> {
-    let mut p = Project::empty();
-    p.id = id("project");
-    p.alias = "allocation_multiselect_native".into();
-    p.name = "Allocation group native".into();
-    p.description = "Four independent compact OA/SA assignment and Arrange trials; ordinary performers use fresh OA assign baseline.".into();
-    for (layer, prefix, work, performer) in [
-        (Layer::Oa, "oa", Kind::Activity, Kind::Entity),
-        (Layer::Sa, "sa", Kind::Function, Kind::SystemActor),
-    ] {
-        for arrange in [false, true] {
-            let scope = format!("{prefix}_{}", if arrange { "arrange" } else { "assign" });
-            let number = match (prefix, arrange) {
-                ("oa", false) => "01",
-                ("sa", false) => "02",
-                ("oa", true) => "03",
-                _ => "04",
-            };
-            diagram(
-                &mut p,
-                &scope,
-                &format!(
-                    "{number} {} {}",
-                    prefix.to_uppercase(),
-                    if arrange { "arrange" } else { "assign" }
-                ),
-                layer,
-                ProjectionKind::Allocation,
-            );
-            let records: Vec<_> = if arrange {
-                vec![
-                    ("p", "P - team", performer, xy(40., 40.)),
-                    ("u", "U - contained work", work, xy(80., 140.)),
-                    ("v", "V - independent work", work, xy(440., 140.)),
-                ]
-            } else {
-                vec![
-                    ("a", "A - origin team", performer, xy(43., 47.)),
-                    // Leave room for SA Y's automatic top port stub below
-                    // B's 64-unit header plus 12-unit routing clearance.
-                    ("b", "B - other team", performer, xy(43., 337.)),
-                    ("c", "C - destination", performer, xy(500., 40.)),
-                    ("x", "X - receive", work, xy(80., 140.)),
-                    ("y", "Y - assess", work, xy(80., 440.)),
-                ]
-            };
-            for (suffix, label, kind, pos) in records {
-                // SA admits one System for the entire project, not one per view.
-                let kind = if layer == Layer::Sa && !arrange && suffix == "a" {
-                    Kind::System
-                } else {
-                    kind
-                };
-                element(&mut p, &named(&scope, suffix), label, kind, layer);
-                place(&mut p, &scope, suffix, pos);
-            }
-            let (from, to, pins) = if arrange {
-                relation(&mut p, &scope, "pu", RelationKind::Allocation, "p", "u")?;
-                ("u", "v", [xy(360., 180.), xy(360., 230.)])
-            } else {
-                p.diagrams
-                    .get_mut(&id(&scope))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id(&named(&scope, "node_c")))
-                    .unwrap()
-                    .size = Size {
-                    width: 360.,
-                    height: 600.,
-                };
-                relation(&mut p, &scope, "ax", RelationKind::Allocation, "a", "x")?;
-                relation(&mut p, &scope, "by", RelationKind::Allocation, "b", "y")?;
-                ("x", "y", [xy(340., 260.), xy(340., 400.)])
-            };
-            relation(
-                &mut p,
-                &scope,
-                "exchange",
-                if layer == Layer::Oa {
-                    RelationKind::Interaction
-                } else {
-                    RelationKind::FunctionalExchange
-                },
-                from,
-                to,
-            )?;
-            p.diagrams
-                .get_mut(&id(&scope))
-                .unwrap()
-                .routes
-                .push(route(&scope, pins));
-        }
-    }
-    diagram(
-        &mut p,
-        "other_view",
-        "05 Other saved view - preserve",
-        Layer::Oa,
-        ProjectionKind::Overview,
-    );
-    for (suffix, pos) in [("x", xy(40., 60.)), ("y", xy(410., 180.))] {
-        let alias = named("other_view", suffix);
-        p.diagrams.get_mut(&id("other_view")).unwrap().nodes.insert(
-            id(&alias),
-            NodePlacement {
-                id: id(&alias),
-                alias,
-                element: id(&named("oa_assign", suffix)),
-                position: pos,
-                size: Size {
-                    width: 224.,
-                    height: 94.,
-                },
-                collapsed: false,
-                port_anchors: vec![],
-            },
-        );
-    }
-    validate_candidate(&p)?;
-    Ok(p)
-}
-fn node_mut<'a>(p: &'a mut Project, scope: &str, suffix: &str) -> &'a mut NodePlacement {
-    p.diagrams
-        .get_mut(&id(scope))
-        .unwrap()
-        .nodes
-        .get_mut(&id(&named(scope, &format!("node_{suffix}"))))
-        .unwrap()
-}
-fn expected(before: &Project, mode: &str) -> Result<Project> {
-    let mut p = before.clone();
-    match mode {
-        "unchanged" => {}
-        "oa-assigned" | "sa-assigned" => {
-            let scope = if mode == "oa-assigned" {
-                "oa_assign"
-            } else {
-                "sa_assign"
-            };
-            for (rel, work) in [("ax", "x"), ("by", "y")] {
-                p.relations.get_mut(&id(&named(scope, rel))).unwrap().body =
-                    RelationBody::Allocation {
-                        source: id(&named(scope, "c")),
-                        target: id(&named(scope, work)),
-                    };
-            }
-            node_mut(&mut p, scope, "x").position = xy(560., 140.);
-            node_mut(&mut p, scope, "y").position = xy(560., 440.);
-            p.diagrams.get_mut(&id(scope)).unwrap().routes[0].waypoints =
-                vec![xy(820., 260.), xy(820., 400.)];
-        }
-        "oa-arranged" | "sa-arranged" => {
-            let scope = if mode == "oa-arranged" {
-                "oa_arrange"
-            } else {
-                "sa_arrange"
-            };
-            for (suffix, pos) in [
-                ("p", xy(40., 280.)),
-                ("u", xy(80., 380.)),
-                ("v", xy(440., 380.)),
-            ] {
-                node_mut(&mut p, scope, suffix).position = pos;
-            }
-            p.diagrams.get_mut(&id(scope)).unwrap().routes[0].waypoints =
-                vec![xy(360., 420.), xy(360., 470.)];
-        }
-        "oa-performers" => {
-            for (suffix, pos) in [
-                ("a", xy(120., 90.)),
-                ("b", xy(120., 380.)),
-                ("x", xy(157., 183.)),
-                ("y", xy(157., 483.)),
-            ] {
-                node_mut(&mut p, "oa_assign", suffix).position = pos;
-            }
-            p.diagrams.get_mut(&id("oa_assign")).unwrap().routes[0].waypoints =
-                vec![xy(417., 303.), xy(417., 443.)];
-        }
-        _ => return Err(format!("Unknown mode {mode}; expected {MODES:?}").into()),
-    }
-    Ok(p)
-}
-fn ancestor(view: &projection::ProjectedView, parent: Id, child: Id) -> bool {
-    let mut next = view
-        .nodes
-        .iter()
-        .find(|n| n.id == child)
-        .and_then(|n| n.visual_parent);
-    for _ in 0..view.nodes.len() {
-        let Some(current) = next else {
-            return false;
-        };
-        if current == parent {
-            return true;
-        }
-        next = view
-            .nodes
-            .iter()
-            .find(|n| n.id == current)
-            .and_then(|n| n.visual_parent);
-    }
-    false
-}
-/// Fixture-usability preflight only: never calculates expected mutations.
-fn preflight(p: &Project) -> Result<serde_json::Value> {
-    validate_candidate(p)?;
-    let mut scenes = Vec::new();
-    for scope in ["oa_assign", "sa_assign", "oa_arrange", "sa_arrange"] {
-        let d = &p.diagrams[&id(scope)];
-        let view = projection::project_view(p, d.id);
-        need(
-            view.nodes.len() == d.nodes.len(),
-            format!("{scope}: hidden/missing fixture placement"),
-        )?;
-        for n in &view.nodes {
-            need(
-                n.position == d.nodes[&n.id].position,
-                format!("{scope}: unexpectedly shifted projected origin {}", n.id),
-            )?;
-            need(
-                n.position.x >= 0.
-                    && n.position.y >= 0.
-                    && n.position.x + n.size.width <= 900.
-                    && n.position.y + n.size.height <= 750.,
-                format!("{scope}: fixture exceeds declared compact world envelope: {n:?}"),
-            )?;
-            if p.elements[&n.element].kind().is_work() {
-                let height = if d.layer == Layer::Sa { 132. } else { 94. };
-                need(
-                    n.size
-                        == Size {
-                            width: 224.,
-                            height,
-                        },
-                    format!("{scope}: unexpected work/port extent {n:?}"),
-                )?;
-            }
-        }
-        for (i, a) in view.nodes.iter().enumerate() {
-            for b in &view.nodes[i + 1..] {
-                if ancestor(&view, a.id, b.id) || ancestor(&view, b.id, a.id) {
-                    continue;
-                }
-                let width = (a.position.x + a.size.width).min(b.position.x + b.size.width)
-                    - a.position.x.max(b.position.x);
-                let height = (a.position.y + a.size.height).min(b.position.y + b.size.height)
-                    - a.position.y.max(b.position.y);
-                need(
-                    width <= 0. || height <= 0.,
-                    format!("{scope}: unrelated projected overlap {} {}", a.id, b.id),
-                )?;
-            }
-        }
-        let routed = routing::route_diagram(p, d, &view);
-        let edge = id(&named(scope, "exchange"));
-        let r = routed
-            .edges
-            .get(&edge)
-            .ok_or("Authored exchange route is missing")?;
-        need(
-            !r.custom_suspended && r.pins == d.routes[0].waypoints,
-            format!("{scope}: authored pins are not active"),
-        )?;
-        need(
-            r.warnings.is_empty(),
-            format!(
-                "{scope}: route warnings require fixture review: {:?}; ports={:?}; points={:?}; nodes={:?}",
-                r.warnings, view.ports, r.points, view.nodes
-            ),
-        )?;
-        need(
-            view.ports.len() == if d.layer == Layer::Sa { 2 } else { 0 },
-            format!("{scope}: unexpected visible typed ports"),
-        )?;
-        scenes.push(serde_json::json!({"diagram":scope,"nodes":view.nodes,"ports":view.ports,"active_pins":r.pins,"route_warnings":r.warnings.iter().map(ToString::to_string).collect::<Vec<_>>()}));
-    }
-    Ok(serde_json::json!(scenes))
-}
-fn load(path: &Path) -> Result<Project> {
-    if path
-        .extension()
-        .is_some_and(|ext| ext.eq_ignore_ascii_case("arcadia"))
-    {
-        let disk = source_files::load_project(path, ProjectLimits::default())?;
-        need(
-            !disk
-                .diagnostics
-                .iter()
-                .any(|d| d.diagnostic.severity == validation::Severity::Error),
-            format!("Source discovery errors: {:?}", disk.diagnostics),
-        )?;
-        let compiled = compile_bundle(&disk.reachable_bundle(), ProjectLimits::default())
-            .map_err(|e| format!("Source compile: {e:?}"))?;
-        Ok(compiled.decoded.project)
-    } else {
-        Ok(persistence::load(path)?)
-    }
-}
-fn equal(expected: &Project, actual: &Project) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    let e = serde_json::to_value(expected)?;
-    let a = serde_json::to_value(actual)?;
-    let fields: Vec<_> = e
-        .as_object()
-        .unwrap()
-        .keys()
-        .filter(|key| e[*key] != a[*key])
-        .cloned()
-        .collect();
-    Err(format!("Whole Project mismatch in {fields:?}; no partial PASS").into())
-}
-fn roundtrip(p: &Project) -> Result<SourceBundle> {
-    validate_candidate(p)?;
-    equal(p, &persistence::decode(&serde_json::to_vec(p)?)?)?;
-    let mut bundle = format_bundle(p);
-    for (path, text) in &mut bundle.files {
-        *text = format!("// Native preservation sentinel: {path}\n{text}");
-    }
-    let parsed = compile_bundle(&bundle, ProjectLimits::default())
-        .map_err(|e| format!("Source roundtrip: {e:?}"))?;
-    equal(p, &parsed.decoded.project)?;
-    Ok(bundle)
-}
-fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
-    fs::create_dir_all(path.parent().ok_or("Missing parent directory")?)?;
-    fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path)?
-        .write_all(bytes)?;
-    Ok(())
-}
-fn generate(out: &Path) -> Result<()> {
-    need(!out.exists(), "Output exists; choose a fresh directory")?;
-    let p = fixture()?;
-    let bundle = roundtrip(&p)?;
-    let mut geometry = BTreeMap::new();
-    // All literal candidates must satisfy the same compact-fixture prerequisites
-    // before any bytes are published for a native run.
-    for mode in MODES {
-        let candidate = expected(&p, mode)?;
-        roundtrip(&candidate)?;
-        geometry.insert(mode, preflight(&candidate)?);
-    }
-    let mut ids = BTreeMap::from([(p.alias.clone(), p.id)]);
-    ids.extend(p.elements.values().map(|v| (v.alias.clone(), v.id)));
-    ids.extend(p.relations.values().map(|v| (v.alias.clone(), v.id)));
-    ids.extend(p.diagrams.values().map(|v| (v.alias.clone(), v.id)));
-    ids.extend(
-        p.diagrams
-            .values()
-            .flat_map(|d| d.nodes.values().map(|v| (v.alias.clone(), v.id))),
-    );
-    write_new(&out.join("baseline.json"), &serde_json::to_vec_pretty(&p)?)?;
-    for (path, text) in &bundle.files {
-        write_new(&out.join("source").join(path), text.as_bytes())?;
-    }
-    let paths: BTreeMap<_, _> = ids
-        .iter()
-        .map(|(alias, id)| {
-            let needle = id.to_string();
-            let files: Vec<_> = bundle
-                .files
-                .iter()
-                .filter(|(_, text)| text.contains(&needle))
-                .map(|(path, _)| path.clone())
-                .collect();
-            (alias.clone(), files)
-        })
-        .collect();
-    write_new(
-        &out.join("manifest.json"),
-        &serde_json::to_vec_pretty(&serde_json::json!({
-            "fixture":"allocation-multiselect-native-20260923","source_entry":bundle.entry,"ids":ids,
-            "source_files":bundle.files.keys().collect::<Vec<_>>(),"id_text_occurrence_files":paths,
-            "modes":MODES,"geometry_preflight":geometry,
-            "literal_deltas":{"oa-assigned":[480,0],"sa-assigned":[480,0],"oa-arranged":[0,240],"sa-arranged":[0,240],"oa-performers":[77,43]},
-            "selection":{"assigned":["X","Y"],"arranged":["P","V"],"ordinary_performers":["A","B"]},
-            "ordinary_anchor_target":[120,90],
-            "evaluation":"Literal complete Project oracle, never inferred from saved geometry; baseline pinned to deterministic original",
-            "limits":"Geometry preflight is not GUI/planner admission. Source comments/history bytes, focus, exact selection, pointer delivery and one Undo/Redo require separate observation/checks. Each mode is one operation from baseline."
-        }))?,
-    )?;
-    equal(&p, &load(&out.join("baseline.json"))?)?;
-    equal(&p, &load(&out.join("source").join(&bundle.entry))?)?;
-    println!("PASS generated and reloaded fixture: {}", out.display());
-    Ok(())
-}
-fn check(mode: &str, baseline: &Path, saved: &Path) -> Result<()> {
-    let before = load(baseline)?;
-    equal(&fixture()?, &before).map_err(|e| format!("Baseline is not immutable original: {e}"))?;
-    let actual = load(saved)?;
-    validate_candidate(&actual)?;
-    equal(&expected(&before, mode)?, &actual)?;
-    roundtrip(&actual)?;
-    println!(
-        "{}",
-        serde_json::to_string_pretty(&serde_json::json!({
-            "result":"PASS","mode":mode,"baseline":baseline,"saved":saved,
-            "comparison":"complete Project equality; literal fixed record edits",
-            "limits":"No pointer, selection, source-byte preservation, focus, Undo/Redo, or native acceptance claim"
-        }))?
-    );
-    Ok(())
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    match args.as_slice() {
-        [command,out] if command=="generate" => generate(Path::new(out)),
-        [command,mode,baseline,saved] if command=="check" => check(mode,Path::new(baseline),Path::new(saved)),
-        _=>Err(format!("Usage: allocation_multiselect_native generate DIRECTORY | check MODE BASELINE SAVED; modes={MODES:?}").into()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn through_json(mode: &str, before: &Project, actual: &Project) -> Result<()> {
-        validate_candidate(before).expect("baseline valid");
-        validate_candidate(actual).expect("falsifier must remain core-valid");
-        let dir = tempfile::tempdir()?;
-        let baseline = dir.path().join("baseline.json");
-        let saved = dir.path().join("saved.json");
-        persistence::save(&baseline, before)?;
-        persistence::save(&saved, actual)?;
-        check(mode, &baseline, &saved)
-    }
-    fn mismatch(mode: &str, before: &Project, actual: &Project) {
-        let error = through_json(mode, before, actual).unwrap_err().to_string();
-        assert!(
-            error.contains("Whole Project mismatch"),
-            "wrong failure cause: {error}"
-        );
-    }
-    #[test]
-    fn deterministic_create_only_generation_and_all_literal_modes() {
-        let p = fixture().unwrap();
-        assert_eq!(p, fixture().unwrap());
-        let dir = tempfile::tempdir().unwrap();
-        let out = dir.path().join("fixture");
-        generate(&out).unwrap();
-        let before = fs::read(out.join("baseline.json")).unwrap();
-        assert!(generate(&out).is_err());
-        assert_eq!(before, fs::read(out.join("baseline.json")).unwrap());
-        for mode in MODES {
-            let candidate = expected(&p, mode).unwrap();
-            preflight(&candidate).unwrap();
-            through_json(mode, &p, &candidate).unwrap();
-            if mode != "unchanged" {
-                mismatch(mode, &p, &p);
-            }
-        }
-        assert!(expected(&p, "invented").is_err());
-        let changed = expected(&p, "oa-assigned").unwrap();
-        assert!(
-            through_json("unchanged", &changed, &changed)
-                .unwrap_err()
-                .to_string()
-                .contains("immutable original")
-        );
-    }
-    #[test]
-    fn actual_core_assignment_batch_matches_literal_oracle_and_one_step_history() {
-        let before = fixture().unwrap();
-        for (mode, scope) in [("oa-assigned", "oa_assign"), ("sa-assigned", "sa_assign")] {
-            let mut commands = Vec::new();
-            for (alias, work) in [("ax", "x"), ("by", "y")] {
-                let relation = id(&named(scope, alias));
-                let mut value = before.relations[&relation].clone();
-                value.body = RelationBody::Allocation {
-                    source: id(&named(scope, "c")),
-                    target: id(&named(scope, work)),
-                };
-                commands.push(Command::EditRelation(relation, value));
-            }
-            for (suffix, position) in [("x", xy(560., 140.)), ("y", xy(560., 440.))] {
-                let original = id(&named(scope, &format!("node_{suffix}")));
-                let mut node = before.diagrams[&id(scope)].nodes[&original].clone();
-                node.position = position;
-                commands.push(Command::EditNode {
-                    diagram: id(scope),
-                    original,
-                    node,
-                });
-            }
-            let mut route = before.diagrams[&id(scope)].routes[0].clone();
-            route.waypoints = vec![xy(820., 260.), xy(820., 400.)];
-            commands.push(Command::SetEdgeRoute {
-                diagram: id(scope),
-                route,
-            });
-            let mut session = Session::new(before.clone());
-            session.execute(Command::Batch(commands)).unwrap();
-            through_json(mode, &before, session.project()).unwrap();
-            let after = session.project().clone();
-            session.undo();
-            assert_eq!(session.project(), &before);
-            assert!(!session.can_undo());
-            session.redo();
-            assert_eq!(session.project(), &after);
-            assert!(!session.can_redo());
-        }
-    }
-    #[test]
-    fn assignment_rejects_singleton_semantic_identity_and_route_drift() {
-        let before = fixture().unwrap();
-        for mode in ["oa-assigned", "sa-assigned"] {
-            let scope = if mode == "oa-assigned" {
-                "oa_assign"
-            } else {
-                "sa_assign"
-            };
-            let good = expected(&before, mode).unwrap();
-            let mut bad = good.clone();
-            node_mut(&mut bad, scope, "y").position = xy(80., 440.);
-            mismatch(mode, &before, &bad);
-            let mut bad = good.clone();
-            bad.relations.insert(
-                id(&named(scope, "by")),
-                before.relations[&id(&named(scope, "by"))].clone(),
-            );
-            mismatch(mode, &before, &bad);
-            let mut bad = good.clone();
-            reidentify(
-                &mut bad,
-                id(&named(scope, "ax")),
-                id("replacement_allocation"),
-            )
-            .unwrap();
-            mismatch(mode, &before, &bad);
-            let mut bad = good.clone();
-            bad.relations
-                .get_mut(&id(&named(scope, "ax")))
-                .unwrap()
-                .description
-                .push_str(" drift");
-            mismatch(mode, &before, &bad);
-            for pins in [
-                vec![xy(340., 260.), xy(340., 400.)],
-                vec![xy(1300., 260.), xy(1300., 400.)],
-            ] {
-                let mut bad = good.clone();
-                bad.diagrams.get_mut(&id(scope)).unwrap().routes[0].waypoints = pins;
-                mismatch(mode, &before, &bad);
-            }
-        }
-    }
-    #[test]
-    fn arrange_and_ordinary_closure_falsifiers_remain_core_valid() {
-        let before = fixture().unwrap();
-        for mode in ["oa-arranged", "sa-arranged"] {
-            let scope = if mode == "oa-arranged" {
-                "oa_arrange"
-            } else {
-                "sa_arrange"
-            };
-            let good = expected(&before, mode).unwrap();
-            for (suffix, pos) in [("u", xy(80., 140.)), ("v", xy(440., 140.))] {
-                let mut bad = good.clone();
-                node_mut(&mut bad, scope, suffix).position = pos;
-                mismatch(mode, &before, &bad);
-            }
-            let mut bad = good.clone();
-            bad.relations.remove(&id(&named(scope, "pu")));
-            mismatch(mode, &before, &bad);
-        }
-        let good = expected(&before, "oa-performers").unwrap();
-        let mut bad = good.clone();
-        node_mut(&mut bad, "oa_assign", "x").position = xy(80., 140.);
-        mismatch("oa-performers", &before, &bad);
-        let mut bad = good;
-        bad.relations.get_mut(&id("oa_assign_ax")).unwrap().body = RelationBody::Allocation {
-            source: id("oa_assign_c"),
-            target: id("oa_assign_x"),
-        };
-        mismatch("oa-performers", &before, &bad);
-    }
-    #[test]
-    fn whole_project_sentinels_and_real_saved_source_are_checked() {
-        let before = fixture().unwrap();
-        let dir = tempfile::tempdir().unwrap();
-        let baseline = dir.path().join("baseline.json");
-        persistence::save(&baseline, &before).unwrap();
-        for mode in MODES {
-            let good = expected(&before, mode).unwrap();
-            for corrupt in [false, true] {
-                let mut actual = good.clone();
-                if corrupt {
-                    actual
-                        .elements
-                        .get_mut(&id("sa_arrange_v"))
-                        .unwrap()
-                        .description
-                        .push_str(" drift");
-                }
-                let bundle = roundtrip(&actual).unwrap();
-                let folder = dir.path().join(format!("{mode}-{corrupt}"));
-                for (path, text) in &bundle.files {
-                    write_new(&folder.join(path), text.as_bytes()).unwrap();
-                }
-                let result = check(mode, &baseline, &folder.join(&bundle.entry));
-                if corrupt {
-                    assert!(
-                        result
-                            .unwrap_err()
-                            .to_string()
-                            .contains("Whole Project mismatch")
-                    );
-                } else {
-                    result.unwrap();
-                }
-            }
-            let mut bad = good;
-            bad.diagrams
-                .get_mut(&id("other_view"))
-                .unwrap()
-                .nodes
-                .get_mut(&id("other_view_x"))
-                .unwrap()
-                .position
-                .x += 10.;
-            mismatch(mode, &before, &bad);
-        }
-        let invalid = dir.path().join("invalid.arcadia");
-        write_new(&invalid, b"project {").unwrap();
-        assert!(load(&invalid).is_err());
-    }
-}

crates/oa-core/examples/attachment_snapshot.rs

@@ -1,27 +0,0 @@
-//! Read and validate a saved acceptance fixture without rewriting its source.
-//! cargo run --locked -p oa-core --example attachment_snapshot -- input.arcadia output.json
-use oa_core::{persistence, validate_candidate};
-use std::{fs::OpenOptions, io::Write, path::Path};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args_os().skip(1).collect();
-    if args.len() != 2 {
-        return Err("Expected input source/JSON and a new output JSON path".into());
-    }
-    let project = persistence::load(Path::new(&args[0]))?;
-    validate_candidate(&project)?;
-    let bytes = serde_json::to_vec_pretty(&project)?;
-    let mut output = OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(&args[1])?;
-    output.write_all(&bytes)?;
-    output.write_all(b"\n")?;
-    output.sync_all()?;
-    println!(
-        "Validated {} objects and {} views; saved a complete Project snapshot",
-        project.identities().len(),
-        project.diagrams.len()
-    );
-    Ok(())
-}

crates/oa-core/examples/auto_layout_probe/boundary_fixtures.rs

@@ -1,131 +0,0 @@
-//! Independent structural falsifiers for incoming boundary ordering.
-use super::*;
-
-fn pair(f: &mut Builder, name: &str, x: f32) -> (Id, Id, Id) {
-    let parent = f.function(name, None, x, 40.0);
-    let a = f.function(&format!("{name} A"), Some(parent), x + 60.0, 130.0);
-    let b = f.function(&format!("{name} B"), Some(parent), x + 60.0, 330.0);
-    (parent, a, b)
-}
-
-pub(super) fn fixtures() -> Vec<(&'static str, Builder)> {
-    let mut all = Vec::new();
-    let mut f = Builder::new("boundary_opposing_parents");
-    let (_, la, lb) = pair(&mut f, "Left", 40.0);
-    let (_, ra, rb) = pair(&mut f, "Right", 820.0);
-    for (name, a, b) in [
-        ("Reverse upper", la, rb),
-        ("Reverse lower", lb, ra),
-        ("Return upper", ra, la),
-        ("Return lower", rb, lb),
-    ] {
-        f.exchange(name, a, b);
-    }
-    all.push(("boundary_opposing_parents", f));
-
-    let mut f = Builder::new("boundary_three_parent_chain");
-    let (_, la, lb) = pair(&mut f, "Left", 40.0);
-    let (middle, ma, mb) = pair(&mut f, "Middle", 820.0);
-    let (_, ra, rb) = pair(&mut f, "Right", 1600.0);
-    for (name, a, b) in [
-        ("Left upper", la, mb),
-        ("Left lower", lb, ma),
-        ("Middle upper", mb, ra),
-        ("Middle lower", ma, rb),
-    ] {
-        f.exchange(name, a, b);
-    }
-    let mut translated = f.clone();
-    for element in [middle, ma, mb] {
-        let node = translated.node(element);
-        let position = &mut translated
-            .project
-            .diagrams
-            .get_mut(&translated.diagram)
-            .unwrap()
-            .nodes
-            .get_mut(&node)
-            .unwrap()
-            .position;
-        position.x += 300.0;
-        position.y += 500.0;
-    }
-    let mut permuted = f.clone();
-    let ids: Vec<_> = permuted.project.relations.keys().copied().collect();
-    for (i, id) in ids.iter().enumerate() {
-        reidentify(
-            &mut permuted.project,
-            *id,
-            Id::from_u128(1_000_000 + i as u128),
-        )
-        .unwrap();
-    }
-    for (i, id) in ids.iter().rev().enumerate() {
-        reidentify(
-            &mut permuted.project,
-            Id::from_u128(1_000_000 + i as u128),
-            *id,
-        )
-        .unwrap();
-    }
-    all.push(("boundary_three_parent_chain", f));
-    all.push(("boundary_three_parent_translated", translated));
-    all.push(("boundary_three_parent_edge_ids_reversed", permuted));
-
-    let mut f = Builder::new("boundary_two_local_sccs");
-    let (_, sa, sb) = pair(&mut f, "Source", 40.0);
-    let target = f.function("Target", None, 820.0, 40.0);
-    let x1 = f.function("X1", Some(target), 880.0, 130.0);
-    let x2 = f.function("X2", Some(target), 1200.0, 130.0);
-    let y1 = f.function("Y1", Some(target), 880.0, 330.0);
-    let y2 = f.function("Y2", Some(target), 1200.0, 330.0);
-    let z = f.function("Z", Some(target), 1520.0, 230.0);
-    for (name, a, b) in [
-        ("X forward", x1, x2),
-        ("X back", x2, x1),
-        ("Y forward", y1, y2),
-        ("Y back", y2, y1),
-        ("X result", x2, z),
-        ("Y result", y2, z),
-        ("Upper boundary", sa, y1),
-        ("Lower boundary", sb, x1),
-    ] {
-        f.exchange(name, a, b);
-    }
-    all.push(("boundary_two_local_sccs", f));
-
-    let mut f = super::fixtures()
-        .into_iter()
-        .find(|(name, _)| *name == "two_containers_reversed_children")
-        .unwrap()
-        .1;
-    let relations: Vec<_> = f.project.relations.values().cloned().collect();
-    for relation in relations {
-        if let RelationBody::FunctionalExchange {
-            source_port,
-            target_port,
-            ..
-        } = relation.body
-        {
-            for (port, side, offset) in [
-                (source_port, PortAnchorSide::Right, 0.3),
-                (target_port, PortAnchorSide::Left, 0.7),
-            ] {
-                let owner = f.project.elements[&port].parent.unwrap();
-                let node = f.node(owner);
-                f.project = prepare_command(
-                    &f.project,
-                    &Command::SetPortAnchor {
-                        diagram: f.diagram,
-                        node,
-                        anchor: PortAnchor { port, side, offset },
-                    },
-                )
-                .unwrap()
-                .project;
-            }
-        }
-    }
-    all.push(("boundary_two_containers_anchored", f));
-    all
-}

crates/oa-core/examples/auto_layout_probe/clearance.rs

@@ -1,279 +0,0 @@
-//! Bounded flat-placement experiment. Empty lead diagnostics are necessary only,
-//! never a claim that routes, labels, or drawing quality are acceptable.
-use oa_core::{Id, ModelError, Project, projection, routing};
-use std::collections::BTreeMap;
-
-const ROUNDS: usize = 4;
-const WORK_LIMIT: usize = 10_000_000;
-const MAX_SPAN: f32 = 100_000.0;
-const MARGIN: f32 = 1.0;
-
-fn fail(message: &str) -> ModelError {
-    ModelError(format!("Clearance probe: {message}"))
-}
-
-fn spend(work: &mut usize, amount: usize) -> Result<(), ModelError> {
-    *work = work.saturating_add(amount);
-    if *work > WORK_LIMIT {
-        return Err(fail("work limit exceeded"));
-    }
-    Ok(())
-}
-
-// A boundary constraint means start[to] >= start[from] + extent[from] + gap.
-// Adjacent total-order constraints below separately preserve start ordering.
-type Constraints = BTreeMap<(usize, usize), f32>;
-
-fn solve(
-    baseline: &[f32],
-    extents: &[f32],
-    order: &[usize],
-    constraints: &Constraints,
-    work: &mut usize,
-) -> Result<Vec<f32>, ModelError> {
-    let mut result = baseline.to_vec();
-    let mut previous = None;
-    for &to in order {
-        if let Some(from) = previous {
-            result[to] = result[to].max(result[from]);
-        }
-        for (&(from, target), &gap) in constraints {
-            spend(work, 1)?;
-            if target == to {
-                result[to] = result[to].max(result[from] + extents[from] + gap);
-            }
-        }
-        previous = Some(to);
-    }
-    let minimum = baseline.iter().copied().fold(f32::INFINITY, f32::min);
-    for (i, &value) in result.iter().enumerate() {
-        if !value.is_finite() || value + extents[i] - minimum > MAX_SPAN {
-            return Err(fail("coordinate/span bound exceeded"));
-        }
-    }
-    Ok(result)
-}
-
-/// Input is an already admitted placement candidate. Never modifies its routes,
-/// authored anchors, sizes or semantics. Error drops the private clone.
-pub fn repair(project: &Project, diagram: Id) -> Result<Project, ModelError> {
-    let original = project
-        .diagrams
-        .get(&diagram)
-        .ok_or_else(|| fail("missing diagram"))?;
-    if original.projection.scenario().is_some() {
-        return Err(fail("Scenario unsupported"));
-    }
-    let baseline = projection::project_diagram(project, original);
-    if baseline.nodes.len() > 256 || baseline.edges.len() > 1024 {
-        return Err(fail("graph bound exceeded"));
-    }
-    if baseline.nodes.len() != original.nodes.len()
-        || baseline
-            .nodes
-            .iter()
-            .any(|n| n.collapsed || n.visual_parent.is_some())
-    {
-        return Err(fail("nested, folded or omitted placements unsupported"));
-    }
-    let mut nodes = baseline.nodes.clone();
-    nodes.sort_by_key(|n| n.id);
-    if nodes.iter().any(|n| {
-        !n.position.x.is_finite()
-            || !n.position.y.is_finite()
-            || !n.size.width.is_finite()
-            || !n.size.height.is_finite()
-            || n.size.width <= 0.0
-            || n.size.height <= 0.0
-    }) {
-        return Err(fail("invalid initial geometry"));
-    }
-    let indices: BTreeMap<_, _> = nodes.iter().enumerate().map(|(i, n)| (n.id, i)).collect();
-    let coordinates = [
-        nodes.iter().map(|n| n.position.x).collect::<Vec<_>>(),
-        nodes.iter().map(|n| n.position.y).collect::<Vec<_>>(),
-    ];
-    let extents = [
-        nodes.iter().map(|n| n.size.width).collect::<Vec<_>>(),
-        nodes.iter().map(|n| n.size.height).collect::<Vec<_>>(),
-    ];
-    for axis in 0..2 {
-        let minimum = coordinates[axis]
-            .iter()
-            .copied()
-            .fold(f32::INFINITY, f32::min);
-        if coordinates[axis]
-            .iter()
-            .zip(&extents[axis])
-            .any(|(&start, &extent)| {
-                !(start + extent).is_finite() || start + extent - minimum > MAX_SPAN
-            })
-        {
-            return Err(fail("initial coordinate/span bound exceeded"));
-        }
-    }
-    let mut orders = [Vec::new(), Vec::new()];
-    let mut ranks = [vec![0; nodes.len()], vec![0; nodes.len()]];
-    for axis in 0..2 {
-        orders[axis] = (0..nodes.len()).collect();
-        orders[axis].sort_by(|&a, &b| {
-            coordinates[axis][a]
-                .total_cmp(&coordinates[axis][b])
-                .then(nodes[a].id.cmp(&nodes[b].id))
-        });
-        for (rank, &i) in orders[axis].iter().enumerate() {
-            ranks[axis][i] = rank;
-        }
-    }
-    let mut constraints = [Constraints::new(), Constraints::new()];
-    let mut work = 0;
-    // Preserve one existing disjoint axis per pair, X before Y. No initially
-    // overlapping pair is silently treated as successfully repaired.
-    for a in 0..nodes.len() {
-        for b in a + 1..nodes.len() {
-            spend(&mut work, 1)?;
-            let mut chosen = None;
-            for axis in 0..2 {
-                for (from, to) in [(a, b), (b, a)] {
-                    let gap = coordinates[axis][to] - coordinates[axis][from] - extents[axis][from];
-                    if gap >= 0.0 {
-                        chosen = Some((axis, from, to, gap));
-                        break;
-                    }
-                }
-                if chosen.is_some() {
-                    break;
-                }
-            }
-            let (axis, from, to, gap) =
-                chosen.ok_or_else(|| fail("initial node overlap unsupported"))?;
-            constraints[axis].insert((from, to), gap);
-        }
-    }
-    let mut result = project.clone();
-    for round in 0..=ROUNDS {
-        let current = &result.diagrams[&diagram];
-        let view = projection::project_diagram(&result, current);
-        if view.nodes.len() != nodes.len()
-            || view.nodes.iter().any(|n| {
-                indices.get(&n.id).is_none_or(|&i| {
-                    n.size != nodes[i].size || n.collapsed || n.visual_parent.is_some()
-                })
-            })
-        {
-            return Err(fail("reprojection changed node identity/size/topology"));
-        }
-        // Charge work units proportional to node count and at most sixteen
-        // endpoint pairs. This is not an exact operation count or a bound on
-        // all projection work; graph, round and span limits apply separately.
-        spend(
-            &mut work,
-            view.edges
-                .len()
-                .saturating_mul(nodes.len().saturating_add(1))
-                .saturating_mul(16),
-        )?;
-        let failures = routing::lead_incompatibilities(&result, current, &view);
-        if failures.is_empty() {
-            return Ok(result);
-        }
-        if round == ROUNDS {
-            return Err(fail("unresolved mandatory leads after four adjustments"));
-        }
-        let mut strengthened = false;
-        for failure in failures {
-            if failure.allowed_pair_count != 1
-                || failure.source.len() != 1
-                || failure.target.len() != 1
-            {
-                return Err(fail("ambiguous endpoint choices unsupported"));
-            }
-            for endpoint in failure.source.iter().chain(&failure.target) {
-                let owner = *indices
-                    .get(&endpoint.owner)
-                    .ok_or_else(|| fail("unknown endpoint owner"))?;
-                let dx = endpoint.stub.x - endpoint.tip.x;
-                let dy = endpoint.stub.y - endpoint.tip.y;
-                if endpoint.blockers.is_empty() {
-                    continue;
-                }
-                let (axis, forward) = match (dx, dy) {
-                    (x, 0.0) if x != 0.0 => (0, x > 0.0),
-                    (0.0, y) if y != 0.0 => (1, y > 0.0),
-                    _ => return Err(fail("noncardinal/degenerate blocked lead")),
-                };
-                for blocker in &endpoint.blockers {
-                    spend(&mut work, 1)?;
-                    let other = *indices
-                        .get(&blocker.id)
-                        .ok_or_else(|| fail("unknown blocker"))?;
-                    let (from, to) = if forward {
-                        (owner, other)
-                    } else {
-                        (other, owner)
-                    };
-                    if ranks[axis][from] >= ranks[axis][to] {
-                        return Err(fail("lead constraint opposes frozen spatial order"));
-                    }
-                    let required = routing::PORT_STUB + routing::CLEARANCE + MARGIN;
-                    let old = constraints[axis].entry((from, to)).or_insert(0.0);
-                    if *old < required {
-                        *old = required;
-                        strengthened = true;
-                    }
-                }
-            }
-        }
-        if !strengthened {
-            return Err(fail(
-                "unresolved lead without a stronger monotone constraint",
-            ));
-        }
-        let x = solve(
-            &coordinates[0],
-            &extents[0],
-            &orders[0],
-            &constraints[0],
-            &mut work,
-        )?;
-        let y = solve(
-            &coordinates[1],
-            &extents[1],
-            &orders[1],
-            &constraints[1],
-            &mut work,
-        )?;
-        let target = result.diagrams.get_mut(&diagram).unwrap();
-        for (i, node) in nodes.iter().enumerate() {
-            let placed = target.nodes.get_mut(&node.id).unwrap();
-            placed.position.x = x[i];
-            placed.position.y = y[i];
-        }
-    }
-    unreachable!("bounded loop returns on final round")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn separation_propagates_to_neighbor_without_moving_predecessor() {
-        let constraints = BTreeMap::from([((0, 1), 31.0), ((1, 2), 10.0)]);
-        let actual = solve(
-            &[-20.0, 100.0, 210.0],
-            &[100.0; 3],
-            &[0, 1, 2],
-            &constraints,
-            &mut 0,
-        )
-        .unwrap();
-        assert_eq!(actual, vec![-20.0, 111.0, 221.0]);
-    }
-
-    #[test]
-    fn extent_bound_rejects_constraint_expansion() {
-        let constraints = BTreeMap::from([((0, 1), MAX_SPAN)]);
-        assert!(solve(&[0.0, 20.0], &[10.0; 2], &[0, 1], &constraints, &mut 0).is_err());
-    }
-}

crates/oa-core/examples/auto_layout_probe/condensed.rs

@@ -1,654 +0,0 @@
-//! Isolated SCC-block placement experiment; no production-layout acceptance.
-use super::{PlacementNode, PlacementPlan, import_placement};
-use oa_core::{Id, ModelError, Position, Project, Size, projection, routing};
-use std::collections::{BTreeMap, BTreeSet};
-
-const LIMIT: usize = 20_000_000;
-const PAD: f32 = 32.0;
-const SPAN: f32 = 100_000.0;
-
-#[path = "condensed/boundary.rs"]
-mod boundary;
-
-fn error(text: &str) -> ModelError {
-    ModelError(format!("SCC placement: {text}"))
-}
-fn charge(work: &mut usize, count: usize) -> Result<(), ModelError> {
-    *work = work.saturating_add(count);
-    if *work > LIMIT {
-        Err(error("work limit exceeded"))
-    } else {
-        Ok(())
-    }
-}
-
-fn components(arcs: &[BTreeSet<usize>], work: &mut usize) -> Result<Vec<Vec<usize>>, ModelError> {
-    let n = arcs.len();
-    let mut reach = vec![vec![false; n]; n];
-    for (start, reachable) in reach.iter_mut().enumerate() {
-        let mut todo = vec![start];
-        reachable[start] = true;
-        while let Some(at) = todo.pop() {
-            for &next in &arcs[at] {
-                charge(work, 1)?;
-                if !reachable[next] {
-                    reachable[next] = true;
-                    todo.push(next);
-                }
-            }
-        }
-    }
-    let mut used = vec![false; n];
-    let mut result = Vec::new();
-    for i in 0..n {
-        if used[i] {
-            continue;
-        }
-        let mut group = Vec::new();
-        for j in i..n {
-            charge(work, 1)?;
-            if !used[j] && reach[i][j] && reach[j][i] {
-                used[j] = true;
-                group.push(j);
-            }
-        }
-        result.push(group);
-    }
-    Ok(result)
-}
-
-fn perimeter_slots(n: usize, rows: usize, cols: usize) -> Vec<(usize, usize)> {
-    let mut slots = Vec::new();
-    if rows == 1 {
-        slots.extend((0..cols).map(|col| (col, 0)));
-    } else if cols == 1 {
-        slots.extend((0..rows).map(|row| (0, row)));
-    } else {
-        slots.extend((0..cols).map(|col| (col, 0)));
-        slots.extend((1..rows).map(|row| (cols - 1, row)));
-        slots.extend((0..cols - 1).rev().map(|col| (col, rows - 1)));
-        slots.extend((1..rows - 1).rev().map(|row| (0, row)));
-    }
-    slots.truncate(n);
-    slots
-}
-
-// Score occupied maximum-member cells, excluding unused perimeter slots.
-// Heterogeneous members may occupy less than this nominal cell envelope.
-fn perimeter(
-    n: usize,
-    cell: Size,
-    gap: Size,
-    work: &mut usize,
-) -> Result<(Vec<Position>, usize, usize), ModelError> {
-    type GridScore = (bool, f32, f32, usize, usize);
-    let mut best: Option<(GridScore, usize, usize)> = None;
-    for rows in 1..=n {
-        for cols in 1..=n {
-            charge(work, 1)?;
-            let capacity = if rows == 1 || cols == 1 {
-                rows * cols
-            } else {
-                2 * rows + 2 * cols - 4
-            };
-            if capacity < n {
-                continue;
-            }
-            charge(work, capacity)?;
-            let slots = perimeter_slots(n, rows, cols);
-            let max_x = slots.iter().map(|p| p.0).max().unwrap();
-            let max_y = slots.iter().map(|p| p.1).max().unwrap();
-            let width = (max_x + 1) as f32 * cell.width + max_x as f32 * gap.width;
-            let height = (max_y + 1) as f32 * cell.height + max_y as f32 * gap.height;
-            let aspect = (width / height).max(height / width);
-            let key = (
-                aspect > 2.0,
-                if aspect <= 2.0 {
-                    width * height
-                } else {
-                    aspect
-                },
-                width * height,
-                rows,
-                cols,
-            );
-            if best.as_ref().is_none_or(|(old, _, _)| key < *old) {
-                best = Some((key, rows, cols));
-            }
-        }
-    }
-    let (_, rows, cols) = best.ok_or_else(|| error("no perimeter grid"))?;
-    let slots = perimeter_slots(n, rows, cols);
-    Ok((
-        slots
-            .into_iter()
-            .take(n)
-            .map(|(x, y)| Position {
-                x: x as f32 * (cell.width + gap.width),
-                y: y as f32 * (cell.height + gap.height),
-            })
-            .collect(),
-        rows,
-        cols,
-    ))
-}
-
-fn lift(
-    id: Id,
-    parent: Option<Id>,
-    parents: &BTreeMap<Id, Option<Id>>,
-    work: &mut usize,
-) -> Result<Option<Id>, ModelError> {
-    let mut at = id;
-    for _ in 0..=parents.len() {
-        charge(work, 1)?;
-        let Some(&up) = parents.get(&at) else {
-            return Err(error("missing visual ancestor"));
-        };
-        if up == parent {
-            return Ok(Some(at));
-        }
-        let Some(next) = up else {
-            return Ok(None);
-        };
-        at = next;
-    }
-    Err(error("cyclic visual ancestry"))
-}
-
-/// Frozen projected geometry is the minimum; folded nodes remain opaque.
-pub fn candidate(project: &Project, diagram: Id) -> Result<Project, ModelError> {
-    candidate_with_diagnostics(project, diagram).map(|(result, _)| result)
-}
-
-pub fn candidate_with_diagnostics(
-    project: &Project,
-    diagram: Id,
-) -> Result<(Project, serde_json::Value), ModelError> {
-    candidate_policy(project, diagram, false)
-}
-
-pub fn boundary_candidate_with_diagnostics(
-    project: &Project,
-    diagram: Id,
-) -> Result<(Project, serde_json::Value), ModelError> {
-    candidate_policy(project, diagram, true)
-}
-
-fn candidate_policy(
-    project: &Project,
-    diagram: Id,
-    order_boundaries: bool,
-) -> Result<(Project, serde_json::Value), ModelError> {
-    let d = project
-        .diagrams
-        .get(&diagram)
-        .ok_or_else(|| error("missing diagram"))?;
-    if d.projection.scenario().is_some() {
-        return Err(error("Scenario unsupported"));
-    }
-    if d.nodes.len() > 256 {
-        return Err(error("stored-node bound exceeded"));
-    }
-    let view = projection::project_diagram(project, d);
-    if view.edges.len() > 1024 {
-        return Err(error("visible-edge bound exceeded"));
-    }
-    if view.nodes.iter().any(|n| {
-        !n.size.width.is_finite()
-            || !n.size.height.is_finite()
-            || n.size.width <= 0.0
-            || n.size.height <= 0.0
-    }) {
-        return Err(error("invalid projected minima"));
-    }
-    let parents: BTreeMap<_, _> = view.nodes.iter().map(|n| (n.id, n.visual_parent)).collect();
-    let names: BTreeMap<_, _> = view
-        .nodes
-        .iter()
-        .map(|n| (n.id, (project.elements[&n.element].alias.clone(), n.id)))
-        .collect();
-    let mut children: BTreeMap<Option<Id>, Vec<Id>> = BTreeMap::new();
-    for n in &view.nodes {
-        children.entry(n.visual_parent).or_default().push(n.id);
-    }
-    for ids in children.values_mut() {
-        ids.sort_by_key(|id| names[id].clone());
-    }
-    let mut work = 0;
-    let mut depth = BTreeMap::new();
-    for n in &view.nodes {
-        let mut at = n.id;
-        let mut count = 0;
-        let mut seen = BTreeSet::new();
-        while let Some(up) = *parents.get(&at).ok_or_else(|| error("missing parent"))? {
-            charge(&mut work, 1)?;
-            if !seen.insert(at) {
-                return Err(error("cyclic hierarchy"));
-            }
-            count += 1;
-            at = up;
-        }
-        depth.insert(n.id, count);
-    }
-    let routed = routing::route_diagram(project, d, &view);
-    let mut sizes: BTreeMap<_, _> = view.nodes.iter().map(|n| (n.id, n.size)).collect();
-    let mut offsets = BTreeMap::new();
-    let mut diagnostics = Vec::new();
-    let mut boundary_groups = Vec::new();
-    let mut groups: Vec<_> = children.keys().copied().collect();
-    groups.sort_by_key(|p| std::cmp::Reverse(p.map_or(0, |id| depth[&id] + 1)));
-    for parent in groups {
-        let ids = &children[&parent];
-        let index: BTreeMap<_, _> = ids.iter().enumerate().map(|(i, id)| (*id, i)).collect();
-        let mut arcs = vec![BTreeSet::new(); ids.len()];
-        let mut links = Vec::new();
-        let mut undirected = BTreeSet::new();
-        for edge in &view.edges {
-            charge(&mut work, 1)?;
-            let (Some(a), Some(b)) = (
-                lift(edge.source, parent, &parents, &mut work)?,
-                lift(edge.target, parent, &parents, &mut work)?,
-            ) else {
-                continue;
-            };
-            if a == b {
-                continue;
-            }
-            let (a, b) = (index[&a], index[&b]);
-            if edge.oriented {
-                arcs[a].insert(b);
-            } else {
-                undirected.insert((ids[a].min(ids[b]), ids[a].max(ids[b])));
-            }
-            let routed_edge = routed
-                .edges
-                .get(&edge.id)
-                .ok_or_else(|| error("missing estimated edge label"))?;
-            let mut label = routed_edge.label.bounds.size;
-            if let Some(relation) = project.relations.get(&edge.id) {
-                for end in routing::association_end_geometry(relation, routed_edge) {
-                    label.width = label.width.max(end.label.bounds.size.width);
-                    label.height = label.height.max(end.label.bounds.size.height);
-                }
-            }
-            if !label.width.is_finite() || !label.height.is_finite() {
-                return Err(error("invalid estimated label"));
-            }
-            links.push((a, b, label));
-        }
-        let comps = components(&arcs, &mut work)?;
-        let mut owner = vec![0; ids.len()];
-        for (c, members) in comps.iter().enumerate() {
-            for &i in members {
-                owner[i] = c;
-            }
-        }
-        let mut dag = vec![BTreeSet::new(); comps.len()];
-        for (a, targets) in arcs.iter().enumerate() {
-            for &b in targets {
-                if owner[a] != owner[b] {
-                    dag[owner[a]].insert(owner[b]);
-                }
-            }
-        }
-        let mut ranks = vec![0usize; comps.len()];
-        let mut done = BTreeSet::new();
-        while done.len() < comps.len() {
-            let next = (0..comps.len())
-                .find(|c| {
-                    !done.contains(c)
-                        && (0..comps.len()).all(|p| !dag[p].contains(c) || done.contains(&p))
-                })
-                .ok_or_else(|| error("condensation is cyclic"))?;
-            charge(&mut work, comps.len() * comps.len())?;
-            for &to in &dag[next] {
-                ranks[to] = ranks[to].max(ranks[next] + 1);
-            }
-            done.insert(next);
-        }
-        let mut blocks = Vec::new();
-        let mut component_diagnostics = Vec::new();
-        let mut member_offsets = BTreeMap::new();
-        for (c, members) in comps.iter().enumerate() {
-            let mut gap = Size {
-                width: PAD,
-                height: PAD,
-            };
-            for &(a, b, label) in &links {
-                if owner[a] == c && owner[b] == c {
-                    gap.width = gap.width.max(label.width + PAD);
-                    gap.height = gap.height.max(label.height + PAD);
-                }
-            }
-            let mut order = Vec::new();
-            let mut seen = BTreeSet::new();
-            for &start in members {
-                let mut stack = vec![start];
-                while let Some(i) = stack.pop() {
-                    charge(&mut work, 1)?;
-                    if !seen.insert(i) {
-                        continue;
-                    }
-                    order.push(i);
-                    for &j in arcs[i].iter().rev() {
-                        if owner[j] == c && !seen.contains(&j) {
-                            stack.push(j);
-                        }
-                    }
-                }
-            }
-            let cell = Size {
-                width: members
-                    .iter()
-                    .map(|&i| sizes[&ids[i]].width)
-                    .fold(0.0, f32::max),
-                height: members
-                    .iter()
-                    .map(|&i| sizes[&ids[i]].height)
-                    .fold(0.0, f32::max),
-            };
-            let (slots, rows, cols) = if members.len() == 1 {
-                (vec![Position { x: 0.0, y: 0.0 }], 1, 1)
-            } else {
-                perimeter(members.len(), cell, gap, &mut work)?
-            };
-            component_diagnostics.push(serde_json::json!({"component":c,"rank":ranks[c],"members":members.iter().map(|&i|ids[i]).collect::<Vec<_>>(),"walk":order.iter().map(|&i|ids[i]).collect::<Vec<_>>(),"grid_rows":rows,"grid_cols":cols,"gap":gap}));
-            let mut size = Size {
-                width: 0.0,
-                height: 0.0,
-            };
-            for (i, pos) in order.into_iter().zip(slots) {
-                size.width = size.width.max(pos.x + sizes[&ids[i]].width);
-                size.height = size.height.max(pos.y + sizes[&ids[i]].height);
-                member_offsets.insert(i, pos);
-            }
-            blocks.push(size);
-        }
-        let max_rank = ranks.iter().copied().max().unwrap_or(0);
-        charge(
-            &mut work,
-            links
-                .len()
-                .saturating_mul(comps.len().saturating_add(1))
-                .saturating_mul(comps.len().saturating_add(1)),
-        )?;
-        let mut block_positions = vec![Position { x: 0.0, y: 0.0 }; comps.len()];
-        let mut x = 0.0;
-        let mut total = Size {
-            width: 0.0,
-            height: 0.0,
-        };
-        let mut prior_order = vec![0usize; comps.len()];
-        let mut bands = Vec::new();
-        for rank in 0..=max_rank {
-            let mut layer: Vec<_> = (0..comps.len()).filter(|&c| ranks[c] == rank).collect();
-            // Fixed one-pass proximity order, including undirected links, without
-            // inventing direction or changing condensation ranks.
-            layer.sort_by_key(|&c| {
-                let neighbors: Vec<_> = links
-                    .iter()
-                    .filter_map(|&(a, b, _)| {
-                        let (a, b) = (owner[a], owner[b]);
-                        if a == c && ranks[b] < rank {
-                            Some(prior_order[b])
-                        } else if b == c && ranks[a] < rank {
-                            Some(prior_order[a])
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-                (
-                    if neighbors.is_empty() {
-                        c
-                    } else {
-                        neighbors.iter().sum::<usize>() / neighbors.len()
-                    },
-                    c,
-                )
-            });
-            // Keep same-rank undirected neighbours contiguous in one canonical
-            // breadth-first walk; these links never become directed rank arcs.
-            let mut proximity = Vec::new();
-            let mut remaining: BTreeSet<_> = layer.iter().copied().collect();
-            for &start in &layer {
-                if !remaining.remove(&start) {
-                    continue;
-                }
-                let mut queue = std::collections::VecDeque::from([start]);
-                while let Some(c) = queue.pop_front() {
-                    proximity.push(c);
-                    for &next in &layer {
-                        charge(&mut work, links.len() + 1)?;
-                        if remaining.contains(&next)
-                            && links.iter().any(|&(a, b, _)| {
-                                (owner[a] == c && owner[b] == next)
-                                    || (owner[b] == c && owner[a] == next)
-                            })
-                        {
-                            remaining.remove(&next);
-                            queue.push_back(next);
-                        }
-                    }
-                }
-            }
-            layer = proximity;
-            let mut cut = Size {
-                width: PAD,
-                height: PAD,
-            };
-            for &(a, b, label) in &links {
-                if owner[a] != owner[b] && (ranks[owner[a]] == rank || ranks[owner[b]] == rank) {
-                    cut.width = cut.width.max(label.width + PAD);
-                    cut.height = cut.height.max(label.height + PAD);
-                }
-            }
-            let mut y = 0.0;
-            let mut width = 0.0_f32;
-            if order_boundaries && parent.is_some() {
-                bands.push(boundary::Band {
-                    components: layer.clone(),
-                    gap: cut.height,
-                });
-            }
-            for (i, c) in layer.into_iter().enumerate() {
-                prior_order[c] = i;
-                block_positions[c] = Position { x, y };
-                y += blocks[c].height + cut.height;
-                width = width.max(blocks[c].width);
-            }
-            total.width = total.width.max(x + width);
-            total.height = total.height.max((y - cut.height).max(0.0));
-            x += width + cut.width;
-        }
-        let header = if let Some(id) = parent {
-            let n = view.nodes.iter().find(|n| n.id == id).unwrap();
-            if n.collapsed {
-                return Err(error("folded node has projected children"));
-            }
-            if d.projection.state_machine().is_some() {
-                projection::state_header_height(project, n.element)
-            } else {
-                64.0
-            }
-        } else {
-            0.0
-        };
-        for (i, id) in ids.iter().enumerate() {
-            let b = block_positions[owner[i]];
-            let m = member_offsets[&i];
-            offsets.insert(
-                *id,
-                Position {
-                    x: b.x + m.x + if parent.is_some() { PAD } else { 0.0 },
-                    y: b.y + m.y + if parent.is_some() { header + PAD } else { 0.0 },
-                },
-            );
-        }
-        if let Some(id) = parent {
-            let size = sizes.get_mut(&id).unwrap();
-            size.width = size.width.max(total.width + 2.0 * PAD);
-            size.height = size.height.max(total.height + header + 2.0 * PAD);
-            if order_boundaries {
-                boundary_groups.push(boundary::Group {
-                    parent: id,
-                    blocks: comps
-                        .iter()
-                        .enumerate()
-                        .map(|(c, members)| boundary::Block {
-                            members: members.iter().map(|&i| ids[i]).collect(),
-                            size: blocks[c],
-                            position: block_positions[c],
-                        })
-                        .collect(),
-                    bands,
-                    undirected: undirected
-                        .iter()
-                        .map(|(a, b)| (owner[index[a]], owner[index[b]]))
-                        .collect(),
-                });
-            }
-        }
-        let lifted: Vec<_> = arcs
-            .iter()
-            .enumerate()
-            .flat_map(|(a, targets)| targets.iter().map(move |&b| (ids[a], ids[b])))
-            .collect();
-        diagnostics.push(serde_json::json!({"visible_parent":parent,"components":component_diagnostics,"directed_lifted_edges":lifted,"undirected_lifted_pairs":undirected,"block_positions":block_positions,"bounds":total,"policy":"SCCs of sibling-subtree quotient, not global semantic SCCs. Undirected edges affect local gap and deterministic proximity only; no rank direction invented."}));
-    }
-    let boundary_report = if order_boundaries {
-        let report = boundary::reorder(
-            &mut boundary_groups,
-            &parents,
-            &mut offsets,
-            &sizes,
-            &view.edges,
-            &mut work,
-        )?;
-        for group in &boundary_groups {
-            let diagnostic = diagnostics
-                .iter_mut()
-                .find(|entry| entry["visible_parent"] == serde_json::json!(group.parent))
-                .unwrap();
-            diagnostic["block_positions"] =
-                serde_json::json!(group.blocks.iter().map(|b| b.position).collect::<Vec<_>>());
-        }
-        Some(report)
-    } else {
-        None
-    };
-    let mut plans = Vec::new();
-    for n in &view.nodes {
-        let mut position = offsets[&n.id];
-        let mut parent = n.visual_parent;
-        while let Some(id) = parent {
-            charge(&mut work, 1)?;
-            let p = offsets[&id];
-            position.x += p.x;
-            position.y += p.y;
-            parent = parents[&id];
-        }
-        position.x += 40.0;
-        position.y += 40.0;
-        let size = sizes[&n.id];
-        if !position.x.is_finite()
-            || !position.y.is_finite()
-            || position.x + size.width > SPAN
-            || position.y + size.height > SPAN
-        {
-            return Err(error("extent bound exceeded"));
-        }
-        plans.push(PlacementNode {
-            id: n.id,
-            position,
-            size,
-        });
-    }
-    let result = import_placement(
-        project,
-        diagram,
-        PlacementPlan {
-            schema: 1,
-            nodes: plans,
-        },
-    )?;
-    let final_view = projection::project_view(&result, diagram);
-    charge(
-        &mut work,
-        final_view.edges.len() * (final_view.nodes.len() + 1) * 16,
-    )?;
-    if !routing::lead_incompatibilities(&result, &result.diagrams[&diagram], &final_view).is_empty()
-    {
-        return Err(error(
-            "final mandatory port lead incompatible; no repair attempted",
-        ));
-    }
-    let mut report = serde_json::json!({"groups":diagnostics,"work_charged":work,"work_limit":LIMIT,"scope":"Projected-forest quotient heuristic; actual final reprojection and necessary lead guard checked. No full-route or readability acceptance."});
-    if let Some(boundary_report) = boundary_report {
-        report["boundary_order"] = boundary_report;
-    }
-    Ok((result, report))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn directed_cycles_remain_separate_across_one_way_bridge() {
-        let arcs = vec![
-            BTreeSet::from([1]),
-            BTreeSet::from([0, 2]),
-            BTreeSet::from([3]),
-            BTreeSet::from([2]),
-        ];
-        assert_eq!(
-            components(&arcs, &mut 0).unwrap(),
-            vec![vec![0, 1], vec![2, 3]]
-        );
-    }
-    #[test]
-    fn perimeter_places_ten_unique_cells_without_overlap() {
-        let (positions, _, _) = perimeter(
-            10,
-            Size {
-                width: 224.0,
-                height: 132.0,
-            },
-            Size {
-                width: 32.0,
-                height: 32.0,
-            },
-            &mut 0,
-        )
-        .unwrap();
-        assert_eq!(positions.len(), 10);
-        for (i, a) in positions.iter().enumerate() {
-            for b in &positions[i + 1..] {
-                assert!((a.x - b.x).abs() >= 256.0 || (a.y - b.y).abs() >= 164.0);
-            }
-        }
-    }
-
-    #[test]
-    fn two_node_perimeter_scores_occupied_cells_instead_of_an_unused_row() {
-        let (positions, rows, cols) = perimeter(
-            2,
-            Size {
-                width: 224.0,
-                height: 160.0,
-            },
-            Size {
-                width: 250.0,
-                height: 56.0,
-            },
-            &mut 0,
-        )
-        .unwrap();
-        assert_eq!((rows, cols), (2, 1));
-        assert_eq!(
-            positions,
-            vec![Position { x: 0.0, y: 0.0 }, Position { x: 0.0, y: 216.0 }]
-        );
-    }
-}

crates/oa-core/examples/auto_layout_probe/condensed/boundary.rs

@@ -1,686 +0,0 @@
-//! One deterministic boundary-order pass; dependency cycles use frozen scores.
-use super::{charge, components, error, lift};
-use oa_core::{Id, ModelError, Position, Size, projection::ProjectedEdge};
-use std::collections::{BTreeMap, BTreeSet};
-
-pub(super) struct Block {
-    pub members: Vec<Id>,
-    pub size: Size,
-    pub position: Position,
-}
-pub(super) struct Band {
-    pub components: Vec<usize>,
-    pub gap: f32,
-}
-pub(super) struct Group {
-    pub parent: Id,
-    pub blocks: Vec<Block>,
-    pub bands: Vec<Band>,
-    pub undirected: BTreeSet<(usize, usize)>,
-}
-
-#[derive(Clone)]
-struct Unit {
-    blocks: Vec<usize>,
-    sources: BTreeSet<Id>,
-    hints: Vec<(Id, Id, Id)>,
-}
-
-fn center(
-    id: Id,
-    parents: &BTreeMap<Id, Option<Id>>,
-    offsets: &BTreeMap<Id, Position>,
-    sizes: &BTreeMap<Id, Size>,
-    work: &mut usize,
-) -> Result<f64, ModelError> {
-    let mut at = Some(id);
-    let mut seen = BTreeSet::new();
-    let mut y = 0.0_f32;
-    while let Some(node) = at {
-        charge(work, 1)?;
-        if !seen.insert(node) {
-            return Err(error("boundary cyclic ancestry"));
-        }
-        let pos = offsets
-            .get(&node)
-            .ok_or_else(|| error("boundary missing offset"))?;
-        if !pos.x.is_finite() || !pos.y.is_finite() {
-            return Err(error("boundary nonfinite offset"));
-        }
-        if seen.len() == 1 {
-            y = pos.y;
-        } else {
-            y += pos.y;
-        }
-        if !y.is_finite() {
-            return Err(error("boundary composed position overflow"));
-        }
-        at = *parents
-            .get(&node)
-            .ok_or_else(|| error("boundary missing parent"))?;
-    }
-    let size = sizes
-        .get(&id)
-        .ok_or_else(|| error("boundary missing source size"))?;
-    y += 40.0;
-    let center = f64::from(y) + f64::from(size.height) / 2.0;
-    if !center.is_finite() {
-        return Err(error("boundary nonfinite center"));
-    }
-    Ok(center)
-}
-
-fn translate(value: f32, old_origin: f32, new_origin: f32) -> Result<f32, ModelError> {
-    // Bound the complete displacement, including origin subtraction. A rounded
-    // f32 delta can hide lost relative precision even when its addition is exact.
-    let intended = f64::from(value) + (f64::from(new_origin) - f64::from(old_origin));
-    let next = intended as f32;
-    if !next.is_finite() || (f64::from(next) - intended).abs() > 0.001 {
-        return Err(error("boundary member translation precision exceeded"));
-    }
-    Ok(next)
-}
-
-fn score(
-    unit: &Unit,
-    parents: &BTreeMap<Id, Option<Id>>,
-    offsets: &BTreeMap<Id, Position>,
-    sizes: &BTreeMap<Id, Size>,
-    work: &mut usize,
-) -> Result<Option<f64>, ModelError> {
-    if unit.sources.is_empty() {
-        return Ok(None);
-    }
-    let mut total = 0.0;
-    for &source in &unit.sources {
-        total += center(source, parents, offsets, sizes, work)?;
-    }
-    let value = total / unit.sources.len() as f64;
-    if !value.is_finite() {
-        return Err(error("boundary nonfinite mean"));
-    }
-    Ok(Some(value))
-}
-
-fn ordered_units(scores: &[Option<f64>]) -> Vec<usize> {
-    let mut anchored: Vec<_> = (0..scores.len()).filter(|&i| scores[i].is_some()).collect();
-    anchored.sort_by(|&a, &b| {
-        scores[a]
-            .unwrap()
-            .total_cmp(&scores[b].unwrap())
-            .then(a.cmp(&b))
-    });
-    let mut next = anchored.into_iter();
-    (0..scores.len())
-        .map(|i| {
-            if scores[i].is_some() {
-                next.next().unwrap()
-            } else {
-                i
-            }
-        })
-        .collect()
-}
-
-fn packing(
-    blocks: &[Block],
-    before: &[usize],
-    after: &[usize],
-    gap: f32,
-) -> Result<Vec<f32>, ModelError> {
-    const EPS: f64 = 0.001;
-    let origin = f64::from(blocks[before[0]].position.y);
-    let mut canonical = origin;
-    for &c in before {
-        if (f64::from(blocks[c].position.y) - canonical).abs() > EPS {
-            return Err(error("boundary non-prefix canonical band"));
-        }
-        canonical += f64::from(blocks[c].size.height) + f64::from(gap);
-    }
-    let mut next = origin;
-    let mut ys = Vec::new();
-    for &c in after {
-        let y = next as f32;
-        if !y.is_finite() || (f64::from(y) - next).abs() > EPS {
-            return Err(error("boundary prefix precision bound exceeded"));
-        }
-        ys.push(y);
-        next += f64::from(blocks[c].size.height) + f64::from(gap);
-    }
-    if (next - canonical).abs() > EPS {
-        return Err(error("boundary envelope changed"));
-    }
-    if before == after {
-        Ok(before.iter().map(|&c| blocks[c].position.y).collect())
-    } else {
-        Ok(ys)
-    }
-}
-
-pub(super) fn reorder(
-    groups: &mut [Group],
-    parents: &BTreeMap<Id, Option<Id>>,
-    offsets: &mut BTreeMap<Id, Position>,
-    sizes: &BTreeMap<Id, Size>,
-    edges: &[ProjectedEdge],
-    work: &mut usize,
-) -> Result<serde_json::Value, ModelError> {
-    let mut group_order: Vec<_> = (0..groups.len()).collect();
-    group_order.sort_by_key(|&i| groups[i].parent);
-    let mut offset_owner = BTreeMap::new();
-    let mut parent_seen = BTreeSet::new();
-    let mut units: Vec<Vec<Vec<Unit>>> = vec![Vec::new(); groups.len()];
-    let mut active = BTreeSet::new();
-    for &g in &group_order {
-        let group = &groups[g];
-        if !parent_seen.insert(group.parent) || !parents.contains_key(&group.parent) {
-            return Err(error("boundary duplicate/missing group parent"));
-        }
-        let mut child_block = BTreeMap::new();
-        for (c, block) in group.blocks.iter().enumerate() {
-            if !block.size.width.is_finite()
-                || !block.size.height.is_finite()
-                || block.size.width <= 0.0
-                || block.size.height <= 0.0
-                || !block.position.x.is_finite()
-                || !block.position.y.is_finite()
-            {
-                return Err(error("boundary invalid block geometry"));
-            }
-            for &id in &block.members {
-                if parents.get(&id) != Some(&Some(group.parent))
-                    || !offsets.contains_key(&id)
-                    || child_block.insert(id, c).is_some()
-                    || offset_owner.insert(id, g).is_some()
-                {
-                    return Err(error("boundary invalid child membership"));
-                }
-            }
-        }
-        let mut covered = BTreeSet::new();
-        for band in &group.bands {
-            if !band.gap.is_finite() || band.gap < 0.0 || band.components.is_empty() {
-                return Err(error("boundary invalid band"));
-            }
-            let local: BTreeMap<_, _> = band
-                .components
-                .iter()
-                .enumerate()
-                .map(|(i, &c)| (c, i))
-                .collect();
-            for &c in &band.components {
-                if c >= group.blocks.len() || !covered.insert(c) {
-                    return Err(error("boundary duplicate/unknown band block"));
-                }
-            }
-            let mut arcs = vec![BTreeSet::new(); band.components.len()];
-            for &(a, b) in &group.undirected {
-                charge(work, 1)?;
-                if let (Some(&a), Some(&b)) = (local.get(&a), local.get(&b)) {
-                    arcs[a].insert(b);
-                    arcs[b].insert(a);
-                }
-            }
-            let bundles = components(&arcs, work)?;
-            let mut band_units = Vec::new();
-            for bundle in bundles {
-                if bundle.windows(2).any(|v| v[1] != v[0] + 1) {
-                    return Err(error("boundary undirected bundle not contiguous"));
-                }
-                let blocks: Vec<_> = bundle.iter().map(|&i| band.components[i]).collect();
-                let mut unit = Unit {
-                    blocks,
-                    sources: BTreeSet::new(),
-                    hints: Vec::new(),
-                };
-                for edge in edges {
-                    charge(work, 1)?;
-                    if !edge.oriented {
-                        continue;
-                    }
-                    let target = lift(edge.target, Some(group.parent), parents, work)?;
-                    let Some(target) = target else {
-                        continue;
-                    };
-                    if !unit.blocks.contains(
-                        child_block
-                            .get(&target)
-                            .ok_or_else(|| error("boundary missing lifted target"))?,
-                    ) {
-                        continue;
-                    }
-                    if lift(edge.source, Some(group.parent), parents, work)?.is_none() {
-                        unit.sources.insert(edge.source);
-                        unit.hints.push((edge.id, edge.source, edge.target));
-                    }
-                }
-                unit.hints.sort();
-                band_units.push(unit);
-            }
-            if band_units.iter().filter(|u| !u.sources.is_empty()).count() >= 2 {
-                active.insert(g);
-            }
-            units[g].push(band_units);
-        }
-        if covered.len() != group.blocks.len() {
-            return Err(error("boundary incomplete band inventory"));
-        }
-    }
-    let active_order: Vec<_> = group_order
-        .into_iter()
-        .filter(|g| active.contains(g))
-        .collect();
-    let active_index: BTreeMap<_, _> = active_order
-        .iter()
-        .enumerate()
-        .map(|(i, &g)| (g, i))
-        .collect();
-    let mut dependencies = vec![BTreeSet::new(); active_order.len()];
-    let mut dependency_evidence = BTreeSet::new();
-    for (&g, &gi) in &active_index {
-        for unit in units[g].iter().flatten() {
-            for &source in &unit.sources {
-                let mut at = Some(source);
-                let mut seen = BTreeSet::new();
-                while let Some(node) = at {
-                    charge(work, 1)?;
-                    if !seen.insert(node) {
-                        return Err(error("boundary dependency ancestry cycle"));
-                    }
-                    if let Some(&owner) = offset_owner.get(&node)
-                        && let Some(&oi) = active_index.get(&owner)
-                    {
-                        dependencies[oi].insert(gi);
-                        dependency_evidence.insert((
-                            groups[owner].parent,
-                            groups[g].parent,
-                            source,
-                            node,
-                        ));
-                    }
-                    at = *parents
-                        .get(&node)
-                        .ok_or_else(|| error("boundary missing dependency ancestor"))?;
-                }
-            }
-        }
-    }
-    let sccs = components(&dependencies, work)?;
-    let mut scc_owner = vec![0; active_order.len()];
-    for (s, members) in sccs.iter().enumerate() {
-        for &i in members {
-            scc_owner[i] = s;
-        }
-    }
-    let mut dag = vec![BTreeSet::new(); sccs.len()];
-    for (a, targets) in dependencies.iter().enumerate() {
-        for &b in targets {
-            if scc_owner[a] != scc_owner[b] {
-                dag[scc_owner[a]].insert(scc_owner[b]);
-            }
-        }
-    }
-    let mut done = BTreeSet::new();
-    let mut records = Vec::new();
-    let mut processed = Vec::new();
-    while done.len() < sccs.len() {
-        charge(work, sccs.len() * sccs.len())?;
-        let s = (0..sccs.len())
-            .find(|s| {
-                !done.contains(s)
-                    && (0..sccs.len()).all(|p| !dag[p].contains(s) || done.contains(&p))
-            })
-            .ok_or_else(|| error("boundary condensation cycle"))?;
-        // Score the entire dependency SCC before modifying any offsets.
-        let mut snapshots = Vec::new();
-        for &i in &sccs[s] {
-            let g = active_order[i];
-            for (b, band_units) in units[g].iter().enumerate() {
-                let scores = band_units
-                    .iter()
-                    .map(|u| score(u, parents, offsets, sizes, work))
-                    .collect::<Result<Vec<_>, _>>()?;
-                snapshots.push((g, b, scores));
-            }
-        }
-        for (g, b, scores) in snapshots {
-            let band_units = &units[g][b];
-            let order = ordered_units(&scores);
-            let before = groups[g].bands[b].components.clone();
-            let gap = groups[g].bands[b].gap;
-            let after: Vec<_> = order
-                .iter()
-                .flat_map(|&u| band_units[u].blocks.iter().copied())
-                .collect();
-            let ys = packing(&groups[g].blocks, &before, &after, gap)?;
-            let mut changed = Vec::new();
-            for (&c, y) in after.iter().zip(ys) {
-                charge(work, groups[g].blocks[c].members.len() + 1)?;
-                let old = groups[g].blocks[c].position.y;
-                if !y.is_finite() {
-                    return Err(error("boundary packing overflow"));
-                }
-                if y != old {
-                    changed.push(c);
-                }
-                for id in &groups[g].blocks[c].members {
-                    let p = offsets
-                        .get_mut(id)
-                        .ok_or_else(|| error("boundary lost member offset"))?;
-                    p.y = translate(p.y, old, y)?;
-                }
-                groups[g].blocks[c].position.y = y;
-            }
-            groups[g].bands[b].components = after.clone();
-            let changed_units: Vec<_> = band_units
-                .iter()
-                .enumerate()
-                .filter(|(_, u)| u.blocks.iter().any(|c| changed.contains(c)))
-                .map(|(i, _)| i)
-                .collect();
-            records.push(serde_json::json!({"parent":groups[g].parent,"band":b,"before_blocks":before,"after_blocks":after,"unit_order":order,"scores":scores,"changed_blocks":changed,"changed_units":changed_units,"envelope_epsilon":0.001,"units":band_units.iter().map(|u|serde_json::json!({"blocks":u.blocks,"source_owners":u.sources,"edge_hints":u.hints})).collect::<Vec<_>>()}));
-        }
-        processed.push(serde_json::json!({"parents":sccs[s].iter().map(|&i|groups[active_order[i]].parent).collect::<Vec<_>>(),"cyclic":sccs[s].len()>1||sccs[s].iter().any(|&i|dependencies[i].contains(&i)),"policy":"all scores snapshotted before one simultaneous group-permutation pass"}));
-        done.insert(s);
-    }
-    Ok(
-        serde_json::json!({"active_parents":active_order.iter().map(|&g|groups[g].parent).collect::<Vec<_>>(),"dependencies":dependency_evidence,"dependency_components":processed,"bands":records,"limitation":"One pass; cyclic dependencies use a common snapshot, not a fixed-point solution. Root unchanged; no quality or repeat-stability acceptance."}),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn id(n: u128) -> Id {
-        Id::from_u128(n)
-    }
-    fn block(n: u128, y: f32, height: f32) -> Block {
-        Block {
-            members: vec![id(n)],
-            size: Size {
-                width: 10.0,
-                height,
-            },
-            position: Position { x: 0.0, y },
-        }
-    }
-    fn edge(n: u128, source: u128, target: u128) -> ProjectedEdge {
-        ProjectedEdge {
-            id: id(n),
-            source: id(source),
-            target: id(target),
-            trace: false,
-            oriented: true,
-            source_port: None,
-            target_port: None,
-        }
-    }
-    #[test]
-    fn anchored_sort_preserves_unanchored_ordinal_slot() {
-        assert_eq!(
-            ordered_units(&[Some(90.0), None, Some(10.0), Some(10.0)]),
-            vec![2, 1, 3, 0]
-        );
-    }
-    #[test]
-    fn heterogeneous_blocks_use_new_prefix_not_old_slots() {
-        let blocks = vec![
-            Block {
-                members: vec![],
-                size: Size {
-                    width: 10.0,
-                    height: 100.0,
-                },
-                position: Position { x: 0.0, y: 0.0 },
-            },
-            Block {
-                members: vec![],
-                size: Size {
-                    width: 10.0,
-                    height: 20.0,
-                },
-                position: Position { x: 0.0, y: 132.0 },
-            },
-        ];
-        assert_eq!(
-            packing(&blocks, &[0, 1], &[1, 0], 32.0).unwrap(),
-            vec![0.0, 52.0]
-        );
-    }
-    #[test]
-    fn center_includes_grandparent_offset_change() {
-        let (a, b, c) = (Id::from_u128(1), Id::from_u128(2), Id::from_u128(3));
-        let parents = BTreeMap::from([(a, None), (b, Some(a)), (c, Some(b))]);
-        let mut offsets = BTreeMap::from([
-            (a, Position { x: 0.0, y: 100.0 }),
-            (b, Position { x: 0.0, y: 20.0 }),
-            (c, Position { x: 0.0, y: 5.0 }),
-        ]);
-        let sizes = BTreeMap::from([(
-            c,
-            Size {
-                width: 10.0,
-                height: 10.0,
-            },
-        )]);
-        assert_eq!(
-            center(c, &parents, &offsets, &sizes, &mut 0).unwrap(),
-            170.0
-        );
-        offsets.get_mut(&a).unwrap().y += 300.0;
-        assert_eq!(
-            center(c, &parents, &offsets, &sizes, &mut 0).unwrap(),
-            470.0
-        );
-    }
-    #[test]
-    fn ancestor_dependency_updates_downstream_scores_before_its_permutation() {
-        // Downstream parent1 sorts before upstream20, so an absent ancestor
-        // dependency would leave downstream order unchanged and fail this test.
-        let mut groups = vec![
-            Group {
-                parent: id(1),
-                blocks: vec![block(2, 0.0, 100.0), block(3, 132.0, 100.0)],
-                bands: vec![Band {
-                    components: vec![0, 1],
-                    gap: 32.0,
-                }],
-                undirected: BTreeSet::new(),
-            },
-            Group {
-                parent: id(20),
-                blocks: vec![block(21, 0.0, 100.0), block(22, 132.0, 100.0)],
-                bands: vec![Band {
-                    components: vec![0, 1],
-                    gap: 32.0,
-                }],
-                undirected: BTreeSet::new(),
-            },
-        ];
-        let parents = BTreeMap::from([
-            (id(1), None),
-            (id(2), Some(id(1))),
-            (id(3), Some(id(1))),
-            (id(20), None),
-            (id(21), Some(id(20))),
-            (id(22), Some(id(20))),
-            (id(23), Some(id(21))),
-            (id(30), None),
-            (id(31), None),
-            (id(32), None),
-        ]);
-        let mut offsets: BTreeMap<_, _> = [
-            (1, 0.0),
-            (2, 0.0),
-            (3, 132.0),
-            (20, 0.0),
-            (21, 0.0),
-            (22, 132.0),
-            (23, 10.0),
-            (30, 300.0),
-            (31, 0.0),
-            (32, 50.0),
-        ]
-        .into_iter()
-        .map(|(n, y)| (id(n), Position { x: 0.0, y }))
-        .collect();
-        let sizes = parents
-            .keys()
-            .map(|&n| {
-                (
-                    n,
-                    Size {
-                        width: 10.0,
-                        height: 10.0,
-                    },
-                )
-            })
-            .collect();
-        let edges = vec![
-            edge(101, 30, 21),
-            edge(102, 31, 22),
-            edge(103, 23, 2),
-            edge(104, 32, 3),
-        ];
-        let report = reorder(&mut groups, &parents, &mut offsets, &sizes, &edges, &mut 0).unwrap();
-        assert_eq!(groups[1].bands[0].components, vec![1, 0]);
-        assert_eq!(groups[0].bands[0].components, vec![1, 0]);
-        assert_eq!(offsets[&id(21)].y, 132.0);
-        assert_eq!(offsets[&id(23)].y, 10.0); // descendant is not directly moved
-        assert_eq!(
-            center(id(23), &parents, &offsets, &sizes, &mut 0).unwrap(),
-            187.0
-        );
-        assert_eq!(
-            report["dependency_components"][0]["parents"][0],
-            serde_json::json!(id(20))
-        );
-    }
-    #[test]
-    fn undirected_bundle_stays_whole_around_unanchored_unit() {
-        let mut groups = vec![Group {
-            parent: id(100),
-            blocks: vec![
-                block(101, 0.0, 20.0),
-                block(102, 30.0, 30.0),
-                block(103, 70.0, 40.0),
-                block(104, 120.0, 10.0),
-            ],
-            bands: vec![Band {
-                components: vec![0, 1, 2, 3],
-                gap: 10.0,
-            }],
-            undirected: BTreeSet::from([(0, 1)]),
-        }];
-        let parents = BTreeMap::from([
-            (id(100), None),
-            (id(101), Some(id(100))),
-            (id(102), Some(id(100))),
-            (id(103), Some(id(100))),
-            (id(104), Some(id(100))),
-            (id(110), None),
-            (id(111), None),
-        ]);
-        let mut offsets: BTreeMap<_, _> = [
-            (100, 0.0),
-            (101, 0.0),
-            (102, 30.0),
-            (103, 70.0),
-            (104, 120.0),
-            (110, 300.0),
-            (111, 0.0),
-        ]
-        .into_iter()
-        .map(|(n, y)| (id(n), Position { x: 0.0, y }))
-        .collect();
-        let sizes = parents
-            .keys()
-            .map(|&n| {
-                (
-                    n,
-                    Size {
-                        width: 10.0,
-                        height: 10.0,
-                    },
-                )
-            })
-            .collect();
-        let report = reorder(
-            &mut groups,
-            &parents,
-            &mut offsets,
-            &sizes,
-            &[
-                edge(201, 110, 101),
-                edge(202, 110, 102),
-                edge(203, 111, 104),
-            ],
-            &mut 0,
-        )
-        .unwrap();
-        assert_eq!(groups[0].bands[0].components, vec![3, 2, 0, 1]);
-        assert_eq!(
-            [
-                offsets[&id(104)].y,
-                offsets[&id(103)].y,
-                offsets[&id(101)].y,
-                offsets[&id(102)].y
-            ],
-            [0.0, 20.0, 70.0, 100.0]
-        );
-        assert_eq!(
-            report["bands"][0]["units"][0]["source_owners"]
-                .as_array()
-                .unwrap()
-                .len(),
-            1
-        );
-    }
-    #[test]
-    fn center_uses_final_plan_f32_composition_and_translation_has_error_bound() {
-        let parents = BTreeMap::from([(id(1), None), (id(2), Some(id(1))), (id(3), Some(id(2)))]);
-        let offsets = BTreeMap::from([
-            (
-                id(1),
-                Position {
-                    x: 0.0,
-                    y: -100000.0,
-                },
-            ),
-            (
-                id(2),
-                Position {
-                    x: 0.0,
-                    y: 100000.0,
-                },
-            ),
-            (id(3), Position { x: 0.0, y: 0.1 }),
-        ]);
-        let sizes = BTreeMap::from([(
-            id(3),
-            Size {
-                width: 10.0,
-                height: 10.0,
-            },
-        )]);
-        assert_eq!(
-            center(id(3), &parents, &offsets, &sizes, &mut 0).unwrap(),
-            45.1015625
-        );
-        assert_eq!(translate(10.125, 0.0, 0.375).unwrap(), 10.5);
-        assert!(translate(32768.0, 0.0, 0.002).is_err());
-    }
-
-    #[test]
-    fn member_offset_survives_large_origin_subtraction() {
-        let blocks = vec![
-            block(1, 0.0, 65404.0),
-            block(2, 65436.0, 68.0),
-            block(3, 65536.0, 100.0),
-            block(4, 65668.0, 68.002),
-        ];
-        let ys = packing(&blocks, &[0, 1, 2, 3], &[3, 2, 1, 0], 32.0).unwrap();
-        let member = translate(65568.0, 65536.0, ys[1]).unwrap();
-        assert!((f64::from(member) - f64::from(ys[1]) - 32.0).abs() <= 0.001);
-    }
-}

crates/oa-core/examples/auto_layout_probe/layered.rs

@@ -1,380 +0,0 @@
-//! Isolated #32 experiment, not a production layout engine.
-//! Uses existing Layout sizing, three deterministic ordering passes, and one
-//! core-estimated-label spacing pass. Automatic elbows remain derived. Folded/omitted
-//! node topology is explicitly unsupported; filtered edges retain their metadata.
-use oa_core::{Command, Id, ModelError, Position, Project, Size, projection, routing};
-use std::collections::{BTreeMap, BTreeSet};
-
-const WORK_LIMIT: usize = 200_000;
-const NODE_LIMIT: usize = 256;
-const EDGE_LIMIT: usize = 1024;
-
-fn spend(work: &mut usize) -> Result<(), ModelError> {
-    *work += 1;
-    if *work > WORK_LIMIT {
-        return Err(ModelError("Layered probe work limit exceeded.".into()));
-    }
-    Ok(())
-}
-
-/// Return a new Project; caller owns comparison, history and serialization.
-pub fn candidate(project: &Project, diagram: Id) -> Result<Project, ModelError> {
-    let original = project
-        .diagrams
-        .get(&diagram)
-        .ok_or_else(|| ModelError("Missing probe diagram.".into()))?;
-    let view = projection::project_diagram(project, original);
-    if view.nodes.len() > NODE_LIMIT || view.edges.len() > EDGE_LIMIT {
-        return Err(ModelError("Layered probe graph limit exceeded.".into()));
-    }
-    if view.nodes.len() != original.nodes.len() || view.nodes.iter().any(|n| n.collapsed) {
-        return Err(ModelError(
-            "Layered probe does not support folded/omitted node topology.".into(),
-        ));
-    }
-    let routed = routing::route_diagram(project, original, &view);
-    let eligible: BTreeSet<_> = view
-        .edges
-        .iter()
-        .filter(|edge| {
-            projection::edge_endpoint_placements(project, original, edge.id)
-                == Some((edge.source, edge.target))
-                && routed
-                    .edges
-                    .get(&edge.id)
-                    .is_some_and(|route| !route.custom_suspended)
-        })
-        .map(|edge| edge.id)
-        .collect();
-    let mut result = oa_core::prepare_command(project, &Command::Layout(diagram))?.project;
-    // Discard baseline route translation: final routes are reconstructed directly
-    // from original geometry, avoiding two translations and preserving list order.
-    result.diagrams.get_mut(&diagram).unwrap().routes = original.routes.clone();
-    for route in &mut result.diagrams.get_mut(&diagram).unwrap().routes {
-        if eligible.contains(&route.edge) {
-            route.waypoints.clear();
-            route.label = None;
-        }
-    }
-    let baseline = projection::project_view(&result, diagram);
-    let labels = routing::route_diagram(&result, &result.diagrams[&diagram], &baseline);
-    let mut gap_x = 64.0_f32;
-    let mut gap_y = 32.0_f32;
-    for edge in labels.edges.values() {
-        gap_x = gap_x.max(edge.label.bounds.size.width + 24.0);
-        gap_y = gap_y.max(edge.label.bounds.size.height + 24.0);
-        if let Some(relation) = result.relations.get(&edge.id) {
-            for end in routing::association_end_geometry(relation, edge) {
-                gap_x = gap_x.max(end.label.bounds.size.width + 24.0);
-                gap_y = gap_y.max(end.label.bounds.size.height + 24.0);
-            }
-        }
-    }
-    if !gap_x.is_finite() || !gap_y.is_finite() {
-        return Err(ModelError("Nonfinite estimated label bound.".into()));
-    }
-    let parents: BTreeMap<_, _> = baseline
-        .nodes
-        .iter()
-        .map(|n| (n.id, n.visual_parent))
-        .collect();
-    let mut children: BTreeMap<Option<Id>, Vec<Id>> = BTreeMap::new();
-    for node in &baseline.nodes {
-        children
-            .entry(node.visual_parent)
-            .or_default()
-            .push(node.id);
-    }
-    let names: BTreeMap<_, _> = baseline
-        .nodes
-        .iter()
-        .map(|n| (n.id, (result.elements[&n.element].alias.clone(), n.id)))
-        .collect();
-    for siblings in children.values_mut() {
-        siblings.sort_by_key(|id| names[id].clone());
-    }
-    let minima: BTreeMap<_, _> = baseline.nodes.iter().map(|n| (n.id, n.size)).collect();
-    let headers: BTreeMap<_, _> = baseline
-        .nodes
-        .iter()
-        .map(|n| {
-            (
-                n.id,
-                if original.projection.state_machine().is_some() {
-                    projection::state_header_height(&result, n.element)
-                } else {
-                    64.0
-                },
-            )
-        })
-        .collect();
-    let mut positions: BTreeMap<_, _> = baseline.nodes.iter().map(|n| (n.id, n.position)).collect();
-    let mut sizes = minima.clone();
-    let mut work = 0;
-    let mut group_order: Vec<_> = children.keys().copied().collect();
-    group_order.sort_by_key(|parent| {
-        parent.map_or(0, |id| {
-            baseline.nodes.iter().find(|n| n.id == id).unwrap().depth + 1
-        })
-    });
-    let mut groups = BTreeMap::new();
-    for pass in 0..3 {
-        for parent in &group_order {
-            let siblings = &children[parent];
-            let mut arcs = BTreeSet::new();
-            for edge in &baseline.edges {
-                spend(&mut work)?;
-                let a = child_under(edge.source, *parent, &parents, &mut work)?;
-                let b = child_under(edge.target, *parent, &parents, &mut work)?;
-                if edge.oriented
-                    && let (Some(a), Some(b)) = (a, b)
-                    && a != b
-                {
-                    arcs.insert((a, b));
-                }
-            }
-            let ranks = ranks(siblings, &arcs, &mut work)?;
-            let mut layers: BTreeMap<usize, Vec<Id>> = BTreeMap::new();
-            for id in siblings {
-                layers.entry(ranks[id]).or_default().push(*id);
-            }
-            // Boundary neighbours participate even though they are not siblings.
-            // Incoming preference anchors the downstream order to its upstream
-            // counterpart instead of swapping both sides simultaneously.
-            let mut scores = BTreeMap::new();
-            for id in siblings {
-                let mut incoming = Vec::new();
-                for edge in &baseline.edges {
-                    spend(&mut work)?;
-                    let a = child_under(edge.source, *parent, &parents, &mut work)?;
-                    let b = child_under(edge.target, *parent, &parents, &mut work)?;
-                    if edge.oriented && b == Some(*id) && a != Some(*id) {
-                        incoming.push(positions[&edge.source].y + sizes[&edge.source].height / 2.0);
-                    }
-                }
-                // Do not also chase outgoing boundary neighbours: simultaneous
-                // swaps in two connected containers can preserve the crossing.
-                let values = &incoming;
-                let score = if values.is_empty() {
-                    positions[id].y
-                } else {
-                    values.iter().sum::<f32>() / values.len() as f32
-                };
-                scores.insert(*id, score);
-            }
-            for layer in layers.values_mut() {
-                // First pass starts from canonical alias order; subsequent passes
-                // retain a deterministic alias tie break, never hash iteration.
-                if pass > 0 {
-                    layer.sort_by(|a, b| {
-                        scores[a]
-                            .total_cmp(&scores[b])
-                            .then_with(|| names[a].cmp(&names[b]))
-                    });
-                }
-            }
-            groups.insert(*parent, layers.into_values().collect::<Vec<_>>());
-        }
-        // Recompute from frozen minima, never add spacing to last pass's size.
-        sizes = minima.clone();
-        measure(None, &groups, &headers, &mut sizes, gap_x, gap_y, &mut work)?;
-        place(
-            None,
-            Position { x: 40.0, y: 40.0 },
-            &groups,
-            &headers,
-            &sizes,
-            &mut positions,
-            gap_x,
-            gap_y,
-            &mut work,
-        )?;
-    }
-    let d = result.diagrams.get_mut(&diagram).unwrap();
-    for (id, node) in &mut d.nodes {
-        node.position = positions[id];
-        node.size = sizes[id];
-    }
-    let deltas: BTreeMap<_, _> = original
-        .nodes
-        .iter()
-        .map(|(id, node)| {
-            (
-                *id,
-                Position {
-                    x: positions[id].x - node.position.x,
-                    y: positions[id].y - node.position.y,
-                },
-            )
-        })
-        .collect();
-    let translated: BTreeMap<_, _> = projection::translated_routes(project, original, &deltas)
-        .into_iter()
-        .map(|r| (r.edge, r))
-        .collect();
-    d.routes = original
-        .routes
-        .iter()
-        .map(|route| {
-            let mut route = translated.get(&route.edge).unwrap_or(route).clone();
-            if eligible.contains(&route.edge) {
-                route.waypoints.clear();
-                route.label = None;
-            }
-            route
-        })
-        .collect();
-    if d.nodes.values().any(|n| {
-        !n.position.x.is_finite()
-            || !n.position.y.is_finite()
-            || !n.size.width.is_finite()
-            || !n.size.height.is_finite()
-            || n.size.width <= 0.0
-            || n.size.height <= 0.0
-    }) {
-        return Err(ModelError("Invalid layered probe geometry.".into()));
-    }
-    oa_core::validate_candidate(&result)?;
-    Ok(result)
-}
-
-fn child_under(
-    mut id: Id,
-    parent: Option<Id>,
-    parents: &BTreeMap<Id, Option<Id>>,
-    work: &mut usize,
-) -> Result<Option<Id>, ModelError> {
-    for _ in 0..=parents.len() {
-        spend(work)?;
-        let Some(actual) = parents.get(&id) else {
-            return Ok(None);
-        };
-        if *actual == parent {
-            return Ok(Some(id));
-        }
-        let Some(next) = actual else { return Ok(None) };
-        id = *next;
-    }
-    Err(ModelError("Layered probe containment cycle.".into()))
-}
-
-fn ranks(
-    ids: &[Id],
-    arcs: &BTreeSet<(Id, Id)>,
-    work: &mut usize,
-) -> Result<BTreeMap<Id, usize>, ModelError> {
-    let mut remaining: BTreeSet<_> = ids.iter().copied().collect();
-    let mut ranks: BTreeMap<_, usize> = BTreeMap::new();
-    while !remaining.is_empty() {
-        let mut ready = None;
-        for id in ids.iter().filter(|id| remaining.contains(*id)) {
-            let mut blocked = false;
-            for (a, b) in arcs {
-                spend(work)?;
-                blocked |= b == id && remaining.contains(a);
-            }
-            if !blocked {
-                ready = Some(*id);
-                break;
-            }
-        }
-        // Explicit cycle fallback: break the first canonical remaining vertex's
-        // incoming ranking constraints. Actual relation direction is unchanged.
-        let id = ready.unwrap_or_else(|| *ids.iter().find(|id| remaining.contains(*id)).unwrap());
-        let mut rank = 0;
-        for (a, b) in arcs {
-            spend(work)?;
-            if *b == id
-                && let Some(previous) = ranks.get(a)
-            {
-                rank = rank.max(previous + 1);
-            }
-        }
-        ranks.insert(id, rank);
-        remaining.remove(&id);
-    }
-    Ok(ranks)
-}
-
-type Groups = BTreeMap<Option<Id>, Vec<Vec<Id>>>;
-
-fn measure(
-    parent: Option<Id>,
-    groups: &Groups,
-    headers: &BTreeMap<Id, f32>,
-    sizes: &mut BTreeMap<Id, Size>,
-    gx: f32,
-    gy: f32,
-    work: &mut usize,
-) -> Result<Size, ModelError> {
-    let Some(layers) = groups.get(&parent) else {
-        return Ok(Size {
-            width: 0.0,
-            height: 0.0,
-        });
-    };
-    let mut width = 0.0;
-    let mut height = 0.0_f32;
-    for (i, layer) in layers.iter().enumerate() {
-        let mut lw = 0.0_f32;
-        let mut lh = 0.0;
-        for (j, id) in layer.iter().enumerate() {
-            spend(work)?;
-            let content = measure(Some(*id), groups, headers, sizes, gx, gy, work)?;
-            let size = sizes.get_mut(id).unwrap();
-            if groups.contains_key(&Some(*id)) {
-                size.width = size.width.max(content.width + 48.0);
-                size.height = size.height.max(content.height + headers[id] + 24.0);
-            }
-            lw = lw.max(size.width);
-            lh += size.height + if j == 0 { 0.0 } else { gy };
-        }
-        width += lw + if i == 0 { 0.0 } else { gx };
-        height = height.max(lh);
-    }
-    Ok(Size { width, height })
-}
-
-#[allow(clippy::too_many_arguments)]
-fn place(
-    parent: Option<Id>,
-    origin: Position,
-    groups: &Groups,
-    headers: &BTreeMap<Id, f32>,
-    sizes: &BTreeMap<Id, Size>,
-    positions: &mut BTreeMap<Id, Position>,
-    gx: f32,
-    gy: f32,
-    work: &mut usize,
-) -> Result<(), ModelError> {
-    let Some(layers) = groups.get(&parent) else {
-        return Ok(());
-    };
-    let mut x = origin.x;
-    for layer in layers {
-        let mut y = origin.y;
-        let mut width = 0.0_f32;
-        for id in layer {
-            spend(work)?;
-            positions.insert(*id, Position { x, y });
-            place(
-                Some(*id),
-                Position {
-                    x: x + 24.0,
-                    y: y + headers[id],
-                },
-                groups,
-                headers,
-                sizes,
-                positions,
-                gx,
-                gy,
-                work,
-            )?;
-            y += sizes[id].height + gy;
-            width = width.max(sizes[id].width);
-        }
-        x += width + gx;
-    }
-    Ok(())
-}

crates/oa-core/examples/multiselect_native.rs

@@ -1,717 +0,0 @@
-//! Native evidence fixture/checker; install as a temporary oa-core example.
-//! This invariant evaluator derives delta from saved A, NOT from pointer input.
-use oa_core::{source_project::*, *};
-use std::{fs, io::Write, path::Path};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn id(alias: &str) -> Id {
-    // Make the intended OA view first for default UUID-ordered view selection.
-    if alias == "oa_view" {
-        return Id::from_u128(0x29_0001);
-    }
-    Id::new_v5(
-        &Id::from_u128(0xc1192026_0923_5000_8000_000000000029),
-        alias.as_bytes(),
-    )
-}
-fn point(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-fn element(p: &mut Project, alias: &str, name: &str, kind: Kind, layer: Layer, parent: Option<Id>) {
-    p.elements.insert(
-        id(alias),
-        Element {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: format!("Preserve engineering record {alias}."),
-            parent,
-            body: ElementBody::new(kind, layer).unwrap(),
-        },
-    );
-}
-fn diagram(p: &mut Project, alias: &str, name: &str, layer: Layer) {
-    p.diagrams.insert(
-        id(alias),
-        Diagram {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: "Selection changes placement geometry only.".into(),
-            layer,
-            projection: ProjectionKind::Overview,
-            view_options: Default::default(),
-            layout: None,
-            nodes: Default::default(),
-            routes: vec![],
-        },
-    );
-}
-fn place(p: &mut Project, view: &str, alias: &str, object: &str, position: Position, size: Size) {
-    p.diagrams.get_mut(&id(view)).unwrap().nodes.insert(
-        id(alias),
-        NodePlacement {
-            id: id(alias),
-            alias: alias.into(),
-            element: id(object),
-            position,
-            size,
-            collapsed: false,
-            port_anchors: vec![],
-        },
-    );
-}
-fn route(edge: &str, pins: Vec<Position>) -> EdgeRoute {
-    EdgeRoute {
-        edge: id(edge),
-        waypoints: pins,
-        source_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Right,
-            offset: 0.25,
-        }),
-        target_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Left,
-            offset: 0.7,
-        }),
-        label: Some(EdgeLabel {
-            fraction: 0.45,
-            offset: point(7., -19.),
-        }),
-    }
-}
-fn fixture() -> Result<Project> {
-    let mut p = Project::empty();
-    p.id = id("project");
-    p.alias = "multiselect_native".into();
-    p.name = "Multiselect native".into();
-    p.description =
-        "Shift-select A and B; move together, retain C and engineering semantics.".into();
-    for (alias, name, parent) in [
-        ("activity_a", "A - receive request", None),
-        ("activity_b", "B - assess request", None),
-        ("activity_c", "C - dispatch response", None),
-        (
-            "activity_child",
-            "A.1 - classify request",
-            Some(id("activity_a")),
-        ),
-    ] {
-        element(&mut p, alias, name, Kind::Activity, Layer::Oa, parent);
-    }
-    element(
-        &mut p,
-        "sa_function",
-        "Technical request processing",
-        Kind::Function,
-        Layer::Sa,
-        None,
-    );
-    for (alias, name, source, target) in [
-        ("internal", "Request assessment", "activity_a", "activity_b"),
-        ("external", "Response decision", "activity_b", "activity_c"),
-    ] {
-        let old = p.relate(RelationKind::Interaction, name, id(source), id(target));
-        reidentify(&mut p, old, id(alias))?;
-        p.relations.get_mut(&id(alias)).unwrap().alias = alias.into();
-    }
-    diagram(
-        &mut p,
-        "oa_view",
-        "Multiselect native - OA overview",
-        Layer::Oa,
-    );
-    diagram(&mut p, "oa_other", "Other OA view - preserve", Layer::Oa);
-    diagram(&mut p, "sa_view", "SA engineering - preserve", Layer::Sa);
-    let size = Size {
-        width: 224.,
-        height: 94.,
-    };
-    place(
-        &mut p,
-        "oa_view",
-        "node_a",
-        "activity_a",
-        point(80., 80.),
-        Size {
-            width: 310.,
-            height: 260.,
-        },
-    );
-    place(
-        &mut p,
-        "oa_view",
-        "node_b",
-        "activity_b",
-        point(470., 120.),
-        size,
-    );
-    place(
-        &mut p,
-        "oa_view",
-        "node_c",
-        "activity_c",
-        point(780., 270.),
-        size,
-    );
-    place(
-        &mut p,
-        "oa_view",
-        "node_child",
-        "activity_child",
-        point(120., 210.),
-        size,
-    );
-    place(
-        &mut p,
-        "oa_other",
-        "other_a",
-        "activity_a",
-        point(40., 60.),
-        size,
-    );
-    place(
-        &mut p,
-        "sa_view",
-        "sa_node",
-        "sa_function",
-        point(100., 110.),
-        size,
-    );
-    p.diagrams.get_mut(&id("oa_view")).unwrap().routes = vec![
-        route("internal", vec![point(420., 145.), point(420., 186.)]),
-        route("external", vec![point(725., 150.), point(725., 336.)]),
-    ];
-    p.traces.insert(
-        id("trace"),
-        Trace {
-            id: id("trace"),
-            alias: "preserved_refinement".into(),
-            name: "Reviewed request refinement".into(),
-            description: "Group geometry and Hide preserve this trace and both endpoints.".into(),
-            oa: id("activity_a"),
-            sa: id("sa_function"),
-            kind: TraceKind::Refinement,
-            baseline: Some(TraceBaseline {
-                oa: p.properties(id("activity_a")).unwrap(),
-                sa: p.properties(id("sa_function")).unwrap(),
-                semantic: None,
-            }),
-        },
-    );
-    validate_candidate(&p)?;
-    Ok(p)
-}
-fn load(path: &Path) -> Result<Project> {
-    if path
-        .extension()
-        .is_some_and(|ext| ext.eq_ignore_ascii_case("arcadia"))
-    {
-        let disk = source_files::load_project(path, ProjectLimits::default())?;
-        // This deliberately partial engineering fixture has completeness
-        // warnings (allocation/behavior context). They are not source errors.
-        // Compilation, candidate validation and whole-Project equality still
-        // reject malformed source or any unexpected model change.
-        if disk
-            .diagnostics
-            .iter()
-            .any(|d| d.diagnostic.severity == validation::Severity::Error)
-        {
-            return Err(format!("Source discovery diagnostics: {:?}", disk.diagnostics).into());
-        }
-        let compiled = compile_bundle(&disk.reachable_bundle(), ProjectLimits::default())
-            .map_err(|e| format!("Source compile diagnostics: {e:?}"))?;
-        Ok(compiled.decoded.project)
-    } else {
-        Ok(persistence::load(path)?)
-    }
-}
-fn equal(expected: &Project, actual: &Project) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    let e = serde_json::to_value(expected)?;
-    let a = serde_json::to_value(actual)?;
-    let fields: Vec<_> = e
-        .as_object()
-        .unwrap()
-        .keys()
-        .filter(|key| e[*key] != a[*key])
-        .cloned()
-        .collect();
-    Err(format!("Whole Project mismatch in {fields:?}; no partial PASS").into())
-}
-fn roundtrip(p: &Project) -> Result<SourceBundle> {
-    validate_candidate(p)?;
-    equal(p, &persistence::decode(&serde_json::to_vec(p)?)?)?;
-    let bundle = format_bundle(p);
-    let compiled = compile_bundle(&bundle, ProjectLimits::default())
-        .map_err(|e| format!("Roundtrip: {e:?}"))?;
-    equal(p, &compiled.decoded.project)?;
-    Ok(bundle)
-}
-fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
-    fs::create_dir_all(path.parent().ok_or("Missing parent directory")?)?;
-    fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path)?
-        .write_all(bytes)?;
-    Ok(())
-}
-fn generate(out: &Path) -> Result<()> {
-    if out.exists() {
-        return Err("Output directory already exists; choose a fresh path".into());
-    }
-    let p = fixture()?;
-    let bundle = roundtrip(&p)?;
-    write_new(&out.join("baseline.json"), &serde_json::to_vec_pretty(&p)?)?;
-    for (path, source) in &bundle.files {
-        write_new(&out.join("source").join(path), source.as_bytes())?;
-    }
-    let names = [
-        "project",
-        "oa_view",
-        "oa_other",
-        "sa_view",
-        "activity_a",
-        "activity_b",
-        "activity_c",
-        "activity_child",
-        "node_a",
-        "node_b",
-        "node_c",
-        "node_child",
-        "internal",
-        "external",
-        "trace",
-        "sa_function",
-        "sa_node",
-        "other_a",
-    ];
-    let ids: std::collections::BTreeMap<_, _> =
-        names.into_iter().map(|name| (name, id(name))).collect();
-    write_new(
-        &out.join("manifest.json"),
-        &serde_json::to_vec_pretty(&serde_json::json!({
-            "fixture": "multiselect-native-20260923", "ids": ids, "source_entry": bundle.entry,
-            "move_members": ["node_a", "node_b", "node_child"], "fixed_member": "node_c",
-            "evaluation": "Whole Project invariant comparison; saved A supplies bounded shared delta, not an exact pointer oracle",
-            "hide": "Remove node_a/node_b only; retain child, stored routes, all model records and other views",
-        }))?,
-    )?;
-    equal(&p, &load(&out.join("baseline.json"))?)?;
-    equal(&p, &load(&out.join("source/project.arcadia"))?)?;
-    println!("PASS generated JSON and source bundle: {}", out.display());
-    Ok(())
-}
-fn check(mode: &str, baseline: &Path, saved: &Path) -> Result<()> {
-    let before = load(baseline)?;
-    let actual = load(saved)?;
-    validate_candidate(&before)?;
-    validate_candidate(&actual)?;
-    if before.id != id("project") {
-        return Err("Not this fixture's baseline project".into());
-    }
-    let mut expected = before.clone();
-    let mut delta = None;
-    match mode {
-        "unchanged" => {}
-        "hide" => {
-            let view = expected
-                .diagrams
-                .get_mut(&id("oa_view"))
-                .ok_or("Missing OA view")?;
-            for alias in ["node_a", "node_b"] {
-                view.nodes
-                    .remove(&id(alias))
-                    .ok_or("Baseline selected placement missing")?;
-            }
-            // references::remove_objects removes routes only when their semantic
-            // edge is deleted. Hide deletes placements; both routes MUST survive.
-        }
-        "moved" => {
-            let old = before
-                .diagrams
-                .get(&id("oa_view"))
-                .ok_or("Missing baseline OA view")?;
-            let new = actual
-                .diagrams
-                .get(&id("oa_view"))
-                .ok_or("Missing saved OA view")?;
-            let a = old
-                .nodes
-                .get(&id("node_a"))
-                .ok_or("Missing baseline A")?
-                .position;
-            let moved_a = new
-                .nodes
-                .get(&id("node_a"))
-                .ok_or("Missing saved A")?
-                .position;
-            let d = point(moved_a.x - a.x, moved_a.y - a.y);
-            if !d.x.is_finite()
-                || !d.y.is_finite()
-                || d.x.abs().max(d.y.abs()) > 500.
-                || d.x.hypot(d.y) < 10.
-            {
-                return Err(format!(
-                    "Move delta must have length >=10 and each axis <=500 world units: {d:?}"
-                )
-                .into());
-            }
-            if moved_a.x % 10. != 0. || moved_a.y % 10. != 0. {
-                return Err("Saved anchor is not on 10-unit grid".into());
-            }
-            let view = expected.diagrams.get_mut(&id("oa_view")).unwrap();
-            // Independent explicit fixture enumeration: no group/descendant/
-            // routing planner is called to predict the result.
-            for alias in ["node_a", "node_b", "node_child"] {
-                let node = view
-                    .nodes
-                    .get_mut(&id(alias))
-                    .ok_or("Missing expected moved placement")?;
-                node.position.x += d.x;
-                node.position.y += d.y;
-            }
-            let internal = view
-                .routes
-                .iter_mut()
-                .find(|route| route.edge == id("internal"))
-                .ok_or("Missing internal pins")?;
-            for pin in &mut internal.waypoints {
-                pin.x += d.x;
-                pin.y += d.y;
-            }
-            delta = Some(d);
-        }
-        _ => return Err("Mode must be moved, hide, or unchanged".into()),
-    }
-    equal(&expected, &actual)?;
-    roundtrip(&actual)?;
-    println!(
-        "{}",
-        serde_json::to_string_pretty(&serde_json::json!({
-            "result": "PASS", "mode": mode, "baseline": baseline, "saved": saved,
-            "comparison": "complete Project equality", "inferred_common_delta": delta,
-            "limits": "Invariant evaluator only; no pointer/action/focus/Undo/source-byte acceptance claim",
-        }))?
-    );
-    Ok(())
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    match args.as_slice() {
-        [command, out] if command == "generate" => generate(Path::new(out)),
-        [command, mode, baseline, saved] if command == "check" => check(mode, Path::new(baseline), Path::new(saved)),
-        _ => Err("Usage: multiselect-native-producer generate DIRECTORY | check moved|hide|unchanged BASELINE SAVED".into()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::BTreeSet;
-
-    // Produce evidence through real validated commands; the checker itself uses
-    // explicit fixture enumeration and never calls this movement implementation.
-    fn moved(before: &Project, delta: Position) -> Project {
-        let command = diagram_edit::translate_placements(
-            before,
-            id("oa_view"),
-            &BTreeSet::from([id("node_a"), id("node_b")]),
-            delta,
-        )
-        .unwrap();
-        let mut session = Session::new(before.clone());
-        session.execute(command).unwrap();
-        session.project().clone()
-    }
-    fn hidden(before: &Project) -> Project {
-        let mut session = Session::new(before.clone());
-        session
-            .execute(Command::Batch(vec![
-                Command::Delete(id("node_a")),
-                Command::Delete(id("node_b")),
-            ]))
-            .unwrap();
-        session.project().clone()
-    }
-    fn through_saved_json(mode: &str, baseline: &Project, actual: &Project) -> Result<()> {
-        let dir = tempfile::tempdir()?;
-        let before = dir.path().join("before.json");
-        let saved = dir.path().join("saved.json");
-        // These assertions distinguish meaningful invariant corruptions from
-        // malformed projects rejected before the evaluator even sees them.
-        validate_candidate(baseline).expect("test baseline must be valid");
-        validate_candidate(actual).expect("corruption must remain a valid model");
-        persistence::save(&before, baseline)?;
-        persistence::save(&saved, actual)?;
-        check(mode, &before, &saved)
-    }
-    fn mismatch(mode: &str, before: &Project, actual: &Project, case: &str) {
-        let error = through_saved_json(mode, before, actual)
-            .expect_err(case)
-            .to_string();
-        assert!(
-            error.contains("Whole Project mismatch"),
-            "{case}: unexpected rejection: {error}"
-        );
-    }
-    fn edge<'a>(p: &'a mut Project, alias: &str) -> &'a mut EdgeRoute {
-        p.diagrams
-            .get_mut(&id("oa_view"))
-            .unwrap()
-            .routes
-            .iter_mut()
-            .find(|route| route.edge == id(alias))
-            .unwrap()
-    }
-
-    #[test]
-    fn generated_json_and_real_source_bundle_are_accepted_unchanged() {
-        let dir = tempfile::tempdir().unwrap();
-        let out = dir.path().join("fixture");
-        generate(&out).unwrap();
-        let baseline = out.join("baseline.json");
-        let saved = out.join("saved.json");
-        persistence::save(&saved, &fixture().unwrap()).unwrap();
-        check("unchanged", &baseline, &saved).unwrap();
-        check("unchanged", &baseline, &out.join("source/project.arcadia")).unwrap();
-        let bytes = fs::read(&baseline).unwrap();
-        assert!(
-            generate(&out).is_err(),
-            "generation cannot overwrite evidence"
-        );
-        assert_eq!(fs::read(&baseline).unwrap(), bytes);
-        let invalid = dir.path().join("invalid.arcadia");
-        fs::write(&invalid, "project {").unwrap();
-        assert!(load(&invalid).is_err(), "source errors must still reject");
-    }
-
-    #[test]
-    fn real_group_command_outputs_pass_and_are_not_unchanged() {
-        let before = fixture().unwrap();
-        for delta in [point(40., 60.), point(-20., 30.)] {
-            let actual = moved(&before, delta);
-            through_saved_json("moved", &before, &actual).unwrap();
-            mismatch(
-                "unchanged",
-                &before,
-                &actual,
-                "real movement cannot count as unchanged",
-            );
-        }
-    }
-
-    #[test]
-    fn real_hide_command_outputs_pass_before_and_after_movement() {
-        let initial = fixture().unwrap();
-        for before in [initial.clone(), moved(&initial, point(40., 60.))] {
-            let actual = hidden(&before);
-            through_saved_json("hide", &before, &actual).unwrap();
-            mismatch(
-                "unchanged",
-                &before,
-                &actual,
-                "real Hide cannot count as unchanged",
-            );
-        }
-    }
-
-    #[test]
-    fn omitted_and_double_moved_child_are_rejected() {
-        let before = fixture().unwrap();
-        let delta = point(40., 60.);
-        let correct = moved(&before, delta);
-        let initial = before.diagrams[&id("oa_view")].nodes[&id("node_child")].position;
-        for position in [
-            initial,
-            point(initial.x + 2. * delta.x, initial.y + 2. * delta.y),
-        ] {
-            let mut bad = correct.clone();
-            bad.diagrams
-                .get_mut(&id("oa_view"))
-                .unwrap()
-                .nodes
-                .get_mut(&id("node_child"))
-                .unwrap()
-                .position = position;
-            mismatch("moved", &before, &bad, "child did not move exactly once");
-        }
-    }
-
-    #[test]
-    fn internal_pins_left_behind_and_external_pins_moved_are_rejected() {
-        let mut before = fixture().unwrap();
-        let original_pins = edge(&mut before, "internal").waypoints.clone();
-        let correct = moved(&before, point(40., 60.));
-        let mut bad = correct.clone();
-        edge(&mut bad, "internal").waypoints = original_pins;
-        mismatch("moved", &before, &bad, "internal pins left behind");
-        let mut bad = correct;
-        for pin in &mut edge(&mut bad, "external").waypoints {
-            pin.x += 40.;
-            pin.y += 60.;
-        }
-        mismatch("moved", &before, &bad, "one-ended pins moved");
-    }
-
-    #[test]
-    fn manual_attachments_and_label_data_must_remain_exact() {
-        let before = fixture().unwrap();
-        let correct = moved(&before, point(40., 60.));
-        let mutations: [fn(&mut EdgeRoute); 4] = [
-            |r| r.source_attachment.as_mut().unwrap().offset = 0.65,
-            |r| r.target_attachment.as_mut().unwrap().side = PortAnchorSide::Top,
-            |r| r.label.as_mut().unwrap().offset.x += 40.,
-            |r| r.label.as_mut().unwrap().fraction = 0.75,
-        ];
-        for mutate in mutations {
-            let mut bad = correct.clone();
-            mutate(edge(&mut bad, "internal"));
-            mismatch("moved", &before, &bad, "relative route metadata changed");
-        }
-    }
-
-    #[test]
-    fn semantic_other_view_fixed_node_and_trace_drift_are_rejected() {
-        let before = fixture().unwrap();
-        let correct = moved(&before, point(40., 60.));
-        let mutations: [fn(&mut Project); 5] = [
-            |p| {
-                p.elements
-                    .get_mut(&id("activity_a"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift")
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("oa_other"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("other_a"))
-                    .unwrap()
-                    .position
-                    .x += 40.
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("sa_view"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("sa_node"))
-                    .unwrap()
-                    .position
-                    .y += 60.
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("oa_view"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("node_c"))
-                    .unwrap()
-                    .position
-                    .x += 40.
-            },
-            |p| {
-                p.traces
-                    .get_mut(&id("trace"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift")
-            },
-        ];
-        for mutate in mutations {
-            let mut bad = correct.clone();
-            mutate(&mut bad);
-            mismatch(
-                "moved",
-                &before,
-                &bad,
-                "record outside permitted movement changed",
-            );
-        }
-    }
-
-    #[test]
-    fn zero_small_excessive_and_offgrid_moves_cannot_satisfy_move_evidence() {
-        let before = fixture().unwrap();
-        for (delta, reason) in [
-            (point(0., 0.), "length >=10"),
-            (point(3., 0.), "length >=10"),
-            (point(510., 0.), "each axis <=500"),
-            (point(20.5, 0.), "10-unit grid"),
-        ] {
-            let actual = moved(&before, delta);
-            let error = through_saved_json("moved", &before, &actual)
-                .unwrap_err()
-                .to_string();
-            assert!(error.contains(reason), "{delta:?}: {error}");
-        }
-    }
-
-    #[test]
-    fn hide_must_preserve_child_routes_and_semantic_objects() {
-        let before = fixture().unwrap();
-        let correct = hidden(&before);
-        let mut missing_child = correct.clone();
-        missing_child
-            .diagrams
-            .get_mut(&id("oa_view"))
-            .unwrap()
-            .nodes
-            .remove(&id("node_child"));
-        mismatch(
-            "hide",
-            &before,
-            &missing_child,
-            "Hide removed unselected child placement",
-        );
-        let mut missing_routes = correct;
-        missing_routes
-            .diagrams
-            .get_mut(&id("oa_view"))
-            .unwrap()
-            .routes
-            .clear();
-        mismatch(
-            "hide",
-            &before,
-            &missing_routes,
-            "Hide removed persistent route records",
-        );
-        let mut semantic_delete = Session::new(before.clone());
-        semantic_delete
-            .execute(Command::Batch(vec![
-                Command::Delete(id("activity_a")),
-                Command::Delete(id("activity_b")),
-            ]))
-            .unwrap();
-        mismatch(
-            "hide",
-            &before,
-            semantic_delete.project(),
-            "Hide became semantic deletion",
-        );
-    }
-
-    #[test]
-    fn unchanged_rejects_valid_semantic_drift_without_geometry_changes() {
-        let before = fixture().unwrap();
-        let mut actual = before.clone();
-        actual
-            .elements
-            .get_mut(&id("activity_b"))
-            .unwrap()
-            .name
-            .push_str(" edited");
-        mismatch(
-            "unchanged",
-            &before,
-            &actual,
-            "geometry equality is not complete Project equality",
-        );
-    }
-}

crates/oa-core/examples/process_multiselect_native.rs

@@ -1,548 +0,0 @@
-//! Deterministic Process native fixture and independent complete-Project oracle.
-//! Expected order is literal; no desktop reorder/layout planner is used here.
-use oa_core::{source_project::*, *};
-use std::{fs, io::Write, path::Path};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn id(alias: &str) -> Id {
-    Id::new_v5(
-        &Id::from_u128(0xc1192026_0923_5000_8000_000000002930),
-        alias.as_bytes(),
-    )
-}
-fn element(p: &mut Project, alias: &str, name: &str, kind: Kind, layer: Layer, parent: Option<Id>) {
-    p.elements.insert(
-        id(alias),
-        Element {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: format!("Preserve engineering record {alias}."),
-            parent,
-            body: ElementBody::new(kind, layer).unwrap(),
-        },
-    );
-}
-fn occurrence(
-    p: &mut Project,
-    alias: &str,
-    name: &str,
-    layer: Layer,
-    owner: &str,
-    value: OccurrenceBody,
-) {
-    element(p, alias, name, Kind::Occurrence, layer, Some(id(owner)));
-    let Some(SharedBody::Occurrence { body, .. }) =
-        p.elements.get_mut(&id(alias)).unwrap().shared_mut()
-    else {
-        panic!("Occurrence body");
-    };
-    *body = value;
-}
-fn set_steps(p: &mut Project, owner: &str, aliases: &[&str]) {
-    *p.elements.get_mut(&id(owner)).unwrap().steps_mut().unwrap() =
-        aliases.iter().map(|alias| id(alias)).collect();
-}
-fn sequence_link(
-    p: &mut Project,
-    alias: &str,
-    name: &str,
-    source: &str,
-    target: &str,
-) -> Result<()> {
-    let old = p.relate(RelationKind::SequenceLink, name, id(source), id(target));
-    reidentify(p, old, id(alias))?;
-    let relation = p.relations.get_mut(&id(alias)).unwrap();
-    relation.alias = alias.into();
-    relation.description = format!("Preserve link {alias} exactly.");
-    if let RelationBody::SequenceLink { guard, .. } = &mut relation.body {
-        *guard = "ready".into();
-    }
-    Ok(())
-}
-fn fixture() -> Result<Project> {
-    let mut p = Project::empty();
-    p.id = id("project");
-    p.alias = "process_multiselect_native".into();
-    p.name = "Process group native".into();
-    p.description = "Select Card C then Shift-select Card A; drop after Card B. Other columns and reusable engineering records remain exact.".into();
-    for (layer, prefix, owner, name, owner_kind, work_kind) in [
-        (
-            Layer::Oa,
-            "oa",
-            "oa_process",
-            "01 OA group order",
-            Kind::Process,
-            Kind::Activity,
-        ),
-        (
-            Layer::Sa,
-            "sa",
-            "sa_chain",
-            "SA chain - preserve",
-            Kind::FunctionalChain,
-            Kind::Function,
-        ),
-    ] {
-        element(&mut p, owner, name, owner_kind, layer, None);
-        let shared = format!("{prefix}_shared_work");
-        let downstream = format!("{prefix}_downstream_work");
-        element(
-            &mut p,
-            &shared,
-            "Shared request work",
-            work_kind,
-            layer,
-            None,
-        );
-        element(
-            &mut p,
-            &downstream,
-            "Downstream verification",
-            work_kind,
-            layer,
-            None,
-        );
-        for (suffix, label) in [
-            ("a", "Card A"),
-            ("u", "Downstream U"),
-            ("b", "Card B"),
-            ("v", "Downstream V"),
-            ("c", "Card C"),
-        ] {
-            let body = if suffix == "b" {
-                OccurrenceBody::Control {
-                    kind: ControlKind::Choice,
-                }
-            } else {
-                OccurrenceBody::Action {
-                    action: Some(id(if suffix == "a" || suffix == "c" {
-                        &shared
-                    } else {
-                        &downstream
-                    })),
-                    lifeline: None,
-                }
-            };
-            occurrence(
-                &mut p,
-                &format!("{prefix}_{suffix}"),
-                label,
-                layer,
-                owner,
-                body,
-            );
-        }
-        let order: Vec<_> = ["a", "u", "b", "v", "c"]
-            .map(|suffix| format!("{prefix}_{suffix}"))
-            .into_iter()
-            .collect();
-        set_steps(
-            &mut p,
-            owner,
-            &order.iter().map(String::as_str).collect::<Vec<_>>(),
-        );
-        sequence_link(
-            &mut p,
-            &format!("{prefix}_a_u"),
-            "A to U",
-            &format!("{prefix}_a"),
-            &format!("{prefix}_u"),
-        )?;
-        sequence_link(
-            &mut p,
-            &format!("{prefix}_b_v"),
-            "B to V",
-            &format!("{prefix}_b"),
-            &format!("{prefix}_v"),
-        )?;
-    }
-    element(
-        &mut p,
-        "reusable",
-        "Reusable request detail",
-        Kind::Process,
-        Layer::Oa,
-        None,
-    );
-    occurrence(
-        &mut p,
-        "reused_leaf",
-        "Shared detail",
-        Layer::Oa,
-        "reusable",
-        OccurrenceBody::Action {
-            action: Some(id("oa_shared_work")),
-            lifeline: None,
-        },
-    );
-    set_steps(&mut p, "reusable", &["reused_leaf"]);
-    element(
-        &mut p,
-        "reuse_trial",
-        "02 Read-only preview trial",
-        Kind::Process,
-        Layer::Oa,
-        None,
-    );
-    for (alias, name) in [
-        ("reference_one", "First use"),
-        ("reference_two", "Second use"),
-    ] {
-        occurrence(
-            &mut p,
-            alias,
-            name,
-            Layer::Oa,
-            "reuse_trial",
-            OccurrenceBody::SequenceReference {
-                sequence: Some(id("reusable")),
-            },
-        );
-    }
-    set_steps(&mut p, "reuse_trial", &["reference_one", "reference_two"]);
-    p.traces.insert(
-        id("trace"),
-        Trace {
-            id: id("trace"),
-            alias: "preserved_work_refinement".into(),
-            name: "Shared request refinement".into(),
-            description: "Process arrangement must preserve cross-layer correspondence.".into(),
-            oa: id("oa_shared_work"),
-            sa: id("sa_shared_work"),
-            kind: TraceKind::Refinement,
-            baseline: Some(TraceBaseline {
-                oa: p.properties(id("oa_shared_work")).unwrap(),
-                sa: p.properties(id("sa_shared_work")).unwrap(),
-                semantic: None,
-            }),
-        },
-    );
-    validate_candidate(&p)?;
-    Ok(p)
-}
-fn load(path: &Path) -> Result<Project> {
-    if path
-        .extension()
-        .is_some_and(|ext| ext.eq_ignore_ascii_case("arcadia"))
-    {
-        let disk = source_files::load_project(path, ProjectLimits::default())?;
-        if disk
-            .diagnostics
-            .iter()
-            .any(|d| d.diagnostic.severity == validation::Severity::Error)
-        {
-            return Err(format!("Source discovery diagnostics: {:?}", disk.diagnostics).into());
-        }
-        let compiled = compile_bundle(&disk.reachable_bundle(), ProjectLimits::default())
-            .map_err(|e| format!("Source compile diagnostics: {e:?}"))?;
-        Ok(compiled.decoded.project)
-    } else {
-        Ok(persistence::load(path)?)
-    }
-}
-fn equal(expected: &Project, actual: &Project) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    let expected = serde_json::to_value(expected)?;
-    let actual = serde_json::to_value(actual)?;
-    let fields: Vec<_> = expected
-        .as_object()
-        .unwrap()
-        .keys()
-        .filter(|key| expected[*key] != actual[*key])
-        .cloned()
-        .collect();
-    Err(format!("Whole Project mismatch in {fields:?}; no partial PASS").into())
-}
-fn roundtrip(p: &Project) -> Result<SourceBundle> {
-    validate_candidate(p)?;
-    equal(p, &persistence::decode(&serde_json::to_vec(p)?)?)?;
-    let bundle = format_bundle(p);
-    let compiled = compile_bundle(&bundle, ProjectLimits::default())
-        .map_err(|e| format!("Roundtrip: {e:?}"))?;
-    equal(p, &compiled.decoded.project)?;
-    Ok(bundle)
-}
-fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
-    fs::create_dir_all(path.parent().ok_or("Missing parent directory")?)?;
-    fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path)?
-        .write_all(bytes)?;
-    Ok(())
-}
-fn generate(out: &Path) -> Result<()> {
-    if out.exists() {
-        return Err("Output directory already exists; choose a fresh path".into());
-    }
-    let p = fixture()?;
-    let bundle = roundtrip(&p)?;
-    write_new(&out.join("baseline.json"), &serde_json::to_vec_pretty(&p)?)?;
-    for (path, source) in &bundle.files {
-        write_new(&out.join("source").join(path), source.as_bytes())?;
-    }
-    let ids: std::collections::BTreeMap<_, _> = [
-        "project",
-        "oa_process",
-        "oa_a",
-        "oa_u",
-        "oa_b",
-        "oa_v",
-        "oa_c",
-        "oa_a_u",
-        "oa_b_v",
-        "oa_shared_work",
-        "oa_downstream_work",
-        "sa_chain",
-        "sa_shared_work",
-        "sa_downstream_work",
-        "sa_a",
-        "sa_u",
-        "sa_b",
-        "sa_v",
-        "sa_c",
-        "sa_a_u",
-        "sa_b_v",
-        "trace",
-        "reusable",
-        "reused_leaf",
-        "reuse_trial",
-        "reference_one",
-        "reference_two",
-    ]
-    .into_iter()
-    .map(|name| (name, id(name)))
-    .collect();
-    write_new(
-        &out.join("manifest.json"),
-        &serde_json::to_vec_pretty(&serde_json::json!({
-            "fixture": "process-multiselect-native-20260923", "ids": ids, "source_entry": bundle.entry,
-            "original_oa_steps": ["oa_a", "oa_u", "oa_b", "oa_v", "oa_c"],
-            "reordered_oa_steps": ["oa_b", "oa_u", "oa_a", "oa_v", "oa_c"],
-            "gesture": "Select Card C then add Card A; Inspect Card C without changing membership, then drag Card C to After Card B",
-            "fixed_slots": {"1": "oa_u", "3": "oa_v"},
-            "read_only_trial": "02 Read-only preview trial has two qualified tiles of reused_leaf through distinct references",
-            "receipt": "Pin baseline.json, manifest.json and generation command externally before interaction. Never replace baseline with a later saved snapshot.",
-            "evaluation": "Literal expected OA steps and complete Project equality; all SA/reuse/trace records exact",
-            "limits": "No pointer, focus, selection-paint, history or source-byte acceptance claim",
-        }))?,
-    )?;
-    equal(&p, &load(&out.join("baseline.json"))?)?;
-    equal(&p, &load(&out.join("source").join(&bundle.entry))?)?;
-    println!("PASS generated JSON and source bundle: {}", out.display());
-    Ok(())
-}
-fn check(mode: &str, baseline: &Path, saved: &Path) -> Result<()> {
-    let before = load(baseline)?;
-    let actual = load(saved)?;
-    validate_candidate(&before)?;
-    validate_candidate(&actual)?;
-    // Pin the exact deterministic original, not merely a reusable project UUID.
-    equal(&fixture()?, &before)
-        .map_err(|e| format!("Baseline is not the immutable original: {e}"))?;
-    let mut expected = before;
-    match mode {
-        "unchanged" => {}
-        "reordered" => set_steps(
-            &mut expected,
-            "oa_process",
-            &["oa_b", "oa_u", "oa_a", "oa_v", "oa_c"],
-        ),
-        _ => return Err("Mode must be reordered or unchanged".into()),
-    }
-    equal(&expected, &actual)?;
-    roundtrip(&actual)?;
-    println!(
-        "{}",
-        serde_json::to_string_pretty(&serde_json::json!({
-            "result": "PASS", "mode": mode, "baseline": baseline, "saved": saved,
-            "comparison": "complete Project equality; literal expected order",
-            "limits": "No pointer/action/focus/Undo/source-byte acceptance claim",
-        }))?
-    );
-    Ok(())
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    match args.as_slice() {
-        [command, out] if command == "generate" => generate(Path::new(out)),
-        [command, mode, baseline, saved] if command == "check" => check(mode, Path::new(baseline), Path::new(saved)),
-        _ => Err("Usage: process_multiselect_native generate DIRECTORY | check reordered|unchanged BASELINE SAVED".into()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn reordered(before: &Project) -> Project {
-        let mut session = Session::new(before.clone());
-        session
-            .execute(Command::SetSteps(
-                id("oa_process"),
-                ["oa_b", "oa_u", "oa_a", "oa_v", "oa_c"].map(id).to_vec(),
-            ))
-            .unwrap();
-        session.project().clone()
-    }
-    fn through_json(mode: &str, baseline: &Project, actual: &Project) -> Result<()> {
-        validate_candidate(baseline).expect("Baseline must be valid");
-        validate_candidate(actual).expect("Corruption must remain semantically valid");
-        let dir = tempfile::tempdir()?;
-        let before = dir.path().join("before.json");
-        let saved = dir.path().join("saved.json");
-        persistence::save(&before, baseline)?;
-        persistence::save(&saved, actual)?;
-        check(mode, &before, &saved)
-    }
-    fn mismatch(before: &Project, actual: &Project) {
-        let error = through_json("reordered", before, actual)
-            .unwrap_err()
-            .to_string();
-        assert!(
-            error.contains("Whole Project mismatch"),
-            "Unexpected rejection: {error}"
-        );
-    }
-    #[test]
-    fn generate_is_deterministic_create_only_and_checks_real_source() {
-        equal(&fixture().unwrap(), &fixture().unwrap()).unwrap();
-        let dir = tempfile::tempdir().unwrap();
-        let out = dir.path().join("fixture");
-        generate(&out).unwrap();
-        let baseline = out.join("baseline.json");
-        let bytes = fs::read(&baseline).unwrap();
-        check("unchanged", &baseline, &out.join("source/project.arcadia")).unwrap();
-        assert!(generate(&out).is_err());
-        assert_eq!(fs::read(&baseline).unwrap(), bytes);
-        let invalid = dir.path().join("invalid.arcadia");
-        fs::write(&invalid, "project {").unwrap();
-        assert!(load(&invalid).is_err());
-    }
-    #[test]
-    fn real_set_steps_passes_but_unchanged_and_mutated_baseline_do_not() {
-        let before = fixture().unwrap();
-        let actual = reordered(&before);
-        through_json("reordered", &before, &actual).unwrap();
-        through_json("unchanged", &before, &before).unwrap();
-        mismatch(&before, &before);
-        assert!(through_json("unchanged", &before, &actual).is_err());
-        let error = through_json("unchanged", &actual, &actual)
-            .unwrap_err()
-            .to_string();
-        assert!(error.contains("immutable original"), "{error}");
-    }
-    #[test]
-    fn global_splice_reversed_block_and_singleton_c_results_are_rejected() {
-        let before = fixture().unwrap();
-        // Native primary/pressed C is already after B, so a singleton C move
-        // is unchanged. Group {C,A} instead puts B before both selected cards.
-        // If A were primary, its singleton result could equal the group result.
-        mismatch(&before, &before);
-        for order in [
-            ["oa_u", "oa_b", "oa_a", "oa_c", "oa_v"],
-            ["oa_b", "oa_u", "oa_c", "oa_v", "oa_a"],
-            ["oa_a", "oa_u", "oa_b", "oa_c", "oa_v"],
-        ] {
-            let mut actual = before.clone();
-            set_steps(&mut actual, "oa_process", &order);
-            mismatch(&before, &actual);
-        }
-    }
-    #[test]
-    fn semantic_link_work_sa_reuse_and_trace_changes_are_rejected() {
-        let before = fixture().unwrap();
-        let correct = reordered(&before);
-        let mutations: [fn(&mut Project); 7] = [
-            |p| {
-                if let RelationBody::SequenceLink { guard, .. } =
-                    &mut p.relations.get_mut(&id("oa_a_u")).unwrap().body
-                {
-                    *guard = "changed".into();
-                }
-            },
-            |p| {
-                if let RelationBody::SequenceLink { target, .. } =
-                    &mut p.relations.get_mut(&id("oa_a_u")).unwrap().body
-                {
-                    *target = id("oa_v");
-                }
-            },
-            |p| {
-                p.elements
-                    .get_mut(&id("oa_shared_work"))
-                    .unwrap()
-                    .name
-                    .push_str(" drift");
-            },
-            |p| {
-                p.elements
-                    .get_mut(&id("sa_shared_work"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift");
-            },
-            |p| {
-                set_steps(p, "sa_chain", &["sa_b", "sa_u", "sa_a", "sa_v", "sa_c"]);
-            },
-            |p| {
-                p.elements
-                    .get_mut(&id("reused_leaf"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift");
-            },
-            |p| {
-                p.traces.get_mut(&id("trace")).unwrap().baseline = None;
-            },
-        ];
-        for mutate in mutations {
-            let mut bad = correct.clone();
-            mutate(&mut bad);
-            mismatch(&before, &bad);
-        }
-    }
-    #[test]
-    fn changed_source_roundtrip_preserves_both_layers_and_checker_rejects_source_drift() {
-        let before = fixture().unwrap();
-        let actual = reordered(&before);
-        let dir = tempfile::tempdir().unwrap();
-        let baseline = dir.path().join("baseline.json");
-        persistence::save(&baseline, &before).unwrap();
-        for corrupt in [false, true] {
-            let mut saved = actual.clone();
-            if corrupt {
-                saved
-                    .elements
-                    .get_mut(&id("sa_c"))
-                    .unwrap()
-                    .name
-                    .push_str(" drift");
-            }
-            let bundle = roundtrip(&saved).unwrap();
-            let folder = dir.path().join(if corrupt { "corrupt" } else { "saved" });
-            for (path, text) in &bundle.files {
-                write_new(&folder.join(path), text.as_bytes()).unwrap();
-            }
-            let parsed = load(&folder.join(&bundle.entry)).unwrap();
-            assert_eq!(parsed.elements[&id("oa_process")].kind(), Kind::Process);
-            assert_eq!(
-                parsed.elements[&id("sa_chain")].kind(),
-                Kind::FunctionalChain
-            );
-            let result = check("reordered", &baseline, &folder.join(&bundle.entry));
-            if corrupt {
-                assert!(
-                    result
-                        .unwrap_err()
-                        .to_string()
-                        .contains("Whole Project mismatch")
-                );
-            } else {
-                result.unwrap();
-            }
-        }
-    }
-}

crates/oa-core/examples/release_dense_views.rs

@@ -230,7 +230,7 @@ fn fixture() -> (Project, Id, Vec<Id>, Vec<Id>, Vec<Id>) {
             )
         })
         .collect();
-    p.diagrams.insert(diagram, Diagram { id: diagram, alias: "forty_exchange_view".into(), name: "Forty service exchanges · all concerns".into(), description: "Start with All. Compare first category, overlapping concerns, global coverage and chosen processes. No hand-routed edges.".into(), layer: Layer::Oa, projection: ProjectionKind::FunctionalDataflow, view_options: ViewOptions::default(), nodes, layout: None, routes: vec![] });
+    p.diagrams.insert(diagram, Diagram { id: diagram, alias: "forty_exchange_view".into(), name: "Forty service exchanges · all concerns".into(), description: "Start with All. Compare first category, overlapping concerns, global coverage and chosen processes. No hand-routed edges.".into(), layer: Layer::Oa, projection: ProjectionKind::FunctionalDataflow, view_options: ViewOptions::default(), nodes, routes: vec![] });
     (p, diagram, exchanges, categories, contexts)
 }
 

crates/oa-core/examples/routing_cost_probe.rs

@@ -1,192 +0,0 @@
-//! Frozen-corpus route-only timing. Protocol: harness/experiments/routing-independent-20260925/timing-protocol.md.
-use oa_core::{Id, Project, projection, routing, validate_candidate};
-use serde::Deserialize;
-use serde_json::json;
-use std::hint::black_box;
-use std::path::{Component, Path, PathBuf};
-use std::time::{Duration, Instant};
-
-const ROUNDS: usize = 7;
-const SLOW_CALL: Duration = Duration::from_secs(5);
-
-#[derive(Deserialize)]
-struct Manifest {
-    schema: u32,
-    cases: Vec<Case>,
-    #[serde(flatten)]
-    metadata: std::collections::BTreeMap<String, serde_json::Value>,
-}
-
-#[derive(Deserialize)]
-struct Case {
-    name: String,
-    project_file: PathBuf,
-    diagram: Id,
-    description: String,
-    #[serde(flatten)]
-    metadata: std::collections::BTreeMap<String, serde_json::Value>,
-}
-
-fn timed_route(
-    project: &Project,
-    diagram: &oa_core::Diagram,
-    view: &projection::ProjectedView,
-) -> (routing::RoutedView, Duration) {
-    // Input black_box is outside the clock. Result consumption is inside it;
-    // allocation is part of routing, result destruction is outside the clock.
-    let project = black_box(project);
-    let diagram = black_box(diagram);
-    let view = black_box(view);
-    let started = Instant::now();
-    let result = black_box(routing::route_diagram(project, diagram, view));
-    let elapsed = started.elapsed();
-    (result, elapsed)
-}
-
-fn point_digest(route: &routing::RoutedView) -> String {
-    // Stable FNV-1a64 over ID bytes, point count and IEEE754 coordinate bits,
-    // little endian. Diagnostic only, not a cryptographic integrity guarantee.
-    let mut hash = 0xcbf29ce484222325_u64;
-    let mut feed = |bytes: &[u8]| {
-        for byte in bytes {
-            hash ^= u64::from(*byte);
-            hash = hash.wrapping_mul(0x100000001b3);
-        }
-    };
-    for (id, edge) in &route.edges {
-        feed(id.as_bytes());
-        feed(&(edge.points.len() as u64).to_le_bytes());
-        for point in &edge.points {
-            feed(&point.x.to_bits().to_le_bytes());
-            feed(&point.y.to_bits().to_le_bytes());
-        }
-    }
-    format!("{hash:016x}")
-}
-
-fn relative_project(root: &Path, file: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    if file.as_os_str().is_empty()
-        || !file
-            .components()
-            .all(|part| matches!(part, Component::Normal(_)))
-    {
-        return Err(
-            "project_file must be a nonempty relative path without parent traversal".into(),
-        );
-    }
-    let path = root.join(file).canonicalize()?;
-    if !path.starts_with(root) {
-        return Err("project_file resolves outside the manifest directory".into());
-    }
-    Ok(path)
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args = std::env::args_os().skip(1);
-    let manifest_path = PathBuf::from(
-        args.next()
-            .ok_or("usage: routing_cost_probe MANIFEST.json")?,
-    )
-    .canonicalize()?;
-    if args.next().is_some() {
-        return Err(
-            "protocol is fixed: one warmup and seven measured calls; no extra arguments".into(),
-        );
-    }
-    let manifest: Manifest = serde_json::from_slice(&std::fs::read(&manifest_path)?)?;
-    if manifest.schema != 1 || manifest.cases.is_empty() {
-        return Err("expected schema1 with at least one case".into());
-    }
-    let root = manifest_path
-        .parent()
-        .ok_or("manifest has no parent directory")?;
-    println!(
-        "{}",
-        json!({
-            "protocol": "routing_cost_probe_v1", "manifest_schema": manifest.schema,
-            "warmup_calls": 1, "measured_calls": ROUNDS,
-            "slow_call_limit_ns": SLOW_CALL.as_nanos(),
-            "debug_assertions": cfg!(debug_assertions),
-            "os": std::env::consts::OS, "arch": std::env::consts::ARCH,
-            "case_count": manifest.cases.len(),
-            "corpus_metadata": manifest.metadata,
-            "clock_scope": "route_diagram plus result black_box; excludes projection, JSON, equality, digest, output and result destruction",
-            "digest": "FNV-1a64 IDs/counts/f32 point bits; diagnostic, not cryptographic",
-            "acceptance": "none; external receipts must bind source, optimized build, binary and corpus"
-        })
-    );
-    let mut names = std::collections::BTreeSet::new();
-    for case in manifest.cases {
-        if !names.insert(case.name.clone()) {
-            return Err("duplicate case name".into());
-        }
-        let bytes = std::fs::read(relative_project(root, &case.project_file)?)?;
-        let project: Project = serde_json::from_slice(&bytes)?;
-        validate_candidate(&project)?;
-        let original = project.clone();
-        let diagram = project
-            .diagrams
-            .get(&case.diagram)
-            .ok_or("case diagram is absent")?;
-        let view = projection::project_diagram(&project, diagram);
-        let (first, warmup) = timed_route(&project, diagram, &view);
-        let mut samples = Vec::with_capacity(ROUNDS);
-        let mut equality = Vec::with_capacity(ROUNDS);
-        let mut endpoints = Vec::with_capacity(ROUNDS);
-        let mut censored = warmup > SLOW_CALL;
-        if !censored {
-            for _ in 0..ROUNDS {
-                let (route, elapsed) = timed_route(&project, diagram, &view);
-                samples.push(elapsed.as_nanos());
-                equality.push(route == first);
-                endpoints.push(
-                    route.edges.len() == first.edges.len()
-                        && route.edges.iter().all(|(id, edge)| {
-                            first.edges.get(id).is_some_and(|other| {
-                                edge.points.first() == other.points.first()
-                                    && edge.points.last() == other.points.last()
-                            })
-                        }),
-                );
-                if elapsed > SLOW_CALL {
-                    censored = true;
-                    break;
-                }
-            }
-        }
-        let mut ordered = samples.clone();
-        ordered.sort_unstable();
-        let complete = !censored && samples.len() == ROUNDS;
-        let median = complete.then(|| ordered[ROUNDS / 2]);
-        let warnings: usize = first.edges.values().map(|edge| edge.warnings.len()).sum();
-        let project_unchanged = project == original;
-        let stable = equality.iter().all(|same| *same);
-        println!(
-            "{}",
-            json!({
-                "case": case.name, "description": case.description,
-                "corpus_case_metadata": case.metadata,
-                "project_file": case.project_file, "diagram": case.diagram,
-                "project_bytes": bytes.len(), "nodes": view.nodes.len(),
-                "edges": view.edges.len(), "ports": view.ports.len(),
-                "routed_edges": first.edges.len(), "warnings": warnings,
-                "route_points": first.edges.values().map(|edge| edge.points.len()).sum::<usize>(),
-                "route_point_digest": point_digest(&first),
-                "warmup_ns": warmup.as_nanos(), "samples_ns": samples,
-                "median_ns": median, "max_observed_measured_ns": ordered.last(),
-                "complete": complete, "censored": censored,
-                "censor_reason": if censored { Some("single call exceeded five seconds; remaining repeats skipped") } else { None },
-                "repeat_full_routed_view_equal_warmup": equality,
-                "repeat_endpoints_equal_warmup": endpoints,
-                "stability_observed": !samples.is_empty(),
-                "project_unchanged": project_unchanged
-            })
-        );
-        if !stable || !project_unchanged {
-            return Err(
-                "routing stability or Project preservation failed; receipt above retained".into(),
-            );
-        }
-    }
-    Ok(())
-}

crates/oa-core/examples/routing_eval_corpus.rs

@@ -1,555 +0,0 @@
-//! Source-first inputs for independent routing experiments. Never invokes layout/routing.
-use oa_core::*;
-use serde_json::{Value, json};
-use std::{collections::BTreeMap, error::Error, fs, path::PathBuf};
-
-struct Case {
-    name: &'static str,
-    description: &'static str,
-    project: Project,
-    diagram: Id,
-    trace_edges: Vec<Id>,
-    metadata: Value,
-}
-
-struct Builder {
-    project: Project,
-    diagram: Id,
-    base: u128,
-    next: u128,
-    edges: Vec<Id>,
-}
-
-impl Builder {
-    fn new(name: &str, base: u128) -> Self {
-        let mut project = Project::empty();
-        project.id = Id::from_u128(base);
-        project.alias = name.into();
-        project.name = name.into();
-        let old = project.ensure_diagram(Layer::Sa);
-        let diagram = Id::from_u128(base + 1);
-        reidentify(&mut project, old, diagram).unwrap();
-        let d = project.diagrams.get_mut(&diagram).unwrap();
-        d.alias = format!("{name}_main");
-        d.name = format!("{name} main view");
-        d.projection = ProjectionKind::FunctionalDataflow;
-        Self {
-            project,
-            diagram,
-            base,
-            next: base + 100,
-            edges: Vec::new(),
-        }
-    }
-
-    fn stable(&mut self, old: Id) -> Id {
-        let id = Id::from_u128(self.next);
-        self.next += 1;
-        reidentify(&mut self.project, old, id).unwrap();
-        id
-    }
-
-    fn function(&mut self, name: &str, x: f32, y: f32) -> Id {
-        let old = self
-            .project
-            .add_element(Kind::Function, Layer::Sa, name, None)
-            .unwrap();
-        let id = self.stable(old);
-        let old = self.project.place(self.diagram, id, Position { x, y });
-        self.stable(old);
-        id
-    }
-
-    fn exchange(
-        &mut self,
-        name: &str,
-        source: Id,
-        target: Id,
-        source_port: PortChoice,
-        target_port: PortChoice,
-    ) -> Id {
-        let id = Id::from_u128(self.base + 10_000 + self.edges.len() as u128);
-        let request = FunctionalExchangeRequest {
-            id,
-            alias: format!("flow_{:02}", self.edges.len()),
-            name: name.into(),
-            description: String::new(),
-            source,
-            target,
-            source_port,
-            target_port,
-            items: vec![],
-        };
-        let commands = ports::plan_functional_exchange(&self.project, &request).unwrap();
-        self.project = execute_batch(&self.project, &commands).unwrap();
-        self.edges.push(id);
-        id
-    }
-
-    fn port_pair(&self, edge: Id) -> (Id, Id) {
-        let RelationBody::FunctionalExchange {
-            source_port,
-            target_port,
-            ..
-        } = self.project.relations[&edge].body
-        else {
-            unreachable!()
-        };
-        (source_port, target_port)
-    }
-
-    fn anchor(&mut self, owner: Id, port: Id, side: PortAnchorSide, offset: f32) {
-        let node = self.project.diagrams[&self.diagram]
-            .nodes
-            .values()
-            .find(|n| n.element == owner)
-            .unwrap()
-            .id;
-        self.project = prepare_command(
-            &self.project,
-            &Command::SetPortAnchor {
-                diagram: self.diagram,
-                node,
-                anchor: PortAnchor { port, side, offset },
-            },
-        )
-        .unwrap()
-        .project;
-    }
-}
-
-fn sentinel(edge: Id, x: f32, y: f32) -> EdgeRoute {
-    EdgeRoute {
-        edge,
-        source_attachment: None,
-        target_attachment: None,
-        waypoints: vec![Position { x, y }],
-        label: Some(EdgeLabel {
-            fraction: 0.4,
-            offset: Position { x: -30., y: -70. },
-        }),
-    }
-}
-
-fn workshop() -> Vec<Case> {
-    let original =
-        persistence::decode(include_bytes!("../../../examples/routing-workshop.json")).unwrap();
-    let diagram = original
-        .diagrams
-        .values()
-        .find(|d| d.alias == "sa_system_boundary_and_functions")
-        .unwrap()
-        .id;
-    assert_eq!(
-        original.diagrams[&diagram].projection,
-        ProjectionKind::Allocation
-    );
-    assert_eq!(original.diagrams[&diagram].nodes.len(), 12);
-    let container = original
-        .elements
-        .values()
-        .find(|e| e.alias == "rescue_coordination_system")
-        .unwrap()
-        .id;
-    let placement = original.diagrams[&diagram]
-        .nodes
-        .values()
-        .find(|n| n.element == container)
-        .unwrap()
-        .id;
-    let traces: Vec<_> = [
-        "sa_report_to_relay",
-        "sa_direct_advice",
-        "sa_incident_decision",
-    ]
-    .iter()
-    .map(|alias| {
-        original
-            .relations
-            .values()
-            .find(|r| r.alias == *alias)
-            .unwrap()
-            .id
-    })
-    .collect();
-    let mut folded = original.clone();
-    assert!(!folded.diagrams[&diagram].nodes[&placement].collapsed);
-    folded
-        .diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .nodes
-        .get_mut(&placement)
-        .unwrap()
-        .collapsed = true;
-    let mut restored = folded.clone();
-    restored
-        .diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .nodes
-        .get_mut(&placement)
-        .unwrap()
-        .collapsed = false;
-    assert_eq!(restored, original);
-    vec![
-        Case {
-            name: "workshop_sa_original",
-            description: "Saved coastal rescue Allocation view, all source records retained.",
-            project: original,
-            diagram,
-            trace_edges: traces.clone(),
-            metadata: json!({"source":"examples/routing-workshop.json","view_alias":"sa_system_boundary_and_functions"}),
-        },
-        Case {
-            name: "workshop_sa_folded",
-            description: "Same saved Project with only rescue_coordination_system placement folded.",
-            project: folded,
-            diagram,
-            trace_edges: traces,
-            metadata: json!({"source":"examples/routing-workshop.json","folded_placement":placement,
-                "folded_element":container,"unfold_restores_original_exact":true}),
-        },
-    ]
-}
-
-fn mixed() -> Vec<Case> {
-    let mut b = Builder::new("mixed_dispatch", 100_000);
-    let nodes: Vec<_> = [
-        ("Sensor A", 40., 90.),
-        ("Sensor B", 40., 510.),
-        ("Ingest", 380., 250.),
-        ("Validate", 720., 80.),
-        ("Archive", 720., 510.),
-        ("Correlate", 1060., 270.),
-        ("Plan", 1400., 80.),
-        ("Dispatch", 1740., 270.),
-        ("Actuator", 1400., 680.),
-        ("Operator", 1740., 680.),
-    ]
-    .into_iter()
-    .map(|(name, x, y)| b.function(name, x, y))
-    .collect();
-    let e0 = b.exchange(
-        "Sensor A observations",
-        nodes[0],
-        nodes[2],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let ingest_input = b.port_pair(e0).1;
-    let e1 = b.exchange(
-        "Sensor B observations",
-        nodes[1],
-        nodes[2],
-        PortChoice::Create,
-        PortChoice::Reuse(ingest_input),
-    );
-    let e2 = b.exchange(
-        "Validate incoming observations",
-        nodes[2],
-        nodes[3],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let ingest_output = b.port_pair(e2).0;
-    let e3 = b.exchange(
-        "Archive incoming observations",
-        nodes[2],
-        nodes[4],
-        PortChoice::Reuse(ingest_output),
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Validated observations",
-        nodes[3],
-        nodes[5],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Archived context",
-        nodes[4],
-        nodes[5],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Correlated situation",
-        nodes[5],
-        nodes[6],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Planned actions",
-        nodes[6],
-        nodes[7],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let e8 = b.exchange(
-        "Actuator dispatch",
-        nodes[7],
-        nodes[8],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let dispatch_output = b.port_pair(e8).0;
-    let e9 = b.exchange(
-        "Operator dispatch copy",
-        nodes[7],
-        nodes[9],
-        PortChoice::Reuse(dispatch_output),
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Operator acknowledgement",
-        nodes[9],
-        nodes[8],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Archived actuator policy",
-        nodes[4],
-        nodes[8],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    b.exchange(
-        "Sensor B archive stream",
-        nodes[1],
-        nodes[4],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let feedback = b.exchange(
-        "Sensor A sampling feedback",
-        nodes[6],
-        nodes[0],
-        PortChoice::Create,
-        PortChoice::Create,
-    );
-    let (feedback_output, feedback_input) = b.port_pair(feedback);
-    b.anchor(nodes[0], b.port_pair(e0).0, PortAnchorSide::Right, 0.25);
-    b.anchor(nodes[2], ingest_input, PortAnchorSide::Left, 0.3);
-    b.anchor(nodes[2], ingest_output, PortAnchorSide::Bottom, 0.6);
-    b.anchor(nodes[6], feedback_output, PortAnchorSide::Top, 0.5);
-    b.anchor(nodes[0], feedback_input, PortAnchorSide::Left, 0.6);
-    b.anchor(nodes[7], dispatch_output, PortAnchorSide::Right, 0.5);
-    b.project
-        .diagrams
-        .get_mut(&b.diagram)
-        .unwrap()
-        .routes
-        .push(sentinel(feedback, 300., -100.));
-    let secondary = Id::from_u128(b.base + 2);
-    let mut other = b.project.diagrams[&b.diagram].clone();
-    other.id = secondary;
-    other.alias = "mixed_dispatch_secondary".into();
-    other.name = "Feedback review sentinel".into();
-    other.description = "Unaffected other-view preservation sentinel".into();
-    other.nodes.clear();
-    other.routes = vec![sentinel(feedback, 460., 480.)];
-    b.project.diagrams.insert(secondary, other);
-    for (i, element) in [nodes[0], nodes[2], nodes[6]].into_iter().enumerate() {
-        let old = b.project.place(
-            secondary,
-            element,
-            Position {
-                x: 100. + i as f32 * 340.,
-                y: 100.,
-            },
-        );
-        let stable = b.stable(old);
-        b.project
-            .diagrams
-            .get_mut(&secondary)
-            .unwrap()
-            .nodes
-            .get_mut(&stable)
-            .unwrap()
-            .alias = format!("feedback_review_{i}");
-    }
-    assert_eq!(b.edges.len(), 14);
-    assert_eq!(b.project.diagrams[&b.diagram].nodes.len(), 10);
-    let originals = b.edges.clone();
-    let replacements: Vec<_> = originals.iter().rev().copied().collect();
-    let mut permuted = b.project.clone();
-    for (i, id) in originals.iter().enumerate() {
-        reidentify(&mut permuted, *id, Id::from_u128(1_000_000 + i as u128)).unwrap();
-    }
-    for (i, id) in replacements.iter().enumerate() {
-        reidentify(&mut permuted, Id::from_u128(1_000_000 + i as u128), *id).unwrap();
-    }
-    let mut restored = permuted.clone();
-    for (i, id) in replacements.iter().enumerate() {
-        reidentify(&mut restored, *id, Id::from_u128(1_000_000 + i as u128)).unwrap();
-    }
-    for (i, id) in originals.iter().enumerate() {
-        reidentify(&mut restored, Id::from_u128(1_000_000 + i as u128), *id).unwrap();
-    }
-    assert_eq!(restored, b.project);
-    let correspondence: BTreeMap<_, _> = originals.iter().copied().zip(replacements).collect();
-    let traces = vec![e1, e3, e9, feedback];
-    let permuted_traces = traces.iter().map(|id| correspondence[id]).collect();
-    let metadata = json!({"shared_input":ingest_input,"shared_outputs":[ingest_output,dispatch_output],
-        "sentinel_edge":feedback,"secondary_diagram":secondary,"fixed_anchor_records":6,
-        "authored_waypoint_count_main":1,"authored_label_count_main":1,
-        "declared_feedback_cycle":[nodes[0],nodes[2],nodes[3],nodes[5],nodes[6],nodes[0]]});
-    vec![
-        Case {
-            name: "mixed_dispatch",
-            description: "Ten-function sensing/decision/dispatch network, explicit port sharing and fixed anchors.",
-            project: b.project,
-            diagram: b.diagram,
-            trace_edges: traces,
-            metadata,
-        },
-        Case {
-            name: "mixed_dispatch_edge_ids_reversed",
-            description: "Same mixed Project with fixed reversed relation-ID permutation, remapped references.",
-            project: permuted,
-            diagram: b.diagram,
-            trace_edges: permuted_traces,
-            metadata: json!({"paired_case":"mixed_dispatch","edge_id_correspondence":correspondence,
-                "inverse_recovers_original_exact":true,"secondary_diagram":secondary}),
-        },
-    ]
-}
-
-fn sparse() -> Case {
-    let mut b = Builder::new("subsystems_40_sparse", 200_000);
-    let names = [
-        "Sensing",
-        "Communications",
-        "Assessment",
-        "Planning",
-        "Delivery",
-    ];
-    let stages = [
-        "Acquire",
-        "Decode",
-        "Validate",
-        "Enrich",
-        "Aggregate",
-        "Decide",
-        "Package",
-        "Publish",
-    ];
-    let mut nodes = Vec::new();
-    for (group, name) in names.iter().enumerate() {
-        let row: Vec<_> = stages
-            .iter()
-            .enumerate()
-            .map(|(stage, label)| {
-                b.function(
-                    &format!("{name} {label}"),
-                    80. + stage as f32 * 300.,
-                    80. + group as f32 * 240.,
-                )
-            })
-            .collect();
-        nodes.push(row);
-    }
-    for group in 0..5 {
-        for stage in 0..7 {
-            b.exchange(
-                &format!(
-                    "{} {} to {}",
-                    names[group],
-                    stages[stage],
-                    stages[stage + 1]
-                ),
-                nodes[group][stage],
-                nodes[group][stage + 1],
-                PortChoice::Create,
-                PortChoice::Create,
-            );
-        }
-    }
-    let mut trace_edges = Vec::new();
-    for group in 0..5 {
-        for stage in [1, 3, 5, 7] {
-            let next = (group + 1) % 5;
-            let id = b.exchange(
-                &format!(
-                    "{} {} handoff to {} {}",
-                    names[group],
-                    stages[stage],
-                    names[next],
-                    stages[stage - 1]
-                ),
-                nodes[group][stage],
-                nodes[next][stage - 1],
-                PortChoice::Create,
-                PortChoice::Create,
-            );
-            if (group == 0 && stage == 1) || (group == 4 && stage == 7) {
-                trace_edges.push(id);
-            }
-        }
-    }
-    assert_eq!(b.edges.len(), 55);
-    assert_eq!(b.project.diagrams[&b.diagram].nodes.len(), 40);
-    Case {
-        name: "subsystems_40_sparse",
-        description: "Five eight-stage subsystem chains with twenty directed cross-subsystem handoffs; all ports distinct.",
-        project: b.project,
-        diagram: b.diagram,
-        trace_edges,
-        metadata: json!({"groups":names,"stages":stages,"chain_edges":35,"cross_edges":20,
-            "all_exchange_ports_distinct":true,"grid_columns":8,"grid_rows":5}),
-    }
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let mut args = std::env::args_os().skip(1);
-    let output = PathBuf::from(
-        args.next()
-            .ok_or("Usage: routing_eval_corpus NEW_DIRECTORY")?,
-    );
-    if args.next().is_some() {
-        return Err("Expected exactly one new output directory".into());
-    }
-    if output.exists() {
-        return Err("Output directory already exists; refusing overwrite".into());
-    }
-    let mut cases = workshop();
-    cases.extend(mixed());
-    cases.push(sparse());
-    let mut files = Vec::new();
-    let mut entries = Vec::new();
-    for case in cases {
-        validate_candidate(&case.project)?;
-        let file = format!("{}.json", case.name);
-        let traces: Vec<_> = case
-            .trace_edges
-            .iter()
-            .map(|id| {
-                let relation = &case.project.relations[id];
-                json!({"edge":id,"alias":relation.alias,"name":relation.name,
-                "source":relation.source(),"target":relation.target()})
-            })
-            .collect();
-        entries.push(json!({"name":case.name,"project_file":file,"diagram":case.diagram,
-            "description":case.description,"metadata":case.metadata,"trace_tasks":traces,
-            "source_counts":{"elements":case.project.elements.len(),"relations":case.project.relations.len(),
-                "views":case.project.diagrams.len(),"selected_view_placements":case.project.diagrams[&case.diagram].nodes.len(),
-                "selected_view_authored_routes":case.project.diagrams[&case.diagram].routes.len()}}));
-        files.push((file, serde_json::to_vec_pretty(&case.project)?));
-    }
-    let manifest = json!({"schema":1,"cases":entries,"definition_baseline":"f72aa2ca",
-        "construction":"Source-authored positions/topology, no Layout/projection/routing calls; validate all before writing.",
-        "invariants":"Routing is read-only. Preserve all semantic records, port identities, fixed anchors, authored routes/labels, fold flags, and other views. ID permutation correspondence is explicit. No quality or automatic endpoint-side expectation.",
-        "generation_in_routing_timing":false});
-    let manifest_bytes = serde_json::to_vec_pretty(&manifest)?;
-    fs::create_dir(&output)?;
-    for (name, bytes) in files {
-        fs::write(output.join(name), bytes)?;
-    }
-    fs::write(output.join("manifest.json"), manifest_bytes)?;
-    println!("{}", output.join("manifest.json").display());
-    Ok(())
-}

crates/oa-core/examples/state_bend_routing_snapshot.rs

@@ -1,101 +0,0 @@
-//! Read-only saved-State geometry evidence for a predeclared native bend trial.
-//!
-//! Usage:
-//! state_bend_routing_snapshot INPUT.arcadia NEW_OUTPUT.json
-//!
-//! Loads and validates the complete Project, then independently projects/routes
-//! every saved State view through core APIs. The complete Project permits exact
-//! semantic and presentation comparison; derived geometry permits declaring a
-//! segment and insertion position before native actions. No desktop command,
-//! planner, gesture, or pin insertion helper is called. Input is never written;
-//! output uses create_new and fails rather than overwriting an existing file.
-//!
-//! Limits: this shares production core routing, so it is not an independent
-//! mathematical test of that router, nor evidence of UI picking/gesture success.
-//! It does not generate expected mutations or adapt an oracle to observed edits.
-//! The acceptance recipe must declare the intended segment/index/point and exact
-//! Project mutation before UI execution, and bind this executable/source/input
-//! and output hashes externally. Warning strings are diagnostic Debug output,
-//! not a stable interchange schema. Missing/hidden/internal transitions have no
-//! routed edge; their semantic records remain in the complete Project snapshot.
-
-use oa_core::{persistence, projection, routing, validate_candidate};
-use serde_json::json;
-use std::{fs::OpenOptions, io::Write, path::Path};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<_> = std::env::args_os().skip(1).collect();
-    if args.len() != 2 {
-        return Err("Expected input source/JSON and a new output JSON path".into());
-    }
-    let project = persistence::load(Path::new(&args[0]))?;
-    validate_candidate(&project)?;
-    let mut views = Vec::new();
-    for (diagram_id, diagram) in &project.diagrams {
-        let Some(machine) = diagram.projection.state_machine() else {
-            continue;
-        };
-        let projected = projection::project_diagram(&project, diagram);
-        let routed = routing::route_diagram(&project, diagram, &projected);
-        let edges: Vec<_> = routed
-            .edges
-            .iter()
-            .map(|(edge_id, edge)| {
-                json!({
-                    "edge": edge_id,
-                    "id": edge.id,
-                    "points": edge.points,
-                    "pins": edge.pins,
-                    "pin_fractions": edge.pin_fractions,
-                    "custom_suspended": edge.custom_suspended,
-                    "warnings": edge.warnings.iter().map(|warning| format!("{warning:?}")).collect::<Vec<_>>(),
-                    "label": {
-                        "text": edge.label.text,
-                        "fraction": edge.label.fraction,
-                        "anchor": edge.label.anchor,
-                        "center": edge.label.center,
-                        "bounds": {
-                            "position": edge.label.bounds.position,
-                            "size": edge.label.bounds.size
-                        }
-                    }
-                })
-            })
-            .collect();
-        views.push(json!({
-            "diagram": diagram_id,
-            "machine": machine,
-            "projected": projected,
-            "routed_bounds": {
-                "position": routed.bounds.position,
-                "size": routed.bounds.size
-            },
-            "routed_edges": edges
-        }));
-    }
-    // Preserve the canonical typed Project serialization (including f32
-    // formatting). Serializing it through Value directly promotes f32 to f64.
-    let project_json: serde_json::Value = serde_json::from_slice(&serde_json::to_vec(&project)?)?;
-    let snapshot = json!({
-        "schema": "state-bend-routing-snapshot/v1",
-        "project": project_json,
-        "state_views": views
-    });
-    // Finish all reading, validation, routing and serialization before creating
-    // the new evidence file. A failed load cannot leave an apparent snapshot.
-    let mut bytes = serde_json::to_vec_pretty(&snapshot)?;
-    bytes.push(b'\n');
-    let mut output = OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(&args[1])?;
-    output.write_all(&bytes)?;
-    output.sync_all()?;
-    println!(
-        "Validated {} objects and {} saved views; snapshotted {} State views and the complete Project",
-        project.identities().len(),
-        project.diagrams.len(),
-        views.len()
-    );
-    Ok(())
-}

crates/oa-core/examples/state_multiselect_native.rs

@@ -1,912 +0,0 @@
-//! Deterministic persisted-State native fixture and complete-Project checker.
-//! This invariant evaluator derives delta from saved A, NOT from pointer input.
-use oa_core::{source_project::*, *};
-use std::{fs, io::Write, path::Path};
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-fn id(alias: &str) -> Id {
-    // Dedicated State view is the smallest diagram UUID, for native opening.
-    if alias == "state_view" {
-        return Id::from_u128(0x29_0101);
-    }
-    Id::new_v5(
-        &Id::from_u128(0xc1192026_0923_5000_8000_000000002929),
-        alias.as_bytes(),
-    )
-}
-fn point(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-fn element(p: &mut Project, alias: &str, name: &str, kind: Kind, layer: Layer, parent: Option<Id>) {
-    p.elements.insert(
-        id(alias),
-        Element {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: format!("Preserve engineering record {alias}."),
-            parent,
-            body: ElementBody::new(kind, layer).unwrap(),
-        },
-    );
-}
-fn diagram(p: &mut Project, alias: &str, name: &str, layer: Layer) {
-    p.diagrams.insert(
-        id(alias),
-        Diagram {
-            id: id(alias),
-            alias: alias.into(),
-            name: name.into(),
-            description: "Selection changes placement geometry only.".into(),
-            layer,
-            projection: ProjectionKind::Overview,
-            view_options: Default::default(),
-            layout: None,
-            nodes: Default::default(),
-            routes: vec![],
-        },
-    );
-}
-fn place(p: &mut Project, view: &str, alias: &str, object: &str, position: Position, size: Size) {
-    p.diagrams.get_mut(&id(view)).unwrap().nodes.insert(
-        id(alias),
-        NodePlacement {
-            id: id(alias),
-            alias: alias.into(),
-            element: id(object),
-            position,
-            size,
-            collapsed: false,
-            port_anchors: vec![],
-        },
-    );
-}
-fn route(edge: &str, pins: Vec<Position>) -> EdgeRoute {
-    EdgeRoute {
-        edge: id(edge),
-        waypoints: pins,
-        source_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Right,
-            offset: 0.25,
-        }),
-        target_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Left,
-            offset: 0.7,
-        }),
-        label: Some(EdgeLabel {
-            fraction: 0.45,
-            offset: point(7., -19.),
-        }),
-    }
-}
-fn transition(
-    p: &mut Project,
-    alias: &str,
-    name: &str,
-    source: &str,
-    target: &str,
-    kind: TransitionKind,
-) -> Result<()> {
-    let old = p.relate(RelationKind::StateTransition, name, id(source), id(target));
-    reidentify(p, old, id(alias))?;
-    let relation = p.relations.get_mut(&id(alias)).unwrap();
-    relation.alias = alias.into();
-    relation.description = format!("Preserve transition {alias}.");
-    if let RelationBody::StateTransition {
-        transition_kind,
-        guard,
-        ..
-    } = &mut relation.body
-    {
-        *transition_kind = kind;
-        *guard = if alias == "between" {
-            "request_ready"
-        } else {
-            ""
-        }
-        .into();
-    }
-    Ok(())
-}
-fn fixture() -> Result<Project> {
-    let mut p = Project::empty();
-    p.id = id("project");
-    p.alias = "state_multiselect_native".into();
-    p.name = "State group native".into();
-    p.description = "Shift-select A and B; move their placements together. C and shared engineering records stay fixed.".into();
-    for (alias, name, kind, parent) in [
-        ("crew", "Operations crew", Kind::Entity, None),
-        (
-            "machine",
-            "Request lifecycle",
-            Kind::StateMachine,
-            Some(id("crew")),
-        ),
-        ("region", "Main region", Kind::Region, Some(id("machine"))),
-        ("state_a", "A - Processing", Kind::State, Some(id("region"))),
-        ("state_b", "B - Ready", Kind::State, Some(id("region"))),
-        ("state_c", "C - Complete", Kind::State, Some(id("region"))),
-        (
-            "inner",
-            "A nested region",
-            Kind::Region,
-            Some(id("state_a")),
-        ),
-        (
-            "state_leaf",
-            "A.1 - Classify",
-            Kind::State,
-            Some(id("inner")),
-        ),
-        ("entry", "Enter A", Kind::EntryPoint, Some(id("inner"))),
-        ("exit", "Leave A", Kind::ExitPoint, Some(id("inner"))),
-        ("shared_work", "Record request", Kind::Activity, None),
-    ] {
-        element(&mut p, alias, name, kind, Layer::Oa, parent);
-    }
-    element(
-        &mut p,
-        "sa_function",
-        "Technical record request",
-        Kind::Function,
-        Layer::Sa,
-        None,
-    );
-    for (alias, name, source, target, kind) in [
-        (
-            "between",
-            "Ready\nfor review",
-            "state_a",
-            "state_b",
-            TransitionKind::External,
-        ),
-        (
-            "external",
-            "Complete request",
-            "state_b",
-            "state_c",
-            TransitionKind::External,
-        ),
-        (
-            "entry_route",
-            "Begin classification",
-            "entry",
-            "state_leaf",
-            TransitionKind::Local,
-        ),
-        (
-            "exit_route",
-            "Classification complete",
-            "state_leaf",
-            "exit",
-            TransitionKind::External,
-        ),
-        (
-            "refresh",
-            "Refresh record",
-            "state_a",
-            "state_a",
-            TransitionKind::Internal,
-        ),
-    ] {
-        transition(&mut p, alias, name, source, target, kind)?;
-    }
-    for (alias, source, phase) in [
-        ("action_a", "state_a", StateActionKind::Entry),
-        ("action_c", "state_c", StateActionKind::Do),
-    ] {
-        let old = p.relate(
-            RelationKind::StateAction,
-            "Record shared work",
-            id(source),
-            id("shared_work"),
-        );
-        reidentify(&mut p, old, id(alias))?;
-        let relation = p.relations.get_mut(&id(alias)).unwrap();
-        relation.alias = alias.into();
-        relation.description = format!("Preserve shared-work action {alias}.");
-        if let RelationBody::StateAction { phase: value, .. } = &mut relation.body {
-            *value = phase;
-        }
-    }
-    for (alias, name) in [
-        ("state_view", "State multiselect - main"),
-        ("state_other", "Other State view - preserve"),
-    ] {
-        diagram(&mut p, alias, name, Layer::Oa);
-        p.diagrams.get_mut(&id(alias)).unwrap().projection = ProjectionKind::StateMachine {
-            machine: id("machine"),
-        };
-    }
-    diagram(&mut p, "sa_view", "SA engineering - preserve", Layer::Sa);
-    // The main machine and outer Region are deliberately unplaced to keep
-    // the target headers readable in a 1442 x 932 native window after Fit.
-    // A starts at the authored origin so saved A recovers the exact f32 delta;
-    // subtracting a nonzero original can round it differently from sibling XY.
-    for (alias, object, x, y, width, height) in [
-        ("node_a", "state_a", 0., 0., 340., 450.),
-        ("node_b", "state_b", 410., 30., 210., 150.),
-        ("node_c", "state_c", 410., 330., 210., 140.),
-        ("node_inner", "inner", 25., 220., 290., 200.),
-        ("node_leaf", "state_leaf", 60., 290., 180., 90.),
-        ("node_entry", "entry", -210., 280., 24., 24.),
-        ("node_exit", "exit", 870., 350., 24., 24.),
-    ] {
-        place(
-            &mut p,
-            "state_view",
-            alias,
-            object,
-            point(x, y),
-            Size { width, height },
-        );
-    }
-    let size = Size {
-        width: 224.,
-        height: 94.,
-    };
-    place(
-        &mut p,
-        "state_other",
-        "other_a",
-        "state_a",
-        point(40., 60.),
-        Size {
-            width: 340.,
-            height: 220.,
-        },
-    );
-    place(
-        &mut p,
-        "state_other",
-        "other_b",
-        "state_b",
-        point(460., 80.),
-        size,
-    );
-    place(
-        &mut p,
-        "sa_view",
-        "sa_node",
-        "sa_function",
-        point(100., 110.),
-        size,
-    );
-    p.diagrams.get_mut(&id("state_view")).unwrap().routes = vec![
-        route("between", vec![point(365., 70.), point(365., 120.)]),
-        route("external", vec![point(660., 140.), point(660., 360.)]),
-        route("entry_route", vec![point(40., 280.), point(40., 320.)]),
-        route("exit_route", vec![point(290., 335.), point(290., 370.)]),
-    ];
-    p.traces.insert(
-        id("trace"),
-        Trace {
-            id: id("trace"),
-            alias: "preserved_refinement".into(),
-            name: "Reviewed recording refinement".into(),
-            description:
-                "Moving states or hiding placements must preserve shared work and its refinement."
-                    .into(),
-            oa: id("shared_work"),
-            sa: id("sa_function"),
-            kind: TraceKind::Refinement,
-            baseline: Some(TraceBaseline {
-                oa: p.properties(id("shared_work")).unwrap(),
-                sa: p.properties(id("sa_function")).unwrap(),
-                semantic: None,
-            }),
-        },
-    );
-    validate_candidate(&p)?;
-    Ok(p)
-}
-fn load(path: &Path) -> Result<Project> {
-    if path
-        .extension()
-        .is_some_and(|ext| ext.eq_ignore_ascii_case("arcadia"))
-    {
-        let disk = source_files::load_project(path, ProjectLimits::default())?;
-        // This deliberately partial engineering fixture has completeness
-        // warnings (allocation/behavior context). They are not source errors.
-        // Compilation, candidate validation and whole-Project equality still
-        // reject malformed source or any unexpected model change.
-        if disk
-            .diagnostics
-            .iter()
-            .any(|d| d.diagnostic.severity == validation::Severity::Error)
-        {
-            return Err(format!("Source discovery diagnostics: {:?}", disk.diagnostics).into());
-        }
-        let compiled = compile_bundle(&disk.reachable_bundle(), ProjectLimits::default())
-            .map_err(|e| format!("Source compile diagnostics: {e:?}"))?;
-        Ok(compiled.decoded.project)
-    } else {
-        Ok(persistence::load(path)?)
-    }
-}
-fn equal(expected: &Project, actual: &Project) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    let e = serde_json::to_value(expected)?;
-    let a = serde_json::to_value(actual)?;
-    let fields: Vec<_> = e
-        .as_object()
-        .unwrap()
-        .keys()
-        .filter(|key| e[*key] != a[*key])
-        .cloned()
-        .collect();
-    Err(format!("Whole Project mismatch in {fields:?}; no partial PASS").into())
-}
-fn roundtrip(p: &Project) -> Result<SourceBundle> {
-    validate_candidate(p)?;
-    equal(p, &persistence::decode(&serde_json::to_vec(p)?)?)?;
-    let bundle = format_bundle(p);
-    let compiled = compile_bundle(&bundle, ProjectLimits::default())
-        .map_err(|e| format!("Roundtrip: {e:?}"))?;
-    equal(p, &compiled.decoded.project)?;
-    Ok(bundle)
-}
-fn write_new(path: &Path, bytes: &[u8]) -> Result<()> {
-    fs::create_dir_all(path.parent().ok_or("Missing parent directory")?)?;
-    fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path)?
-        .write_all(bytes)?;
-    Ok(())
-}
-fn generate(out: &Path) -> Result<()> {
-    if out.exists() {
-        return Err("Output directory already exists; choose a fresh path".into());
-    }
-    let p = fixture()?;
-    let bundle = roundtrip(&p)?;
-    write_new(&out.join("baseline.json"), &serde_json::to_vec_pretty(&p)?)?;
-    for (path, source) in &bundle.files {
-        write_new(&out.join("source").join(path), source.as_bytes())?;
-    }
-    let names = [
-        "crew",
-        "machine",
-        "region",
-        "inner",
-        "entry",
-        "exit",
-        "shared_work",
-        "node_inner",
-        "node_entry",
-        "node_exit",
-        "entry_route",
-        "exit_route",
-        "refresh",
-        "action_a",
-        "action_c",
-        "other_b",
-        "project",
-        "state_view",
-        "state_other",
-        "sa_view",
-        "state_a",
-        "state_b",
-        "state_c",
-        "state_leaf",
-        "node_a",
-        "node_b",
-        "node_c",
-        "node_leaf",
-        "between",
-        "external",
-        "trace",
-        "sa_function",
-        "sa_node",
-        "other_a",
-    ];
-    let ids: std::collections::BTreeMap<_, _> =
-        names.into_iter().map(|name| (name, id(name))).collect();
-    write_new(
-        &out.join("manifest.json"),
-        &serde_json::to_vec_pretty(&serde_json::json!({
-            "fixture": "state-multiselect-native-20260923", "ids": ids, "source_entry": bundle.entry,
-            "move_members": ["node_a", "node_b", "node_inner", "node_leaf", "node_entry", "node_exit"],
-            "translated_routes": ["between", "entry_route", "exit_route"],
-            "fixed_route": "external",
-            "window": [1442, 932],
-            "target_headers_world": {"A": [40, 35], "B": [450, 65]},
-            "delta_limits": "finite, nonzero length >=0.01, each axis <=300; no grid quantization",
-            "receipt": "Pin baseline.json, manifest.json and generation command externally before interaction; baseline identity alone does not authenticate evidence", "fixed_member": "node_c",
-            "evaluation": "Whole Project invariant comparison; saved A supplies bounded shared delta, not an exact pointer oracle",
-            "hide": "Remove node_a/node_b only; retain nested Region/leaf/entry/exit, stored routes, all model records and other views",
-        }))?,
-    )?;
-    equal(&p, &load(&out.join("baseline.json"))?)?;
-    equal(&p, &load(&out.join("source/project.arcadia"))?)?;
-    println!("PASS generated JSON and source bundle: {}", out.display());
-    Ok(())
-}
-fn check(mode: &str, baseline: &Path, saved: &Path) -> Result<()> {
-    let before = load(baseline)?;
-    let actual = load(saved)?;
-    validate_candidate(&before)?;
-    validate_candidate(&actual)?;
-    if before.id != id("project") {
-        return Err("Not this fixture's baseline project".into());
-    }
-    let mut expected = before.clone();
-    let mut delta = None;
-    match mode {
-        "unchanged" => {}
-        "hide" => {
-            let view = expected
-                .diagrams
-                .get_mut(&id("state_view"))
-                .ok_or("Missing State view")?;
-            for alias in ["node_a", "node_b"] {
-                view.nodes
-                    .remove(&id(alias))
-                    .ok_or("Baseline selected placement missing")?;
-            }
-            // references::remove_objects removes routes only when their semantic
-            // edge is deleted. Hide deletes placements; both routes MUST survive.
-        }
-        "moved" => {
-            let old = before
-                .diagrams
-                .get(&id("state_view"))
-                .ok_or("Missing baseline State view")?;
-            let new = actual
-                .diagrams
-                .get(&id("state_view"))
-                .ok_or("Missing saved State view")?;
-            let a = old
-                .nodes
-                .get(&id("node_a"))
-                .ok_or("Missing baseline A")?
-                .position;
-            let moved_a = new
-                .nodes
-                .get(&id("node_a"))
-                .ok_or("Missing saved A")?
-                .position;
-            let d = point(moved_a.x - a.x, moved_a.y - a.y);
-            if !d.x.is_finite()
-                || !d.y.is_finite()
-                || d.x.abs().max(d.y.abs()) > 300.
-                || d.x.hypot(d.y) < 0.01
-            {
-                return Err(format!(
-                    "Move delta must have length >=0.01 and each axis <=300 world units: {d:?}"
-                )
-                .into());
-            }
-            let view = expected.diagrams.get_mut(&id("state_view")).unwrap();
-            // Independent explicit fixture enumeration: no group/descendant/
-            // routing planner is called to predict the result.
-            for alias in [
-                "node_a",
-                "node_b",
-                "node_inner",
-                "node_leaf",
-                "node_entry",
-                "node_exit",
-            ] {
-                let node = view
-                    .nodes
-                    .get_mut(&id(alias))
-                    .ok_or("Missing expected moved placement")?;
-                node.position.x += d.x;
-                node.position.y += d.y;
-            }
-            for alias in ["between", "entry_route", "exit_route"] {
-                let route = view
-                    .routes
-                    .iter_mut()
-                    .find(|route| route.edge == id(alias))
-                    .ok_or("Missing explicitly expected moved route")?;
-                for pin in &mut route.waypoints {
-                    pin.x += d.x;
-                    pin.y += d.y;
-                }
-            }
-            delta = Some(d);
-        }
-        _ => return Err("Mode must be moved, hide, or unchanged".into()),
-    }
-    equal(&expected, &actual)?;
-    roundtrip(&actual)?;
-    println!(
-        "{}",
-        serde_json::to_string_pretty(&serde_json::json!({
-            "result": "PASS", "mode": mode, "baseline": baseline, "saved": saved,
-            "comparison": "complete Project equality", "inferred_common_delta": delta,
-            "limits": "Invariant evaluator only; no pointer/action/focus/Undo/source-byte acceptance claim",
-        }))?
-    );
-    Ok(())
-}
-fn main() -> Result<()> {
-    let args: Vec<_> = std::env::args().skip(1).collect();
-    match args.as_slice() {
-        [command, out] if command == "generate" => generate(Path::new(out)),
-        [command, mode, baseline, saved] if command == "check" => check(mode, Path::new(baseline), Path::new(saved)),
-        _ => Err("Usage: state_multiselect_native generate DIRECTORY | check moved|hide|unchanged BASELINE SAVED".into()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::BTreeSet;
-
-    // Produce evidence through real validated commands; the checker itself uses
-    // explicit fixture enumeration and never calls this movement implementation.
-    fn moved(before: &Project, delta: Position) -> Project {
-        let command = diagram_edit::translate_placements(
-            before,
-            id("state_view"),
-            &BTreeSet::from([id("node_a"), id("node_b")]),
-            delta,
-        )
-        .unwrap();
-        let mut session = Session::new(before.clone());
-        session.execute(command).unwrap();
-        session.project().clone()
-    }
-    fn hidden(before: &Project) -> Project {
-        let mut session = Session::new(before.clone());
-        session
-            .execute(Command::Batch(vec![
-                Command::Delete(id("node_a")),
-                Command::Delete(id("node_b")),
-            ]))
-            .unwrap();
-        session.project().clone()
-    }
-    fn through_saved_json(mode: &str, baseline: &Project, actual: &Project) -> Result<()> {
-        let dir = tempfile::tempdir()?;
-        let before = dir.path().join("before.json");
-        let saved = dir.path().join("saved.json");
-        // These assertions distinguish meaningful invariant corruptions from
-        // malformed projects rejected before the evaluator even sees them.
-        validate_candidate(baseline).expect("test baseline must be valid");
-        validate_candidate(actual).expect("corruption must remain a valid model");
-        persistence::save(&before, baseline)?;
-        persistence::save(&saved, actual)?;
-        check(mode, &before, &saved)
-    }
-    fn mismatch(mode: &str, before: &Project, actual: &Project, case: &str) {
-        let error = through_saved_json(mode, before, actual)
-            .expect_err(case)
-            .to_string();
-        assert!(
-            error.contains("Whole Project mismatch"),
-            "{case}: unexpected rejection: {error}"
-        );
-    }
-    fn edge<'a>(p: &'a mut Project, alias: &str) -> &'a mut EdgeRoute {
-        p.diagrams
-            .get_mut(&id("state_view"))
-            .unwrap()
-            .routes
-            .iter_mut()
-            .find(|route| route.edge == id(alias))
-            .unwrap()
-    }
-
-    #[test]
-    fn generated_json_and_real_source_bundle_are_accepted_unchanged() {
-        let dir = tempfile::tempdir().unwrap();
-        let out = dir.path().join("fixture");
-        generate(&out).unwrap();
-        let baseline = out.join("baseline.json");
-        let saved = out.join("saved.json");
-        persistence::save(&saved, &fixture().unwrap()).unwrap();
-        check("unchanged", &baseline, &saved).unwrap();
-        check("unchanged", &baseline, &out.join("source/project.arcadia")).unwrap();
-        let bytes = fs::read(&baseline).unwrap();
-        assert!(
-            generate(&out).is_err(),
-            "generation cannot overwrite evidence"
-        );
-        assert_eq!(fs::read(&baseline).unwrap(), bytes);
-        let invalid = dir.path().join("invalid.arcadia");
-        fs::write(&invalid, "project {").unwrap();
-        assert!(load(&invalid).is_err(), "source errors must still reject");
-    }
-
-    #[test]
-    fn real_group_command_outputs_pass_and_are_not_unchanged() {
-        let before = fixture().unwrap();
-        for delta in [
-            point(7.25, -2.75),
-            point(-20.5, 30.125),
-            point(0.25, 0.),
-            point(0.01, 10.),
-            point(0.1, -0.2),
-        ] {
-            let actual = moved(&before, delta);
-            through_saved_json("moved", &before, &actual).unwrap();
-            mismatch(
-                "unchanged",
-                &before,
-                &actual,
-                "real movement cannot count as unchanged",
-            );
-        }
-    }
-
-    #[test]
-    fn real_hide_command_outputs_pass_before_and_after_movement() {
-        let initial = fixture().unwrap();
-        for before in [initial.clone(), moved(&initial, point(40., 60.))] {
-            let actual = hidden(&before);
-            through_saved_json("hide", &before, &actual).unwrap();
-            mismatch(
-                "unchanged",
-                &before,
-                &actual,
-                "real Hide cannot count as unchanged",
-            );
-        }
-    }
-
-    #[test]
-    fn omitted_and_double_moved_child_are_rejected() {
-        let before = fixture().unwrap();
-        let delta = point(40., 60.);
-        let correct = moved(&before, delta);
-        for alias in ["node_inner", "node_leaf", "node_entry", "node_exit"] {
-            let initial = before.diagrams[&id("state_view")].nodes[&id(alias)].position;
-            for position in [
-                initial,
-                point(initial.x + 2. * delta.x, initial.y + 2. * delta.y),
-            ] {
-                let mut bad = correct.clone();
-                bad.diagrams
-                    .get_mut(&id("state_view"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id(alias))
-                    .unwrap()
-                    .position = position;
-                mismatch("moved", &before, &bad, "child did not move exactly once");
-            }
-        }
-    }
-
-    #[test]
-    fn internal_pins_left_behind_and_external_pins_moved_are_rejected() {
-        let mut before = fixture().unwrap();
-        let correct = moved(&before, point(40., 60.));
-        for alias in ["between", "entry_route", "exit_route"] {
-            let original_pins = edge(&mut before, alias).waypoints.clone();
-            let mut bad = correct.clone();
-            edge(&mut bad, alias).waypoints = original_pins;
-            mismatch("moved", &before, &bad, "internal pins left behind");
-        }
-        let mut bad = correct;
-        for pin in &mut edge(&mut bad, "external").waypoints {
-            pin.x += 40.;
-            pin.y += 60.;
-        }
-        mismatch("moved", &before, &bad, "one-ended pins moved");
-    }
-
-    #[test]
-    fn manual_attachments_and_label_data_must_remain_exact() {
-        let before = fixture().unwrap();
-        let correct = moved(&before, point(40., 60.));
-        let mutations: [fn(&mut EdgeRoute); 4] = [
-            |r| r.source_attachment.as_mut().unwrap().offset = 0.65,
-            |r| r.target_attachment.as_mut().unwrap().side = PortAnchorSide::Top,
-            |r| r.label.as_mut().unwrap().offset.x += 40.,
-            |r| r.label.as_mut().unwrap().fraction = 0.75,
-        ];
-        for mutate in mutations {
-            let mut bad = correct.clone();
-            mutate(edge(&mut bad, "between"));
-            mismatch("moved", &before, &bad, "relative route metadata changed");
-        }
-    }
-
-    #[test]
-    fn semantic_other_view_fixed_node_and_trace_drift_are_rejected() {
-        let before = fixture().unwrap();
-        let correct = moved(&before, point(40., 60.));
-        let mutations: [fn(&mut Project); 9] = [
-            |p| p.traces.get_mut(&id("trace")).unwrap().baseline = None,
-            |p| {
-                p.elements
-                    .get_mut(&id("shared_work"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift")
-            },
-            |p| {
-                if let RelationBody::StateAction { phase, .. } =
-                    &mut p.relations.get_mut(&id("action_a")).unwrap().body
-                {
-                    *phase = StateActionKind::Exit;
-                }
-            },
-            |p| {
-                if let RelationBody::StateTransition { guard, .. } =
-                    &mut p.relations.get_mut(&id("refresh")).unwrap().body
-                {
-                    *guard = "changed_refresh_guard".into();
-                }
-            },
-            |p| {
-                p.elements
-                    .get_mut(&id("state_a"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift")
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("state_other"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("other_a"))
-                    .unwrap()
-                    .position
-                    .x += 40.
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("sa_view"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("sa_node"))
-                    .unwrap()
-                    .position
-                    .y += 60.
-            },
-            |p| {
-                p.diagrams
-                    .get_mut(&id("state_view"))
-                    .unwrap()
-                    .nodes
-                    .get_mut(&id("node_c"))
-                    .unwrap()
-                    .position
-                    .x += 40.
-            },
-            |p| {
-                p.traces
-                    .get_mut(&id("trace"))
-                    .unwrap()
-                    .description
-                    .push_str(" drift")
-            },
-        ];
-        for mutate in mutations {
-            let mut bad = correct.clone();
-            mutate(&mut bad);
-            mismatch(
-                "moved",
-                &before,
-                &bad,
-                "record outside permitted movement changed",
-            );
-        }
-    }
-
-    #[test]
-    fn zero_and_excessive_moves_cannot_satisfy_move_evidence() {
-        let before = fixture().unwrap();
-        for (delta, reason) in [
-            (point(0., 0.), "length >=0.01"),
-            (point(310., 0.), "each axis <=300"),
-        ] {
-            let actual = moved(&before, delta);
-            let error = through_saved_json("moved", &before, &actual)
-                .unwrap_err()
-                .to_string();
-            assert!(error.contains(reason), "{delta:?}: {error}");
-        }
-    }
-
-    #[test]
-    fn hide_must_preserve_child_routes_and_semantic_objects() {
-        let before = fixture().unwrap();
-        let correct = hidden(&before);
-        let mut missing_child = correct.clone();
-        missing_child
-            .diagrams
-            .get_mut(&id("state_view"))
-            .unwrap()
-            .nodes
-            .remove(&id("node_leaf"));
-        mismatch(
-            "hide",
-            &before,
-            &missing_child,
-            "Hide removed unselected child placement",
-        );
-        let mut missing_routes = correct;
-        missing_routes
-            .diagrams
-            .get_mut(&id("state_view"))
-            .unwrap()
-            .routes
-            .clear();
-        mismatch(
-            "hide",
-            &before,
-            &missing_routes,
-            "Hide removed persistent route records",
-        );
-        let mut semantic_delete = Session::new(before.clone());
-        semantic_delete
-            .execute(Command::Batch(vec![
-                Command::Delete(id("state_a")),
-                Command::Delete(id("state_b")),
-            ]))
-            .unwrap();
-        mismatch(
-            "hide",
-            &before,
-            semantic_delete.project(),
-            "Hide became semantic deletion",
-        );
-    }
-
-    #[test]
-    fn unchanged_rejects_valid_semantic_drift_without_geometry_changes() {
-        let before = fixture().unwrap();
-        let mut actual = before.clone();
-        actual
-            .elements
-            .get_mut(&id("state_b"))
-            .unwrap()
-            .name
-            .push_str(" edited");
-        mismatch(
-            "unchanged",
-            &before,
-            &actual,
-            "geometry equality is not complete Project equality",
-        );
-    }
-
-    #[test]
-    fn moved_and_hidden_source_inputs_are_checked_against_complete_expected_projects() {
-        let before = fixture().unwrap();
-        for (mode, actual) in [
-            ("moved", moved(&before, point(7.25, -2.75))),
-            ("hide", hidden(&before)),
-        ] {
-            let dir = tempfile::tempdir().unwrap();
-            let baseline = dir.path().join("baseline.json");
-            persistence::save(&baseline, &before).unwrap();
-            let bundle = roundtrip(&actual).unwrap();
-            for (path, source) in &bundle.files {
-                write_new(&dir.path().join("saved").join(path), source.as_bytes()).unwrap();
-            }
-            check(
-                mode,
-                &baseline,
-                &dir.path().join("saved").join(&bundle.entry),
-            )
-            .unwrap();
-            let mut corrupt = actual.clone();
-            corrupt.elements.get_mut(&id("shared_work")).unwrap().name =
-                "Unrequested source edit".into();
-            let bundle = roundtrip(&corrupt).unwrap();
-            for (path, source) in &bundle.files {
-                write_new(&dir.path().join("corrupt").join(path), source.as_bytes()).unwrap();
-            }
-            let error = check(
-                mode,
-                &baseline,
-                &dir.path().join("corrupt").join(&bundle.entry),
-            )
-            .unwrap_err()
-            .to_string();
-            assert!(error.contains("Whole Project mismatch"), "{error}");
-        }
-    }
-}

crates/oa-core/src/analysis_numeric.rs

@@ -1,103 +0,0 @@
-//! Exact numeric foundation for analysis; no model, expression, or package resolver.
-//!
-//! Values use reduced rational coordinates. All nontrivial arithmetic takes one
-//! request-local [WorkMeter]. The future evaluator must also charge *expanded*
-//! expression/call/property/list/target visits and retain the same logical walk on
-//! cache hits. Stored AST size is not a dynamic execution limit.
-//!
-//! Approximate engineering functions/irrational unit scales require a subsequent
-//! explicit numeric profile; rationals do not implement degree/radian conversion
-//! or transcendental mathematics.
-
-mod dimension;
-mod exact;
-mod meter;
-mod quantity;
-
-pub use dimension::{Dimension, DimensionAxis};
-pub use exact::{Exact, ExactWire};
-pub use meter::{
-    EvaluationStep, NumericOperation, WorkExhaustion, WorkLimits, WorkMeter, WorkResource,
-    WorkSite, WorkUsage,
-};
-pub use quantity::{NumericType, NumericValue, ResolvedKind, Unit};
-
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-/// Profile identity includes the accounting rules, not crate-internal timing.
-pub const WORK_PROFILE: &str = "Q1-logical-work-1";
-pub const MAX_COMPONENT_BITS: u64 = 4096;
-/// Cross products require 8192 bits; their sum can require one additional bit.
-pub const MAX_INTERMEDIATE_BITS: u64 = 8193;
-pub const MAX_COMPONENT_DIGITS: usize = 1234;
-pub const MAX_DECIMAL_EXPONENT: i32 = 128;
-pub const MAX_INTEGER_POWER: i8 = 16;
-/// Includes ratio punctuation/whitespace without permitting unbounded scanning.
-pub const MAX_LITERAL_BYTES: usize = 2 * MAX_COMPONENT_DIGITS + 32;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum NumberComponent {
-    Numerator,
-    Denominator,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
-pub enum NumericLimit {
-    #[error("request work exhausted: {0}")]
-    Work(WorkExhaustion),
-    #[error("{component:?} uses {bits} bits, above the {limit}-bit {stage} limit")]
-    Bits {
-        component: NumberComponent,
-        bits: u64,
-        limit: u64,
-        stage: String,
-    },
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
-pub enum NumericError {
-    #[error("numeric limit: {0}")]
-    Limit(NumericLimit),
-    #[error("invalid numeric literal")]
-    InvalidLiteral,
-    #[error("numeric literal exceeds its digit or byte limit")]
-    LiteralTooLong,
-    #[error("decimal exponent is outside -128 through 128")]
-    DecimalExponent,
-    #[error("wire rational is not in canonical reduced form")]
-    NonCanonicalWire,
-    #[error("rational denominator is zero")]
-    ZeroDenominator,
-    #[error("division by zero")]
-    DivisionByZero,
-    #[error("zero to the power zero is undefined in this profile")]
-    ZeroPowerZero,
-    #[error("integer power is outside -16 through 16")]
-    IntegerPower,
-    #[error("dimension exponent at {axis:?} is outside -32 through 32: {value}")]
-    DimensionExponent { axis: DimensionAxis, value: i32 },
-    #[error("unit scale must be strictly positive")]
-    UnitScale,
-    #[error("a linear unit must have zero offset")]
-    LinearOffset,
-    #[error("an affine point must have a distinct linear difference kind")]
-    DifferenceKind,
-    #[error("numeric kinds or dimensions are incompatible")]
-    IncompatibleTypes,
-    #[error("operation is not defined for affine points")]
-    AffineOperation,
-    #[error("AsKind requires an anonymous matching dimension and a linear target")]
-    KindAssertion,
-    #[error("request work limits exceed the provisional reference ceilings")]
-    InvalidWorkLimits,
-}
-
-impl NumericError {
-    pub fn is_terminal_work_exhaustion(&self) -> bool {
-        matches!(self, Self::Limit(NumericLimit::Work(_)))
-    }
-}
-
-#[cfg(test)]
-mod tests;

crates/oa-core/src/analysis_numeric/dimension.rs

@@ -1,107 +0,0 @@
-use super::NumericError;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum DimensionAxis {
-    Length,
-    Mass,
-    Time,
-    ElectricCurrent,
-    Temperature,
-    Amount,
-    LuminousIntensity,
-}
-
-impl DimensionAxis {
-    pub const ALL: [Self; 7] = [
-        Self::Length,
-        Self::Mass,
-        Self::Time,
-        Self::ElectricCurrent,
-        Self::Temperature,
-        Self::Amount,
-        Self::LuminousIntensity,
-    ];
-}
-
-/// SI base-dimension vector in DimensionAxis::ALL order, each entry -32..=32.
-/// This is a dimension, never a nominal quantity-kind compatibility proof.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(try_from = "[i16; 7]", into = "[i16; 7]")]
-pub struct Dimension([i16; 7]);
-
-impl Dimension {
-    pub const ZERO: Self = Self([0; 7]);
-
-    pub fn new(exponents: [i16; 7]) -> Result<Self, NumericError> {
-        for (index, value) in exponents.iter().copied().enumerate() {
-            if !(-32..=32).contains(&value) {
-                return Err(NumericError::DimensionExponent {
-                    axis: DimensionAxis::ALL[index],
-                    value: i32::from(value),
-                });
-            }
-        }
-        Ok(Self(exponents))
-    }
-
-    pub fn exponents(self) -> [i16; 7] {
-        self.0
-    }
-
-    pub fn is_dimensionless(self) -> bool {
-        self == Self::ZERO
-    }
-
-    pub fn checked_product(self, rhs: Self) -> Result<Self, NumericError> {
-        self.combine(rhs, 1)
-    }
-
-    pub fn checked_quotient(self, rhs: Self) -> Result<Self, NumericError> {
-        self.combine(rhs, -1)
-    }
-
-    pub fn checked_power(self, exponent: i8) -> Result<Self, NumericError> {
-        if !(-super::MAX_INTEGER_POWER..=super::MAX_INTEGER_POWER).contains(&exponent) {
-            return Err(NumericError::IntegerPower);
-        }
-        let mut output = [0; 7];
-        for (index, value) in self.0.iter().enumerate() {
-            output[index] = Self::checked_exponent(index, i32::from(*value) * i32::from(exponent))?;
-        }
-        Ok(Self(output))
-    }
-
-    fn combine(self, rhs: Self, sign: i32) -> Result<Self, NumericError> {
-        let mut output = [0; 7];
-        for (index, value) in self.0.iter().enumerate() {
-            output[index] =
-                Self::checked_exponent(index, i32::from(*value) + sign * i32::from(rhs.0[index]))?;
-        }
-        Ok(Self(output))
-    }
-
-    fn checked_exponent(index: usize, value: i32) -> Result<i16, NumericError> {
-        if !(-32..=32).contains(&value) {
-            return Err(NumericError::DimensionExponent {
-                axis: DimensionAxis::ALL[index],
-                value,
-            });
-        }
-        Ok(value as i16)
-    }
-}
-
-impl TryFrom<[i16; 7]> for Dimension {
-    type Error = NumericError;
-
-    fn try_from(value: [i16; 7]) -> Result<Self, Self::Error> {
-        Self::new(value)
-    }
-}
-
-impl From<Dimension> for [i16; 7] {
-    fn from(value: Dimension) -> Self {
-        value.0
-    }
-}

crates/oa-core/src/analysis_numeric/exact.rs

@@ -1,469 +0,0 @@
-use super::meter::{normalization_cost, parse_cost, product_cost, sum_cost, words};
-use super::{
-    MAX_COMPONENT_BITS, MAX_COMPONENT_DIGITS, MAX_DECIMAL_EXPONENT, MAX_INTEGER_POWER,
-    MAX_INTERMEDIATE_BITS, MAX_LITERAL_BYTES, NumberComponent, NumericError, NumericLimit,
-    NumericOperation, WorkLimits, WorkMeter,
-};
-use num_bigint::BigInt;
-use num_integer::Integer;
-use num_traits::{One, Signed, Zero};
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-
-/// The interchange representation deliberately does not use num-bigint's serde
-/// format or JSON numeric values. Duplicate/missing/unknown fields reject.
-/// Its derived decoder allocates String fields before numeric validation; a
-/// transport/document adapter must bound the encoded envelope and decoded text.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct ExactWire {
-    pub numerator: String,
-    pub denominator: String,
-}
-
-/// Reduced rational with positive denominator and <=4096-bit components.
-///
-/// There are no unmetered arithmetic/ordering traits. Eq is structural equality
-/// of already normalized bounded values, not an expression comparison API.
-/// Standalone serde admission bounds the subsequent BigInt validation, not the
-/// preceding String decoding. Document adapters must bound encoded/decoded input
-/// and aggregate admission work. Evaluation uses one explicit WorkMeter.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(try_from = "ExactWire", into = "ExactWire")]
-pub struct Exact {
-    numerator: BigInt,
-    denominator: BigInt,
-}
-
-impl Exact {
-    pub fn from_integer(value: i64) -> Self {
-        Self {
-            numerator: BigInt::from(value),
-            denominator: BigInt::one(),
-        }
-    }
-
-    pub fn is_zero(&self) -> bool {
-        self.numerator.is_zero()
-    }
-
-    pub fn is_positive(&self) -> bool {
-        self.numerator.is_positive()
-    }
-
-    pub fn component_bits(&self) -> (u64, u64) {
-        (self.numerator.bits(), self.denominator.bits())
-    }
-
-    pub fn to_wire(&self) -> ExactWire {
-        ExactWire {
-            numerator: self.numerator.to_string(),
-            denominator: self.denominator.to_string(),
-        }
-    }
-
-    /// Canonical *literal* spelling, not a generic expression formatter.
-    /// Negative literal nodes use ratio(-n,d), even when d=1. A leading minus
-    /// belongs to the future expression parser's UnaryNegate node instead.
-    pub fn canonical_literal(&self) -> String {
-        if self.denominator.is_one() && !self.numerator.is_negative() {
-            self.numerator.to_string()
-        } else {
-            format!("ratio({}, {})", self.numerator, self.denominator)
-        }
-    }
-
-    pub fn from_wire(wire: &ExactWire, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        let n_digits = wire_digits(&wire.numerator, true)?;
-        let d_digits = wire_digits(&wire.denominator, false)?;
-        let n_bound = decimal_bits(n_digits.len());
-        let d_bound = decimal_bits(d_digits.len());
-        meter.numeric(
-            NumericOperation::ParseWire,
-            parse_cost(n_digits.len(), n_bound)
-                + parse_cost(d_digits.len(), d_bound)
-                + normalization_cost(n_bound, d_bound),
-        )?;
-        let numerator = parse_integer(&wire.numerator)?;
-        let denominator = parse_integer(&wire.denominator)?;
-        Self::check_bits(&numerator, &denominator, MAX_COMPONENT_BITS, "wire")?;
-        if denominator.is_zero() {
-            return Err(NumericError::ZeroDenominator);
-        }
-        if !numerator.gcd(&denominator).is_one() {
-            return Err(NumericError::NonCanonicalWire);
-        }
-        Ok(Self {
-            numerator,
-            denominator,
-        })
-    }
-
-    /// Reads one unsigned decimal/integer atom or a ratio(n,d) literal only.
-    /// It does not parse expressions, unary operators, units, calls or names.
-    /// Source ratios/decimals may reduce; wire values must already be canonical.
-    pub fn parse_literal(source: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        if source.len() > MAX_LITERAL_BYTES {
-            return Err(NumericError::LiteralTooLong);
-        }
-        let source = trim_ascii(source);
-        if let Some(body) = source.strip_prefix("ratio(") {
-            let body = body.strip_suffix(')').ok_or(NumericError::InvalidLiteral)?;
-            let (n, d) = body.split_once(',').ok_or(NumericError::InvalidLiteral)?;
-            return Self::parse_ratio(trim_ascii(n), trim_ascii(d), meter);
-        }
-        Self::parse_decimal(source, meter)
-    }
-
-    fn parse_ratio(n: &str, d: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        let n_digits = source_integer_digits(n, true)?;
-        let d_digits = source_integer_digits(d, false)?;
-        let n_bound = decimal_bits(n_digits.len());
-        let d_bound = decimal_bits(d_digits.len());
-        Self::check_estimates(n_bound, d_bound)?;
-        meter.numeric(
-            NumericOperation::ParseLiteral,
-            parse_cost(n_digits.len(), n_bound)
-                + parse_cost(d_digits.len(), d_bound)
-                + normalization_cost(n_bound, d_bound),
-        )?;
-        Self::normalize_precharged(parse_integer(n)?, parse_integer(d)?)
-    }
-
-    fn parse_decimal(source: &str, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        let mut parts = source.split(['e', 'E']);
-        let mantissa = parts.next().ok_or(NumericError::InvalidLiteral)?;
-        let exponent = match parts.next() {
-            Some(text) => parse_exponent(text)?,
-            None => 0,
-        };
-        if parts.next().is_some() {
-            return Err(NumericError::InvalidLiteral);
-        }
-        let (whole, fraction) = match mantissa.split_once('.') {
-            Some((whole, fraction)) if !fraction.is_empty() => (whole, fraction),
-            Some(_) => return Err(NumericError::InvalidLiteral),
-            None => (mantissa, ""),
-        };
-        source_integer_digits(whole, false)?;
-        if !fraction.bytes().all(|byte| byte.is_ascii_digit()) {
-            return Err(NumericError::InvalidLiteral);
-        }
-        let digit_count = whole.len() + fraction.len();
-        if digit_count > MAX_COMPONENT_DIGITS {
-            return Err(NumericError::LiteralTooLong);
-        }
-        let adjustment = exponent - fraction.len() as i32;
-        let power = adjustment.unsigned_abs();
-        let mantissa_bound = decimal_bits(digit_count);
-        let scale_bound = decimal_bits(power as usize + 1);
-        let (n_bound, d_bound) = if adjustment >= 0 {
-            (mantissa_bound + scale_bound, 1)
-        } else {
-            (mantissa_bound, scale_bound)
-        };
-        Self::check_estimates(n_bound, d_bound)?;
-        // Fixed logical allowance for constructing 10^power; independent of
-        // num-bigint's selected multiplication/exponentiation implementation.
-        let power_steps = 1 + 2 * u64::from(u32::BITS - power.leading_zeros());
-        meter.numeric(
-            NumericOperation::ParseLiteral,
-            parse_cost(digit_count, mantissa_bound)
-                + power_steps * product_cost(scale_bound, scale_bound)
-                + product_cost(mantissa_bound, scale_bound)
-                + normalization_cost(n_bound, d_bound),
-        )?;
-        let digits = format!("{whole}{fraction}");
-        let mut numerator = parse_integer(&digits)?;
-        let scale = BigInt::from(10_u8).pow(power);
-        let denominator = if adjustment >= 0 {
-            numerator *= scale;
-            BigInt::one()
-        } else {
-            scale
-        };
-        Self::normalize_precharged(numerator, denominator)
-    }
-
-    pub fn add(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        self.add_or_subtract(rhs, false, meter)
-    }
-
-    pub fn subtract(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        self.add_or_subtract(rhs, true, meter)
-    }
-
-    fn add_or_subtract(
-        &self,
-        rhs: &Self,
-        subtract: bool,
-        meter: &mut WorkMeter,
-    ) -> Result<Self, NumericError> {
-        let (a, b) = self.component_bits();
-        let (c, d) = rhs.component_bits();
-        let left_bound = a + d;
-        let right_bound = c + b;
-        let n_bound = left_bound.max(right_bound) + 1;
-        let d_bound = b + d;
-        Self::check_estimates(n_bound, d_bound)?;
-        meter.numeric(
-            if subtract {
-                NumericOperation::Subtract
-            } else {
-                NumericOperation::Add
-            },
-            product_cost(a, d)
-                + product_cost(c, b)
-                + sum_cost(left_bound, right_bound)
-                + product_cost(b, d)
-                + normalization_cost(n_bound, d_bound),
-        )?;
-        let left = &self.numerator * &rhs.denominator;
-        let right = &rhs.numerator * &self.denominator;
-        let numerator = if subtract { left - right } else { left + right };
-        let denominator = &self.denominator * &rhs.denominator;
-        Self::normalize_precharged(numerator, denominator)
-    }
-
-    pub fn multiply(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        let (a, b) = self.component_bits();
-        let (c, d) = rhs.component_bits();
-        Self::check_estimates(a + c, b + d)?;
-        meter.numeric(
-            NumericOperation::Multiply,
-            product_cost(a, c) + product_cost(b, d) + normalization_cost(a + c, b + d),
-        )?;
-        Self::normalize_precharged(
-            &self.numerator * &rhs.numerator,
-            &self.denominator * &rhs.denominator,
-        )
-    }
-
-    pub fn divide(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        let (a, b) = self.component_bits();
-        let (c, d) = rhs.component_bits();
-        Self::check_estimates(a + d, b + c)?;
-        meter.numeric(
-            NumericOperation::Divide,
-            product_cost(a, d) + product_cost(b, c) + normalization_cost(a + d, b + c),
-        )?;
-        if rhs.is_zero() {
-            return Err(NumericError::DivisionByZero);
-        }
-        Self::normalize_precharged(
-            &self.numerator * &rhs.denominator,
-            &self.denominator * &rhs.numerator,
-        )
-    }
-
-    pub fn compare(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Ordering, NumericError> {
-        let (a, b) = self.component_bits();
-        let (c, d) = rhs.component_bits();
-        Self::check_estimates((a + d).max(c + b), 1)?;
-        meter.numeric(
-            NumericOperation::Compare,
-            product_cost(a, d) + product_cost(c, b) + sum_cost(a + d, c + b),
-        )?;
-        Ok((&self.numerator * &rhs.denominator).cmp(&(&rhs.numerator * &self.denominator)))
-    }
-
-    pub fn negated(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.numeric(NumericOperation::Negate, self.copy_cost())?;
-        Ok(Self {
-            numerator: -&self.numerator,
-            denominator: self.denominator.clone(),
-        })
-    }
-
-    pub fn absolute(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.numeric(NumericOperation::Absolute, self.copy_cost())?;
-        Ok(Self {
-            numerator: self.numerator.abs(),
-            denominator: self.denominator.clone(),
-        })
-    }
-
-    pub fn reciprocal(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.numeric(NumericOperation::Reciprocal, self.copy_cost())?;
-        if self.is_zero() {
-            return Err(NumericError::DivisionByZero);
-        }
-        Ok(Self {
-            numerator: if self.numerator.is_negative() {
-                -&self.denominator
-            } else {
-                self.denominator.clone()
-            },
-            denominator: self.numerator.abs(),
-        })
-    }
-
-    /// Fixed left-to-right repeated multiplication, at most 16 multiplications.
-    /// Each reduced stage obeys the same component bound; no large power is
-    /// allocated and subsequently discarded after discovering it is oversized.
-    pub fn power(&self, exponent: i8, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.numeric(NumericOperation::Power, self.copy_cost())?;
-        if !(-MAX_INTEGER_POWER..=MAX_INTEGER_POWER).contains(&exponent) {
-            return Err(NumericError::IntegerPower);
-        }
-        if self.is_zero() && exponent == 0 {
-            return Err(NumericError::ZeroPowerZero);
-        }
-        let factor = if exponent < 0 {
-            self.reciprocal(meter)?
-        } else {
-            self.clone()
-        };
-        let mut value = Self::from_integer(1);
-        for _ in 0..exponent.unsigned_abs() {
-            value = value.multiply(&factor, meter)?;
-        }
-        Ok(value)
-    }
-
-    pub(super) fn copy_cost(&self) -> u64 {
-        let (n, d) = self.component_bits();
-        1 + words(n) + words(d)
-    }
-
-    fn normalize_precharged(
-        mut numerator: BigInt,
-        mut denominator: BigInt,
-    ) -> Result<Self, NumericError> {
-        Self::check_bits(
-            &numerator,
-            &denominator,
-            MAX_INTERMEDIATE_BITS,
-            "intermediate",
-        )?;
-        if denominator.is_zero() {
-            return Err(NumericError::ZeroDenominator);
-        }
-        if denominator.is_negative() {
-            numerator = -numerator;
-            denominator = -denominator;
-        }
-        let gcd = numerator.gcd(&denominator);
-        numerator /= &gcd;
-        denominator /= gcd;
-        Self::check_bits(&numerator, &denominator, MAX_COMPONENT_BITS, "reduced")?;
-        Ok(Self {
-            numerator,
-            denominator,
-        })
-    }
-
-    fn check_estimates(n: u64, d: u64) -> Result<(), NumericError> {
-        Self::check_bit_count(
-            n,
-            NumberComponent::Numerator,
-            MAX_INTERMEDIATE_BITS,
-            "predicted",
-        )?;
-        Self::check_bit_count(
-            d,
-            NumberComponent::Denominator,
-            MAX_INTERMEDIATE_BITS,
-            "predicted",
-        )
-    }
-
-    fn check_bits(n: &BigInt, d: &BigInt, limit: u64, stage: &str) -> Result<(), NumericError> {
-        Self::check_bit_count(n.bits(), NumberComponent::Numerator, limit, stage)?;
-        Self::check_bit_count(d.bits(), NumberComponent::Denominator, limit, stage)
-    }
-
-    fn check_bit_count(
-        bits: u64,
-        component: NumberComponent,
-        limit: u64,
-        stage: &str,
-    ) -> Result<(), NumericError> {
-        if bits > limit {
-            return Err(NumericError::Limit(NumericLimit::Bits {
-                component,
-                bits,
-                limit,
-                stage: stage.to_owned(),
-            }));
-        }
-        Ok(())
-    }
-}
-
-impl TryFrom<ExactWire> for Exact {
-    type Error = NumericError;
-
-    fn try_from(value: ExactWire) -> Result<Self, Self::Error> {
-        // BigInt validation is bounded after ExactWire strings have decoded.
-        // The adapter owns envelope/text/aggregate admission bounds and must not
-        // reset evaluation meters.
-        Self::from_wire(&value, &mut WorkMeter::new(WorkLimits::REFERENCE))
-    }
-}
-
-impl From<Exact> for ExactWire {
-    fn from(value: Exact) -> Self {
-        value.to_wire()
-    }
-}
-
-fn trim_ascii(text: &str) -> &str {
-    text.trim_matches(|ch: char| ch.is_ascii_whitespace())
-}
-
-fn source_integer_digits(text: &str, signed: bool) -> Result<&str, NumericError> {
-    let digits = if signed {
-        text.strip_prefix('-').unwrap_or(text)
-    } else {
-        text
-    };
-    if digits.len() > MAX_COMPONENT_DIGITS {
-        return Err(NumericError::LiteralTooLong);
-    }
-    if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
-        return Err(NumericError::InvalidLiteral);
-    }
-    Ok(digits)
-}
-
-fn wire_digits(text: &str, signed: bool) -> Result<&str, NumericError> {
-    let digits = source_integer_digits(text, signed).map_err(|error| match error {
-        NumericError::LiteralTooLong => error,
-        _ => NumericError::NonCanonicalWire,
-    })?;
-    if (digits.len() > 1 && digits.starts_with('0')) || (text.starts_with('-') && digits == "0") {
-        return Err(NumericError::NonCanonicalWire);
-    }
-    Ok(digits)
-}
-
-fn parse_integer(text: &str) -> Result<BigInt, NumericError> {
-    BigInt::parse_bytes(text.as_bytes(), 10).ok_or(NumericError::InvalidLiteral)
-}
-
-fn parse_exponent(text: &str) -> Result<i32, NumericError> {
-    let (negative, digits) = if let Some(digits) = text.strip_prefix('-') {
-        (true, digits)
-    } else {
-        (false, text.strip_prefix('+').unwrap_or(text))
-    };
-    if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
-        return Err(NumericError::InvalidLiteral);
-    }
-    let mut value = 0_i32;
-    for digit in digits.bytes() {
-        value = value * 10 + i32::from(digit - b'0');
-        if value > MAX_DECIMAL_EXPONENT {
-            return Err(NumericError::DecimalExponent);
-        }
-    }
-    Ok(if negative { -value } else { value })
-}
-
-fn decimal_bits(digits: usize) -> u64 {
-    // 3.322 exceeds log2(10); dimensions are bounded before this conversion.
-    (digits as u64 * 3322).div_ceil(1000).max(1)
-}

crates/oa-core/src/analysis_numeric/fixtures/r7-literal-boundaries.json

@@ -1,32 +0,0 @@
-[
-  {
-    "canonical_source": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "expression": {
-      "Number": {
-        "denominator": "1",
-        "numerator": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-      }
-    },
-    "name": "ten_to_300"
-  },
-  {
-    "canonical_source": "ratio(1, 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168)",
-    "expression": {
-      "Number": {
-        "denominator": "522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168",
-        "numerator": "1"
-      }
-    },
-    "name": "one_over_two_to_4095"
-  },
-  {
-    "canonical_source": "ratio(-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335, 1)",
-    "expression": {
-      "Number": {
-        "denominator": "1",
-        "numerator": "-1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190335"
-      }
-    },
-    "name": "negative_4096_bit_bound"
-  }
-]

crates/oa-core/src/analysis_numeric/meter.rs

@@ -1,240 +0,0 @@
-use super::{NumericError, NumericLimit};
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-/// Every event is charged once per dynamic occurrence, before entering it.
-///
-/// A Call expression therefore charges Expression and CalculationEntry; a
-/// Property read charges Expression and PropertyBinding. List element visits
-/// are additional to evaluation of their expressions. Only executed branches
-/// are charged. Targets are sorted by category (properties, then checks), then
-/// stable UUID bytes, by the integrating evaluator.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum EvaluationStep {
-    Target,
-    Expression,
-    CalculationEntry,
-    PropertyBinding,
-    ListElement,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum NumericOperation {
-    ParseWire,
-    ParseLiteral,
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Compare,
-    Negate,
-    Absolute,
-    Reciprocal,
-    Power,
-    KindAssertion,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum WorkResource {
-    DynamicEvents,
-    NumericUnits,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum WorkSite {
-    Evaluation(EvaluationStep),
-    Numeric(NumericOperation),
-}
-
-/// Failed reservations consume no partial charge. The first failure is latched.
-#[derive(Debug, Clone, PartialEq, Eq, Error, Serialize, Deserialize)]
-#[error("{resource:?}: used {used}, requested {requested}, limit {limit}, at {site:?}")]
-pub struct WorkExhaustion {
-    pub resource: WorkResource,
-    pub used: u64,
-    pub requested: u64,
-    pub limit: u64,
-    pub site: WorkSite,
-}
-
-/// Provisional calibration ceilings, not measured execution-time guarantees.
-///
-/// Effective limits, profile identity, capture, targets and context must all be
-/// recorded in request/result/frozen identity. A caller may lower these ceilings.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(try_from = "WorkLimitsWire", into = "WorkLimitsWire")]
-pub struct WorkLimits {
-    dynamic_events: u64,
-    numeric_units: u64,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-struct WorkLimitsWire {
-    dynamic_events: u64,
-    numeric_units: u64,
-}
-
-impl WorkLimits {
-    pub const REFERENCE: Self = Self {
-        dynamic_events: 1_000_000,
-        numeric_units: 50_000_000,
-    };
-
-    pub fn new(dynamic_events: u64, numeric_units: u64) -> Result<Self, NumericError> {
-        if dynamic_events > Self::REFERENCE.dynamic_events
-            || numeric_units > Self::REFERENCE.numeric_units
-        {
-            return Err(NumericError::InvalidWorkLimits);
-        }
-        Ok(Self {
-            dynamic_events,
-            numeric_units,
-        })
-    }
-
-    pub fn dynamic_events(self) -> u64 {
-        self.dynamic_events
-    }
-
-    pub fn numeric_units(self) -> u64 {
-        self.numeric_units
-    }
-}
-
-impl TryFrom<WorkLimitsWire> for WorkLimits {
-    type Error = NumericError;
-
-    fn try_from(value: WorkLimitsWire) -> Result<Self, Self::Error> {
-        Self::new(value.dynamic_events, value.numeric_units)
-    }
-}
-
-impl From<WorkLimits> for WorkLimitsWire {
-    fn from(value: WorkLimits) -> Self {
-        Self {
-            dynamic_events: value.dynamic_events,
-            numeric_units: value.numeric_units,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct WorkUsage {
-    pub dynamic_events: u64,
-    pub numeric_units: u64,
-}
-
-/// Intentionally neither Clone nor Default: pass the same mutable meter through
-/// every target, numeric operation and expanded call in one evaluation request.
-///
-/// Exhaustion is terminal. Integrators must stop traversing siblings/targets and
-/// mark already collected causes as incomplete. Replaying an aggregate cache
-/// cost is insufficient if it changes the exact exhaustion location; initially
-/// retain logical traversal even when numerical values come from a cache.
-#[derive(Debug)]
-pub struct WorkMeter {
-    limits: WorkLimits,
-    usage: WorkUsage,
-    exhausted: Option<WorkExhaustion>,
-}
-
-impl WorkMeter {
-    pub fn new(limits: WorkLimits) -> Self {
-        Self {
-            limits,
-            usage: WorkUsage::default(),
-            exhausted: None,
-        }
-    }
-
-    pub fn limits(&self) -> WorkLimits {
-        self.limits
-    }
-
-    pub fn usage(&self) -> WorkUsage {
-        self.usage
-    }
-
-    pub fn exhaustion(&self) -> Option<&WorkExhaustion> {
-        self.exhausted.as_ref()
-    }
-
-    pub fn ensure_active(&self) -> Result<(), NumericError> {
-        match &self.exhausted {
-            Some(failure) => Err(NumericError::Limit(NumericLimit::Work(failure.clone()))),
-            None => Ok(()),
-        }
-    }
-
-    pub fn visit(&mut self, step: EvaluationStep) -> Result<(), NumericError> {
-        self.reserve(WorkResource::DynamicEvents, 1, WorkSite::Evaluation(step))
-    }
-
-    pub(super) fn numeric(
-        &mut self,
-        operation: NumericOperation,
-        units: u64,
-    ) -> Result<(), NumericError> {
-        self.reserve(
-            WorkResource::NumericUnits,
-            units,
-            WorkSite::Numeric(operation),
-        )
-    }
-
-    fn reserve(
-        &mut self,
-        resource: WorkResource,
-        requested: u64,
-        site: WorkSite,
-    ) -> Result<(), NumericError> {
-        self.ensure_active()?;
-        let (used, limit) = match resource {
-            WorkResource::DynamicEvents => (self.usage.dynamic_events, self.limits.dynamic_events),
-            WorkResource::NumericUnits => (self.usage.numeric_units, self.limits.numeric_units),
-        };
-        // Subtraction is safe: only successful reservations update usage.
-        if requested > limit - used {
-            let failure = WorkExhaustion {
-                resource,
-                used,
-                requested,
-                limit,
-                site,
-            };
-            self.exhausted = Some(failure.clone());
-            return Err(NumericError::Limit(NumericLimit::Work(failure)));
-        }
-        match resource {
-            WorkResource::DynamicEvents => self.usage.dynamic_events += requested,
-            WorkResource::NumericUnits => self.usage.numeric_units += requested,
-        }
-        Ok(())
-    }
-}
-
-// Logical 64-bit words are platform independent. These are deterministic
-// accounting weights, not a claim about num-bigint's internal algorithm/timing.
-pub(super) fn words(bits: u64) -> u64 {
-    bits.max(1).div_ceil(64)
-}
-
-pub(super) fn product_cost(a_bits: u64, b_bits: u64) -> u64 {
-    1 + words(a_bits) * words(b_bits)
-}
-
-pub(super) fn sum_cost(a_bits: u64, b_bits: u64) -> u64 {
-    1 + words(a_bits.max(b_bits))
-}
-
-pub(super) fn normalization_cost(n_bits: u64, d_bits: u64) -> u64 {
-    let width = words(n_bits.max(d_bits));
-    // 64*w² for GCD plus 2*w² for the two quotient operations.
-    1 + 66 * width * width
-}
-
-pub(super) fn parse_cost(digits: usize, estimated_bits: u64) -> u64 {
-    1 + digits as u64 * words(estimated_bits)
-}

crates/oa-core/src/analysis_numeric/quantity.rs

@@ -1,378 +0,0 @@
-use super::{Dimension, Exact, MAX_INTEGER_POWER, NumericError, NumericOperation, WorkMeter};
-use std::cmp::Ordering;
-
-/// K is supplied by the common resolver's verified nominal compatibility
-/// relation. It is not inferred from dimension/name/symbol/archive bytes here.
-/// Coordinate basis/algebra/difference-kind closure must be part of that proof.
-/// Exact definition references and pins remain the caller's provenance.
-/// K must be a bounded, cheap-to-clone/compare verified handle. Constructing or
-/// comparing an unbounded rooted contract graph is resolver admission work and
-/// must not be hidden inside K's Clone/Eq implementations. Rust trait bounds do
-/// not enforce this resource contract.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ResolvedKind<K> {
-    key: K,
-    dimension: Dimension,
-    difference: Option<K>,
-}
-
-impl<K> ResolvedKind<K> {
-    pub fn linear(key: K, dimension: Dimension) -> Self {
-        Self {
-            key,
-            dimension,
-            difference: None,
-        }
-    }
-
-    pub fn key(&self) -> &K {
-        &self.key
-    }
-
-    pub fn dimension(&self) -> Dimension {
-        self.dimension
-    }
-
-    pub fn is_affine(&self) -> bool {
-        self.difference.is_some()
-    }
-}
-
-impl<K: Clone + Eq> ResolvedKind<K> {
-    pub fn affine(key: K, difference: &Self) -> Result<Self, NumericError> {
-        if difference.is_affine() || key == difference.key {
-            return Err(NumericError::DifferenceKind);
-        }
-        Ok(Self {
-            key,
-            dimension: difference.dimension,
-            difference: Some(difference.key.clone()),
-        })
-    }
-
-    pub fn difference_kind(&self) -> Option<Self> {
-        self.difference
-            .as_ref()
-            .map(|key| Self::linear(key.clone(), self.dimension))
-    }
-}
-
-/// Canonical coordinate = magnitude * scale + offset.
-/// Unit symbols and display preferences are outside this numeric representation.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Unit<K> {
-    kind: ResolvedKind<K>,
-    scale: Exact,
-    offset: Exact,
-}
-
-impl<K: Clone + Eq> Unit<K> {
-    pub fn new(kind: ResolvedKind<K>, scale: Exact, offset: Exact) -> Result<Self, NumericError> {
-        if !scale.is_positive() {
-            return Err(NumericError::UnitScale);
-        }
-        if !kind.is_affine() && !offset.is_zero() {
-            return Err(NumericError::LinearOffset);
-        }
-        Ok(Self {
-            kind,
-            scale,
-            offset,
-        })
-    }
-
-    pub fn kind(&self) -> &ResolvedKind<K> {
-        &self.kind
-    }
-
-    pub fn scale(&self) -> &Exact {
-        &self.scale
-    }
-
-    pub fn offset(&self) -> &Exact {
-        &self.offset
-    }
-
-    /// Fixed multiply-then-add path. Each reduced arithmetic stage is bounded.
-    /// A mathematically cancelling wider intermediate still reports NumericLimit;
-    /// replacing this path with a fused operation requires a new work profile.
-    pub fn to_canonical(
-        &self,
-        magnitude: &Exact,
-        meter: &mut WorkMeter,
-    ) -> Result<Exact, NumericError> {
-        magnitude
-            .multiply(&self.scale, meter)?
-            .add(&self.offset, meter)
-    }
-
-    /// Fixed subtract-then-divide path; never rounds a coordinate.
-    pub fn from_canonical(
-        &self,
-        coordinate: &Exact,
-        meter: &mut WorkMeter,
-    ) -> Result<Exact, NumericError> {
-        coordinate
-            .subtract(&self.offset, meter)?
-            .divide(&self.scale, meter)
-    }
-
-    pub fn convert(
-        &self,
-        magnitude: &Exact,
-        target: &Self,
-        meter: &mut WorkMeter,
-    ) -> Result<Exact, NumericError> {
-        meter.ensure_active()?;
-        if self.kind != target.kind {
-            return Err(NumericError::IncompatibleTypes);
-        }
-        target.from_canonical(&self.to_canonical(magnitude, meter)?, meter)
-    }
-}
-
-/// Internal numerical types. Boolean/list/check semantics belong to the common
-/// expression evaluator. Anonymous zero dimension normalizes to Number.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum NumericType<K> {
-    Number,
-    Named(ResolvedKind<K>),
-    Anonymous(Dimension),
-}
-
-impl<K> NumericType<K> {
-    pub fn dimension(&self) -> Dimension {
-        match self {
-            Self::Number => Dimension::ZERO,
-            Self::Named(kind) => kind.dimension,
-            Self::Anonymous(dimension) => *dimension,
-        }
-    }
-
-    pub fn is_affine(&self) -> bool {
-        matches!(self, Self::Named(kind) if kind.is_affine())
-    }
-
-    fn anonymous(dimension: Dimension) -> Self {
-        if dimension.is_dimensionless() {
-            Self::Number
-        } else {
-            Self::Anonymous(dimension)
-        }
-    }
-
-    fn normalized(self) -> Self {
-        match self {
-            Self::Anonymous(dimension) => Self::anonymous(dimension),
-            other => other,
-        }
-    }
-}
-
-/// A canonical rational coordinate with an internal numerical type.
-///
-/// Derived Eq compares stored representation. Formal equality/ordering must call
-/// compare(), which rejects mismatched nominal kinds instead of treating them
-/// as a false predicate. Public property output must still check its declared
-/// type and anchor the result to that declaration's exact definition reference.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NumericValue<K> {
-    value_type: NumericType<K>,
-    coordinate: Exact,
-}
-
-impl<K: Clone + Eq> NumericValue<K> {
-    pub fn new(value_type: NumericType<K>, coordinate: Exact) -> Self {
-        Self {
-            value_type: value_type.normalized(),
-            coordinate,
-        }
-    }
-
-    pub fn number(coordinate: Exact) -> Self {
-        Self::new(NumericType::Number, coordinate)
-    }
-
-    pub fn from_unit(
-        magnitude: &Exact,
-        unit: &Unit<K>,
-        meter: &mut WorkMeter,
-    ) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        Ok(Self::new(
-            NumericType::Named(unit.kind.clone()),
-            unit.to_canonical(magnitude, meter)?,
-        ))
-    }
-
-    pub fn value_type(&self) -> &NumericType<K> {
-        &self.value_type
-    }
-
-    pub fn coordinate(&self) -> &Exact {
-        &self.coordinate
-    }
-
-    pub fn display_in(&self, unit: &Unit<K>, meter: &mut WorkMeter) -> Result<Exact, NumericError> {
-        meter.ensure_active()?;
-        if !matches!(&self.value_type, NumericType::Named(kind) if kind == &unit.kind) {
-            return Err(NumericError::IncompatibleTypes);
-        }
-        unit.from_canonical(&self.coordinate, meter)
-    }
-
-    pub fn add(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        let output = self.additive_type(rhs, false)?;
-        Ok(Self::new(
-            output,
-            self.coordinate.add(&rhs.coordinate, meter)?,
-        ))
-    }
-
-    pub fn subtract(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        let output = self.additive_type(rhs, true)?;
-        Ok(Self::new(
-            output,
-            self.coordinate.subtract(&rhs.coordinate, meter)?,
-        ))
-    }
-
-    fn additive_type(&self, rhs: &Self, subtract: bool) -> Result<NumericType<K>, NumericError> {
-        use NumericType::{Anonymous, Named, Number};
-        match (&self.value_type, &rhs.value_type) {
-            (Number, Number) => Ok(Number),
-            (Anonymous(left), Anonymous(right)) if left == right => Ok(Anonymous(*left)),
-            (Named(left), Named(right)) => match (&left.difference, &right.difference) {
-                (None, None) if left == right => Ok(Named(left.clone())),
-                (Some(difference), Some(_)) if subtract && left == right => Ok(Named(
-                    ResolvedKind::linear(difference.clone(), left.dimension),
-                )),
-                (Some(difference), None)
-                    if difference == &right.key && left.dimension == right.dimension =>
-                {
-                    Ok(Named(left.clone()))
-                }
-                (None, Some(difference))
-                    if !subtract
-                        && difference == &left.key
-                        && left.dimension == right.dimension =>
-                {
-                    Ok(Named(right.clone()))
-                }
-                _ => Err(NumericError::IncompatibleTypes),
-            },
-            _ => Err(NumericError::IncompatibleTypes),
-        }
-    }
-
-    pub fn multiply(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        let output = self.multiplicative_type(rhs, false)?;
-        Ok(Self::new(
-            output,
-            self.coordinate.multiply(&rhs.coordinate, meter)?,
-        ))
-    }
-
-    pub fn divide(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        let output = self.multiplicative_type(rhs, true)?;
-        Ok(Self::new(
-            output,
-            self.coordinate.divide(&rhs.coordinate, meter)?,
-        ))
-    }
-
-    fn multiplicative_type(
-        &self,
-        rhs: &Self,
-        divide: bool,
-    ) -> Result<NumericType<K>, NumericError> {
-        use NumericType::Number;
-        if self.value_type.is_affine() || rhs.value_type.is_affine() {
-            return Err(NumericError::AffineOperation);
-        }
-        match (&self.value_type, &rhs.value_type) {
-            (Number, Number) => Ok(Number),
-            (_, Number) => Ok(self.value_type.clone()),
-            (Number, _) if !divide => Ok(rhs.value_type.clone()),
-            _ => {
-                let left = self.value_type.dimension();
-                let right = rhs.value_type.dimension();
-                let dimension = if divide {
-                    left.checked_quotient(right)?
-                } else {
-                    left.checked_product(right)?
-                };
-                Ok(NumericType::anonymous(dimension))
-            }
-        }
-    }
-
-    pub fn negated(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        if self.value_type.is_affine() {
-            return Err(NumericError::AffineOperation);
-        }
-        Ok(Self::new(
-            self.value_type.clone(),
-            self.coordinate.negated(meter)?,
-        ))
-    }
-
-    pub fn absolute(&self, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        if self.value_type.is_affine() {
-            return Err(NumericError::AffineOperation);
-        }
-        Ok(Self::new(
-            self.value_type.clone(),
-            self.coordinate.absolute(meter)?,
-        ))
-    }
-
-    pub fn power(&self, exponent: i8, meter: &mut WorkMeter) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        if !(-MAX_INTEGER_POWER..=MAX_INTEGER_POWER).contains(&exponent) {
-            return Err(NumericError::IntegerPower);
-        }
-        if self.value_type.is_affine() {
-            return Err(NumericError::AffineOperation);
-        }
-        let output = match exponent {
-            0 => NumericType::Number,
-            1 => self.value_type.clone(),
-            _ => NumericType::anonymous(self.value_type.dimension().checked_power(exponent)?),
-        };
-        Ok(Self::new(output, self.coordinate.power(exponent, meter)?))
-    }
-
-    pub fn compare(&self, rhs: &Self, meter: &mut WorkMeter) -> Result<Ordering, NumericError> {
-        meter.ensure_active()?;
-        if self.value_type != rhs.value_type {
-            return Err(NumericError::IncompatibleTypes);
-        }
-        self.coordinate.compare(&rhs.coordinate, meter)
-    }
-
-    pub fn as_kind(
-        &self,
-        target: &ResolvedKind<K>,
-        meter: &mut WorkMeter,
-    ) -> Result<Self, NumericError> {
-        meter.ensure_active()?;
-        if target.is_affine()
-            || matches!(self.value_type, NumericType::Named(_))
-            || self.value_type.dimension() != target.dimension
-        {
-            return Err(NumericError::KindAssertion);
-        }
-        meter.numeric(NumericOperation::KindAssertion, self.coordinate.copy_cost())?;
-        Ok(Self::new(
-            NumericType::Named(target.clone()),
-            self.coordinate.clone(),
-        ))
-    }
-}

crates/oa-core/src/analysis_numeric/tests.rs

@@ -1,804 +0,0 @@
-use super::*;
-use num_bigint::BigInt;
-use num_traits::One;
-use std::cmp::Ordering;
-
-fn meter() -> WorkMeter {
-    WorkMeter::new(WorkLimits::REFERENCE)
-}
-
-fn exact(n: impl ToString, d: impl ToString) -> Exact {
-    Exact::from_wire(
-        &ExactWire {
-            numerator: n.to_string(),
-            denominator: d.to_string(),
-        },
-        &mut meter(),
-    )
-    .unwrap()
-}
-
-fn source(text: &str) -> Exact {
-    Exact::parse_literal(text, &mut meter()).unwrap()
-}
-
-fn assert_fraction(value: &Exact, n: impl ToString, d: impl ToString) {
-    assert_eq!(
-        value.to_wire(),
-        ExactWire {
-            numerator: n.to_string(),
-            denominator: d.to_string(),
-        }
-    );
-}
-
-// Independent bounded i128 oracle. It does not call the production Exact/GCD
-// implementation when deriving expected arithmetic or ordering.
-fn small_fraction(mut n: i128, mut d: i128) -> (i128, i128) {
-    assert_ne!(d, 0);
-    if d < 0 {
-        n = -n;
-        d = -d;
-    }
-    let (mut a, mut b) = (n.abs(), d);
-    while b != 0 {
-        (a, b) = (b, a % b);
-    }
-    (n / a, d / a)
-}
-
-#[test]
-fn arithmetic_matches_independent_small_integer_oracle() {
-    for a in [-5_i128, -2, 0, 1, 4] {
-        for b in [1_i128, 2, 3, 7] {
-            for c in [-5_i128, -2, 0, 1, 4] {
-                for d in [1_i128, 2, 3, 7] {
-                    let (an, ad) = small_fraction(a, b);
-                    let (bn, bd) = small_fraction(c, d);
-                    let left = exact(an, ad);
-                    let right = exact(bn, bd);
-                    let mut work = meter();
-                    let (n, den) = small_fraction(a * d + c * b, b * d);
-                    assert_fraction(&left.add(&right, &mut work).unwrap(), n, den);
-                    let (n, den) = small_fraction(a * d - c * b, b * d);
-                    assert_fraction(&left.subtract(&right, &mut work).unwrap(), n, den);
-                    let (n, den) = small_fraction(a * c, b * d);
-                    assert_fraction(&left.multiply(&right, &mut work).unwrap(), n, den);
-                    if c != 0 {
-                        let (n, den) = small_fraction(a * d, b * c);
-                        assert_fraction(&left.divide(&right, &mut work).unwrap(), n, den);
-                    } else {
-                        assert_eq!(
-                            left.divide(&right, &mut work),
-                            Err(NumericError::DivisionByZero)
-                        );
-                    }
-                    assert_eq!(
-                        left.compare(&right, &mut work).unwrap(),
-                        (a * d).cmp(&(c * b))
-                    );
-                }
-            }
-        }
-    }
-}
-
-#[test]
-fn decimals_are_exact_and_source_ratios_reduce() {
-    assert_fraction(
-        &source("0.1").add(&source("0.2"), &mut meter()).unwrap(),
-        3,
-        10,
-    );
-    assert_fraction(&source("0.50"), 1, 2);
-    assert_fraction(&source("12.50e-2"), 1, 8);
-    assert_fraction(&source("1e+3"), 1000, 1);
-    assert_fraction(&source("0001.2500"), 5, 4);
-    assert_fraction(&source(" ratio( -6, 8 ) "), -3, 4);
-    assert_fraction(&source("ratio(-0, 27)"), 0, 1);
-    assert_eq!(source("0.5").canonical_literal(), "ratio(1, 2)");
-    assert_eq!(source("42").canonical_literal(), "42");
-}
-
-#[test]
-fn powers_and_signs_have_explicit_domains() {
-    let x = exact(-2, 3);
-    assert_fraction(&x.power(3, &mut meter()).unwrap(), -8, 27);
-    assert_fraction(&x.power(-3, &mut meter()).unwrap(), -27, 8);
-    assert_fraction(&x.power(0, &mut meter()).unwrap(), 1, 1);
-    assert_fraction(&x.absolute(&mut meter()).unwrap(), 2, 3);
-    assert_fraction(&x.negated(&mut meter()).unwrap(), 2, 3);
-    assert_fraction(&x.reciprocal(&mut meter()).unwrap(), -3, 2);
-    let zero = Exact::from_integer(0);
-    assert_eq!(
-        zero.power(0, &mut meter()),
-        Err(NumericError::ZeroPowerZero)
-    );
-    assert_eq!(
-        zero.power(-1, &mut meter()),
-        Err(NumericError::DivisionByZero)
-    );
-    assert_eq!(x.power(17, &mut meter()), Err(NumericError::IntegerPower));
-    assert_eq!(
-        x.power(i8::MIN, &mut meter()),
-        Err(NumericError::IntegerPower)
-    );
-}
-
-#[test]
-fn canonical_wire_rejects_both_component_noncanonical_forms() {
-    for (n, d) in [
-        ("+1", "1"),
-        ("01", "1"),
-        ("-0", "1"),
-        ("1", "+1"),
-        ("1", "-1"),
-        ("1", "01"),
-        ("2", "4"),
-        ("0", "3"),
-        ("", "1"),
-        ("1", ""),
-        ("1.0", "1"),
-        ("1", "1.0"),
-        ("1e1", "1"),
-        ("1", "1e1"),
-        (" 1", "1"),
-        ("1", "1 "),
-    ] {
-        assert!(
-            Exact::from_wire(
-                &ExactWire {
-                    numerator: n.into(),
-                    denominator: d.into()
-                },
-                &mut meter(),
-            )
-            .is_err(),
-            "accepted {n}/{d}"
-        );
-    }
-    assert_eq!(
-        Exact::from_wire(
-            &ExactWire {
-                numerator: "1".into(),
-                denominator: "0".into()
-            },
-            &mut meter()
-        ),
-        Err(NumericError::ZeroDenominator)
-    );
-    assert_fraction(&exact(0, 1), 0, 1);
-    assert_fraction(&exact(-1, 2), -1, 2);
-}
-
-#[test]
-fn serde_uses_closed_canonical_string_wire() {
-    let value = exact(-3, 7);
-    let encoded = serde_json::to_value(&value).unwrap();
-    assert_eq!(
-        encoded,
-        serde_json::json!({"numerator":"-3","denominator":"7"})
-    );
-    assert_eq!(serde_json::from_value::<Exact>(encoded).unwrap(), value);
-    for invalid in [
-        r#"{"numerator":1,"denominator":"2"}"#,
-        r#"{"numerator":"1","denominator":2}"#,
-        r#"{"numerator":"1","denominator":"2","other":0}"#,
-        r#"{"numerator":"1","numerator":"2","denominator":"3"}"#,
-        r#"{"numerator":"1"}"#,
-        r#"{"numerator":"2","denominator":"4"}"#,
-    ] {
-        assert!(serde_json::from_str::<Exact>(invalid).is_err(), "{invalid}");
-    }
-}
-
-#[test]
-fn literal_reader_does_not_fold_expression_unary_minus() {
-    assert_eq!(
-        Exact::parse_literal("-2", &mut meter()),
-        Err(NumericError::InvalidLiteral)
-    );
-    let negative_literal = source("ratio(-2, 1)");
-    assert_eq!(negative_literal.canonical_literal(), "ratio(-2, 1)");
-    assert_eq!(source("2").negated(&mut meter()).unwrap(), negative_literal);
-    // Equality of coordinates does not claim AST equality. The expression
-    // parser must preserve UnaryNegate independently of its operand literal.
-    assert_eq!(source("2").canonical_literal(), "2");
-}
-
-#[test]
-fn literal_syntax_and_decimal_exponent_are_bounded() {
-    for invalid in [
-        "",
-        "-",
-        "+1",
-        ".5",
-        "1.",
-        "1.2.3",
-        "1e",
-        "1ee2",
-        "1e+-2",
-        "1_000",
-        "NaN",
-        "Infinity",
-        "1/2",
-        "ratio(1)",
-        "ratio(1,2,3)",
-        "ratio(1,-2)",
-        "ratio(+1,2)",
-        "ratio(1,2) + 1",
-        "１２",
-    ] {
-        assert!(
-            Exact::parse_literal(invalid, &mut meter()).is_err(),
-            "{invalid}"
-        );
-    }
-    for invalid in ["1e129", "1e-129", "1e9999999999999999999999"] {
-        assert_eq!(
-            Exact::parse_literal(invalid, &mut meter()),
-            Err(NumericError::DecimalExponent)
-        );
-    }
-    assert!(Exact::parse_literal("1e128", &mut meter()).is_ok());
-    assert!(Exact::parse_literal("1e-128", &mut meter()).is_ok());
-    assert_eq!(
-        Exact::parse_literal(&"1".repeat(MAX_COMPONENT_DIGITS + 1), &mut meter()),
-        Err(NumericError::LiteralTooLong)
-    );
-    assert_eq!(
-        Exact::parse_literal(&" ".repeat(MAX_LITERAL_BYTES + 1), &mut meter()),
-        Err(NumericError::LiteralTooLong)
-    );
-}
-
-#[test]
-fn full_independent_r7_packets_round_trip_as_literals_and_wire() {
-    let packets: serde_json::Value =
-        serde_json::from_str(include_str!("fixtures/r7-literal-boundaries.json")).unwrap();
-    for packet in packets.as_array().unwrap() {
-        let wire: ExactWire =
-            serde_json::from_value(packet["expression"]["Number"].clone()).unwrap();
-        let expected = Exact::from_wire(&wire, &mut meter()).unwrap();
-        let spelling = packet["canonical_source"].as_str().unwrap();
-        assert_eq!(expected.canonical_literal(), spelling);
-        assert_eq!(
-            Exact::parse_literal(spelling, &mut meter()).unwrap(),
-            expected
-        );
-        let serialized = serde_json::to_string(&expected).unwrap();
-        assert_eq!(
-            serde_json::from_str::<Exact>(&serialized).unwrap(),
-            expected
-        );
-        assert_eq!(expected.to_wire(), wire);
-    }
-}
-
-#[test]
-fn full_8193_bit_sum_intermediate_can_reduce_to_admitted_value() {
-    // N=(2^4096)-1, D=N-1. gcd(N,D)=1 and D is even.
-    // N/D + N/D = N/(D/2), although its un-reduced numerator needs 8193 bits.
-    let n = (BigInt::one() << 4096_usize) - 1_u8;
-    let d = &n - 1_u8;
-    let value = exact(&n, &d);
-    let result = value.add(&value, &mut meter()).unwrap();
-    assert_fraction(&result, &n, &d / 2_u8);
-}
-
-#[test]
-fn cross_products_cancel_before_reduced_component_limit() {
-    let n = BigInt::one() << 4095_usize;
-    let d = &n - 1_u8;
-    let left = exact(&n, &d);
-    let right = exact(&d, &n);
-    assert_fraction(&left.multiply(&right, &mut meter()).unwrap(), 1, 1);
-    assert_fraction(
-        &left
-            .add(&left.negated(&mut meter()).unwrap(), &mut meter())
-            .unwrap(),
-        0,
-        1,
-    );
-}
-
-#[test]
-fn both_reduced_component_overflows_are_reported() {
-    let n = BigInt::one() << 4095_usize;
-    let mut work = meter();
-    let failure = exact(&n, 1)
-        .multiply(&Exact::from_integer(2), &mut work)
-        .unwrap_err();
-    assert!(matches!(
-        failure,
-        NumericError::Limit(NumericLimit::Bits {
-            component: NumberComponent::Numerator,
-            bits: 4097,
-            ..
-        })
-    ));
-    assert!(work.exhaustion().is_none());
-    let failure = exact(1, &n)
-        .divide(&Exact::from_integer(2), &mut work)
-        .unwrap_err();
-    assert!(matches!(
-        failure,
-        NumericError::Limit(NumericLimit::Bits {
-            component: NumberComponent::Denominator,
-            bits: 4097,
-            ..
-        })
-    ));
-    // Value overflow is a nonterminal supported-operation failure; fuel
-    // exhaustion, in contrast, terminates the entire request.
-    assert_fraction(&source("1").add(&source("1"), &mut work).unwrap(), 2, 1);
-}
-
-#[test]
-fn wire_rejects_4097_bits_before_gcd_can_reduce_them() {
-    let oversized = (BigInt::one() << 4096_usize).to_string();
-    for wire in [
-        ExactWire {
-            numerator: oversized.clone(),
-            denominator: "1".into(),
-        },
-        ExactWire {
-            numerator: "1".into(),
-            denominator: oversized.clone(),
-        },
-        ExactWire {
-            numerator: oversized.clone(),
-            denominator: oversized,
-        },
-    ] {
-        assert!(matches!(
-            Exact::from_wire(&wire, &mut meter()),
-            Err(NumericError::Limit(NumericLimit::Bits { stage, .. })) if stage == "wire"
-        ));
-    }
-}
-
-#[test]
-fn numeric_precharge_precedes_big_integer_result_allocation() {
-    let n = BigInt::one() << 4095_usize;
-    let left = exact(&n, 1);
-    let mut work = WorkMeter::new(WorkLimits::new(10, 0).unwrap());
-    let failure = left
-        .multiply(&Exact::from_integer(2), &mut work)
-        .unwrap_err();
-    assert!(failure.is_terminal_work_exhaustion());
-    assert_eq!(work.usage().numeric_units, 0);
-    assert!(matches!(
-        work.exhaustion().unwrap().site,
-        WorkSite::Numeric(NumericOperation::Multiply)
-    ));
-    // With available fuel the same operation reaches the 4097-bit result check.
-    assert!(matches!(
-        left.multiply(&Exact::from_integer(2), &mut meter()),
-        Err(NumericError::Limit(NumericLimit::Bits { .. }))
-    ));
-    let too_wide_wire = ExactWire {
-        numerator: (BigInt::one() << 4096_usize).to_string(),
-        denominator: "1".into(),
-    };
-    let mut parse_work = WorkMeter::new(WorkLimits::new(0, 0).unwrap());
-    assert!(
-        Exact::from_wire(&too_wide_wire, &mut parse_work)
-            .unwrap_err()
-            .is_terminal_work_exhaustion()
-    );
-}
-
-#[test]
-fn provisional_limits_and_effective_limits_round_trip() {
-    let limits = WorkLimits::new(500, 2000).unwrap();
-    let encoded = serde_json::to_value(limits).unwrap();
-    assert_eq!(
-        encoded,
-        serde_json::json!({"dynamic_events":500,"numeric_units":2000})
-    );
-    assert_eq!(
-        serde_json::from_value::<WorkLimits>(encoded).unwrap(),
-        limits
-    );
-    assert_eq!(
-        WorkLimits::new(1_000_001, 0),
-        Err(NumericError::InvalidWorkLimits)
-    );
-    assert_eq!(
-        WorkLimits::new(0, 50_000_001),
-        Err(NumericError::InvalidWorkLimits)
-    );
-    assert!(
-        serde_json::from_str::<WorkLimits>(r#"{"dynamic_events":1000001,"numeric_units":0}"#)
-            .is_err()
-    );
-}
-
-#[test]
-fn exact_accounting_boundary_and_terminal_failure_are_stable() {
-    // One-word addition: three products at 2, one sum at 2,
-    // normalization at 67 => 75 logical numeric units.
-    let mut work = WorkMeter::new(WorkLimits::new(4, 75).unwrap());
-    assert_fraction(&exact(1, 2).add(&exact(1, 3), &mut work).unwrap(), 5, 6);
-    assert_eq!(work.usage().numeric_units, 75);
-    assert!(work.exhaustion().is_none());
-    let first = Exact::from_integer(1).negated(&mut work).unwrap_err();
-    let at_failure = work.usage();
-    assert_eq!(
-        work.exhaustion().unwrap(),
-        &WorkExhaustion {
-            resource: WorkResource::NumericUnits,
-            used: 75,
-            requested: 3,
-            limit: 75,
-            site: WorkSite::Numeric(NumericOperation::Negate),
-        }
-    );
-    assert_eq!(work.visit(EvaluationStep::Target).unwrap_err(), first);
-    assert_eq!(
-        Exact::from_integer(1)
-            .divide(&Exact::from_integer(0), &mut work)
-            .unwrap_err(),
-        first
-    );
-    assert_eq!(
-        work.numeric(NumericOperation::Compare, 0).unwrap_err(),
-        first
-    );
-    assert_eq!(work.usage(), at_failure);
-}
-
-#[test]
-fn zero_cost_and_maximum_reservation_do_not_underflow_or_reactivate() {
-    let mut work = WorkMeter::new(WorkLimits::new(0, 0).unwrap());
-    work.numeric(NumericOperation::Compare, 0).unwrap();
-    let failure = work
-        .numeric(NumericOperation::Multiply, u64::MAX)
-        .unwrap_err();
-    assert!(failure.is_terminal_work_exhaustion());
-    assert_eq!(work.usage(), WorkUsage::default());
-    assert_eq!(
-        work.numeric(NumericOperation::Compare, 0).unwrap_err(),
-        failure
-    );
-    let mut dynamic = WorkMeter::new(WorkLimits::new(0, 5).unwrap());
-    assert!(dynamic.visit(EvaluationStep::Target).is_err());
-    assert_eq!(dynamic.usage(), WorkUsage::default());
-}
-
-#[test]
-fn multiple_targets_share_one_aggregate_meter() {
-    let mut work = WorkMeter::new(WorkLimits::new(3, 50).unwrap());
-    work.visit(EvaluationStep::Target).unwrap();
-    work.visit(EvaluationStep::Expression).unwrap();
-    work.visit(EvaluationStep::Target).unwrap();
-    let failure = work.visit(EvaluationStep::Expression).unwrap_err();
-    assert!(failure.is_terminal_work_exhaustion());
-    assert_eq!(work.usage().dynamic_events, 3);
-}
-
-// A direct bounded call-tree workload, not an expression interpreter/dialect.
-fn expanded_calls(
-    depth: u8,
-    x: u64,
-    work: &mut WorkMeter,
-    entered: &mut u64,
-) -> Result<u64, NumericError> {
-    work.visit(EvaluationStep::CalculationEntry)?;
-    *entered += 1;
-    if depth == 0 {
-        return Ok(x);
-    }
-    let left = expanded_calls(depth - 1, 2 * x, work, entered)?;
-    let right = expanded_calls(depth - 1, 2 * x + 1, work, entered)?;
-    Ok(left + right)
-}
-
-#[test]
-fn c1_expanded_call_witness_terminates_at_dynamic_limit() {
-    let mut work = WorkMeter::new(WorkLimits::new(10_000, 0).unwrap());
-    let mut entered = 0;
-    let failure = expanded_calls(30, 0, &mut work, &mut entered).unwrap_err();
-    assert!(failure.is_terminal_work_exhaustion());
-    assert_eq!(entered, 10_000);
-    assert_eq!(work.usage().dynamic_events, 10_000);
-    assert_eq!(
-        work.exhaustion().unwrap().site,
-        WorkSite::Evaluation(EvaluationStep::CalculationEntry)
-    );
-    // Nearby finite control: 63 invocations, leaves 0..31, sum 496.
-    let mut bounded = WorkMeter::new(WorkLimits::new(63, 0).unwrap());
-    let mut entered = 0;
-    assert_eq!(
-        expanded_calls(5, 0, &mut bounded, &mut entered).unwrap(),
-        496
-    );
-    assert_eq!(entered, 63);
-    assert!(bounded.exhaustion().is_none());
-}
-
-fn dim(value: [i16; 7]) -> Dimension {
-    Dimension::new(value).unwrap()
-}
-
-fn linear(key: &str, dimension: Dimension) -> ResolvedKind<String> {
-    ResolvedKind::linear(key.to_owned(), dimension)
-}
-
-fn named(n: i64, kind: &ResolvedKind<String>) -> NumericValue<String> {
-    NumericValue::new(NumericType::Named(kind.clone()), Exact::from_integer(n))
-}
-
-#[test]
-fn dimensions_use_checked_seven_axis_integer_algebra() {
-    let length = dim([1, 0, 0, 0, 0, 0, 0]);
-    let mass = dim([0, 1, 0, 0, 0, 0, 0]);
-    let time = dim([0, 0, 1, 0, 0, 0, 0]);
-    assert_eq!(
-        mass.checked_product(length)
-            .unwrap()
-            .checked_quotient(time.checked_power(2).unwrap())
-            .unwrap(),
-        dim([1, 1, -2, 0, 0, 0, 0])
-    );
-    assert!(time.checked_quotient(time).unwrap().is_dimensionless());
-    assert!(matches!(
-        dim([32, 0, 0, 0, 0, 0, 0]).checked_product(length),
-        Err(NumericError::DimensionExponent {
-            axis: DimensionAxis::Length,
-            value: 33
-        })
-    ));
-    assert!(dim([0, 0, -32, 0, 0, 0, 0]).checked_quotient(time).is_err());
-    assert!(length.checked_power(i8::MIN).is_err());
-    assert!(Dimension::new([33, 0, 0, 0, 0, 0, 0]).is_err());
-    assert_eq!(
-        serde_json::to_value(time).unwrap(),
-        serde_json::json!([0, 0, 1, 0, 0, 0, 0])
-    );
-    for invalid in ["[0,0,33,0,0,0,0]", "[0,0,1]", "[0,0,1,0,0,0,0,0]"] {
-        assert!(serde_json::from_str::<Dimension>(invalid).is_err());
-    }
-}
-
-#[test]
-fn duration_unit_coordinates_are_exact_and_nominal() {
-    let duration = linear("duration", dim([0, 0, 1, 0, 0, 0, 0]));
-    let s = Unit::new(duration.clone(), source("1"), source("0")).unwrap();
-    let ms = Unit::new(duration.clone(), source("0.001"), source("0")).unwrap();
-    assert_fraction(&ms.convert(&source("750"), &s, &mut meter()).unwrap(), 3, 4);
-    let receive = NumericValue::from_unit(&source("750"), &ms, &mut meter()).unwrap();
-    let dispatch = NumericValue::from_unit(&source("1"), &s, &mut meter()).unwrap();
-    let total = receive.add(&dispatch, &mut meter()).unwrap();
-    assert_fraction(total.coordinate(), 7, 4);
-    assert_fraction(&total.display_in(&ms, &mut meter()).unwrap(), 1750, 1);
-    let different = Unit::new(
-        linear("different-kind", duration.dimension()),
-        source("1"),
-        source("0"),
-    )
-    .unwrap();
-    assert_eq!(
-        ms.convert(&source("750"), &different, &mut meter()),
-        Err(NumericError::IncompatibleTypes)
-    );
-    let inconsistent = Unit::new(
-        linear("duration", dim([1, 0, 0, 0, 0, 0, 0])),
-        source("1"),
-        source("0"),
-    )
-    .unwrap();
-    assert!(
-        ms.convert(&source("1"), &inconsistent, &mut meter())
-            .is_err()
-    );
-    assert!(Unit::new(duration.clone(), source("0"), source("0")).is_err());
-    assert!(Unit::new(duration.clone(), source("ratio(-1,1)"), source("0")).is_err());
-    assert_eq!(
-        Unit::new(duration, source("1"), source("1")).unwrap_err(),
-        NumericError::LinearOffset
-    );
-}
-
-#[test]
-fn affine_point_and_difference_arithmetic_has_distinct_kinds() {
-    let interval = linear("temperature-difference", dim([0, 0, 0, 0, 1, 0, 0]));
-    let point = ResolvedKind::affine("temperature-point".to_owned(), &interval).unwrap();
-    let celsius = Unit::new(point.clone(), source("1"), source("273.15")).unwrap();
-    let fahrenheit = Unit::new(
-        point.clone(),
-        source("ratio(5,9)"),
-        source("ratio(45967,180)"),
-    )
-    .unwrap();
-    let kelvin_interval = Unit::new(interval.clone(), source("1"), source("0")).unwrap();
-    assert_fraction(
-        &celsius
-            .convert(&source("0"), &fahrenheit, &mut meter())
-            .unwrap(),
-        32,
-        1,
-    );
-    assert_fraction(
-        &fahrenheit
-            .convert(&source("70"), &celsius, &mut meter())
-            .unwrap(),
-        190,
-        9,
-    );
-    let p20 = NumericValue::from_unit(&source("20"), &celsius, &mut meter()).unwrap();
-    let p10 = NumericValue::from_unit(&source("10"), &celsius, &mut meter()).unwrap();
-    let difference = p20.subtract(&p10, &mut meter()).unwrap();
-    assert_eq!(
-        difference.value_type(),
-        &NumericType::Named(interval.clone())
-    );
-    assert_fraction(
-        &difference
-            .display_in(&kelvin_interval, &mut meter())
-            .unwrap(),
-        10,
-        1,
-    );
-    let delta5 = named(5, &interval);
-    let p25 = p20.add(&delta5, &mut meter()).unwrap();
-    assert_fraction(&p25.display_in(&celsius, &mut meter()).unwrap(), 25, 1);
-    assert_eq!(delta5.add(&p20, &mut meter()).unwrap(), p25);
-    assert!(p20.add(&p10, &mut meter()).is_err());
-    assert!(delta5.subtract(&p20, &mut meter()).is_err());
-    assert_eq!(
-        p20.power(1, &mut meter()),
-        Err(NumericError::AffineOperation)
-    );
-    assert_eq!(
-        p20.negated(&mut meter()),
-        Err(NumericError::AffineOperation)
-    );
-    assert_eq!(p20.compare(&p10, &mut meter()).unwrap(), Ordering::Greater);
-    assert!(p20.display_in(&kelvin_interval, &mut meter()).is_err());
-    assert!(ResolvedKind::affine(interval.key().clone(), &interval).is_err());
-    assert!(ResolvedKind::affine("other".to_owned(), &point).is_err());
-}
-
-#[test]
-fn affine_conversion_rejects_a_wider_stage_even_when_the_final_value_would_fit() {
-    // A fused coordinate calculation 2*m-m equals m, where m=2^4095 fits.
-    // The fixed multiply stage produces 2^4096, so it must fail before offset
-    // cancellation. The inverse path likewise rejects (m-(-m))/2 at subtraction.
-    let large = BigInt::one() << 4095_usize;
-    let magnitude = exact(&large, 1);
-    let interval = linear("temperature-interval", dim([0, 0, 0, 0, 1, 0, 0]));
-    let point = ResolvedKind::affine("temperature-point".to_owned(), &interval).unwrap();
-    let unit = Unit::new(point, Exact::from_integer(2), exact(-&large, 1)).unwrap();
-    let mut work = meter();
-    for outcome in [
-        unit.to_canonical(&magnitude, &mut work),
-        unit.from_canonical(&magnitude, &mut work),
-    ] {
-        assert!(matches!(
-            outcome,
-            Err(NumericError::Limit(NumericLimit::Bits {
-                component: NumberComponent::Numerator,
-                bits: 4097,
-                limit: MAX_COMPONENT_BITS,
-                ..
-            }))
-        ));
-    }
-    assert!(work.exhaustion().is_none());
-    let half = exact(&large >> 1_usize, 1);
-    assert_fraction(&unit.to_canonical(&half, &mut work).unwrap(), 0, 1);
-    assert_eq!(
-        unit.from_canonical(&Exact::from_integer(0), &mut work)
-            .unwrap(),
-        half
-    );
-}
-
-#[test]
-fn r6_anonymous_compound_energy_needs_one_outer_assertion() {
-    let force = linear("force", dim([1, 1, -2, 0, 0, 0, 0]));
-    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
-    let energy = linear("energy", dim([2, 1, -2, 0, 0, 0, 0]));
-    let a = named(3, &force)
-        .multiply(&named(4, &length), &mut meter())
-        .unwrap();
-    let b = named(2, &force)
-        .multiply(&named(7, &length), &mut meter())
-        .unwrap();
-    assert_eq!(a.value_type(), &NumericType::Anonymous(energy.dimension()));
-    let sum = a.add(&b, &mut meter()).unwrap();
-    let result = sum.as_kind(&energy, &mut meter()).unwrap();
-    assert_fraction(result.coordinate(), 26, 1);
-    assert_eq!(result.value_type(), &NumericType::Named(energy.clone()));
-    assert_eq!(a.compare(&b, &mut meter()).unwrap(), Ordering::Less);
-    assert!(result.add(&sum, &mut meter()).is_err());
-    assert_eq!(
-        result.as_kind(&energy, &mut meter()),
-        Err(NumericError::KindAssertion)
-    );
-}
-
-#[test]
-fn anonymous_product_then_quotient_closes_and_preserves_scaling() {
-    let mass = linear("mass", dim([0, 1, 0, 0, 0, 0, 0]));
-    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
-    let time = linear("duration", dim([0, 0, 1, 0, 0, 0, 0]));
-    let momentum = linear("momentum", dim([1, 1, -1, 0, 0, 0, 0]));
-    let result = named(2, &mass)
-        .multiply(&named(3, &length), &mut meter())
-        .unwrap()
-        .divide(&named(2, &time), &mut meter())
-        .unwrap()
-        .as_kind(&momentum, &mut meter())
-        .unwrap();
-    assert_fraction(result.coordinate(), 3, 1);
-    let scalar = NumericValue::number(source("2"));
-    let scaled = scalar.multiply(&named(3, &time), &mut meter()).unwrap();
-    assert_eq!(scaled.value_type(), &NumericType::Named(time.clone()));
-    assert_fraction(scaled.coordinate(), 6, 1);
-    assert_eq!(
-        named(3, &time)
-            .divide(&scalar, &mut meter())
-            .unwrap()
-            .value_type(),
-        &NumericType::Named(time.clone())
-    );
-    assert_eq!(
-        scalar
-            .divide(&named(3, &time), &mut meter())
-            .unwrap()
-            .value_type(),
-        &NumericType::Anonymous(dim([0, 0, -1, 0, 0, 0, 0]))
-    );
-}
-
-#[test]
-fn nominal_kinds_survive_comparison_but_explicit_quotients_can_erase_dimension() {
-    let energy = linear("energy", dim([2, 1, -2, 0, 0, 0, 0]));
-    let torque = linear("torque", energy.dimension());
-    let left = named(7, &energy);
-    let right = named(7, &torque);
-    assert!(left.add(&right, &mut meter()).is_err());
-    assert!(left.compare(&right, &mut meter()).is_err());
-    let ratio = left.divide(&right, &mut meter()).unwrap();
-    assert_eq!(ratio.value_type(), &NumericType::Number);
-    assert_fraction(ratio.coordinate(), 1, 1);
-    let named_ratio = linear("chosen-ratio", Dimension::ZERO);
-    let asserted = ratio.as_kind(&named_ratio, &mut meter()).unwrap();
-    assert_eq!(
-        asserted.value_type(),
-        &NumericType::Named(named_ratio.clone())
-    );
-    assert!(asserted.add(&ratio, &mut meter()).is_err());
-    assert_eq!(
-        NumericValue::<String>::new(NumericType::Anonymous(Dimension::ZERO), source("1")),
-        NumericValue::number(source("1"))
-    );
-}
-
-#[test]
-fn numerical_power_types_and_dimension_overflow_are_checked() {
-    let length = linear("length", dim([1, 0, 0, 0, 0, 0, 0]));
-    let value = named(2, &length);
-    assert_eq!(
-        value.power(0, &mut meter()).unwrap().value_type(),
-        &NumericType::Number
-    );
-    assert_eq!(
-        value.power(1, &mut meter()).unwrap().value_type(),
-        value.value_type()
-    );
-    assert_eq!(
-        value.power(-2, &mut meter()).unwrap().value_type(),
-        &NumericType::Anonymous(dim([-2, 0, 0, 0, 0, 0, 0]))
-    );
-    let large_dimension = linear("large-dimension", dim([32, 0, 0, 0, 0, 0, 0]));
-    assert!(
-        named(1, &large_dimension)
-            .multiply(&value, &mut meter())
-            .is_err()
-    );
-    assert!(named(1, &large_dimension).power(2, &mut meter()).is_err());
-}

crates/oa-core/src/demo.rs

@@ -81,7 +81,6 @@ fn diagram(
             projection,
             view_options: Default::default(),
             nodes: BTreeMap::new(),
-            layout: None,
             routes: vec![],
         },
     );

crates/oa-core/src/diagram_edit.rs

@@ -1,91 +0,0 @@
-//! Pure diagram edits shared by movement previews and committed transactions.
-use crate::{Command, Id, MAX_COORDINATE, ModelError, Position, Project, projection};
-use std::collections::{BTreeMap, BTreeSet};
-
-/// Translate selected placements and their projected descendants simultaneously.
-///
-/// Membership and geometry are read from one snapshot, including folded children.
-/// Overlapping roots move each placement once. Route pins follow the combined
-/// movement of their actual endpoint owners (and State boundaries). Semantic
-/// ownership and other views are untouched. Apply the returned batch through the
-/// normal validated command path; its selected identity is not a primary selection.
-pub fn translate_placements(
-    project: &Project,
-    diagram: Id,
-    selected: &BTreeSet<Id>,
-    delta: Position,
-) -> Result<Command, ModelError> {
-    let view = project
-        .diagrams
-        .get(&diagram)
-        .ok_or_else(|| ModelError("Movement requires an existing diagram.".into()))?;
-    if selected.is_empty() {
-        return Err(ModelError(
-            "Movement requires at least one placement.".into(),
-        ));
-    }
-    if selected.iter().any(|id| !view.nodes.contains_key(id)) {
-        return Err(ModelError(
-            "Every selected placement must belong to the diagram.".into(),
-        ));
-    }
-    if !delta.x.is_finite() || !delta.y.is_finite() {
-        return Err(ModelError("Movement displacement must be finite.".into()));
-    }
-    if delta.x == 0. && delta.y == 0. {
-        return Ok(Command::Batch(vec![]));
-    }
-    let mut children: BTreeMap<Id, Vec<Id>> = BTreeMap::new();
-    for (child, parent) in projection::parents(project, view) {
-        if let Some(parent) = parent {
-            children.entry(parent).or_default().push(child);
-        }
-    }
-    let mut moved = BTreeSet::new();
-    let mut pending: Vec<_> = selected.iter().copied().collect();
-    while let Some(id) = pending.pop() {
-        if moved.insert(id) {
-            pending.extend(children.get(&id).into_iter().flatten().copied());
-        }
-    }
-    let deltas: BTreeMap<_, _> = moved.iter().map(|id| (*id, delta)).collect();
-    let routes = projection::translated_routes(project, view, &deltas);
-    let bounded = |value: f32| value.is_finite() && value.abs() <= MAX_COORDINATE;
-    let mut commands = Vec::with_capacity(moved.len() + routes.len());
-    for id in moved {
-        let mut node = view.nodes[&id].clone();
-        node.position.x += delta.x;
-        node.position.y += delta.y;
-        if ![
-            node.position.x,
-            node.position.y,
-            node.size.width,
-            node.size.height,
-        ]
-        .into_iter()
-        .all(bounded)
-            || node.size.width <= 0.
-            || node.size.height <= 0.
-        {
-            return Err(ModelError(
-                "Movement produces invalid placement bounds.".into(),
-            ));
-        }
-        commands.push(Command::EditNode {
-            diagram,
-            original: id,
-            node,
-        });
-    }
-    for route in routes {
-        if route
-            .waypoints
-            .iter()
-            .any(|point| !bounded(point.x) || !bounded(point.y))
-        {
-            return Err(ModelError("Movement produces invalid route bounds.".into()));
-        }
-        commands.push(Command::SetEdgeRoute { diagram, route });
-    }
-    Ok(Command::Batch(commands))
-}

crates/oa-core/src/lib.rs

@@ -1,7 +1,5 @@
 //! Framework-independent OA/SA model, transactional commands and editing services.
-pub mod analysis_numeric;
 pub mod data;
-pub mod diagram_edit;
 pub mod language;
 pub mod model;
 pub mod operations;
@@ -10,7 +8,6 @@ pub mod ports;
 pub mod projection;
 pub mod references;
 pub mod routing;
-pub mod scenario_layout;
 pub mod semantic;
 pub mod session;
 mod source_defaults;
@@ -22,9 +19,6 @@ pub mod validation;
 pub mod view_options;
 pub use model::*;
 pub use ports::*;
-pub use scenario_layout::{
-    DiagramLayout, ScenarioLanePosition, ScenarioLayout, ScenarioMessagePosition,
-};
 pub use semantic::*;
 pub use session::*;
 mod demo;

crates/oa-core/src/model.rs

@@ -1436,7 +1436,6 @@ pub enum ProjectionKind {
     FunctionalDataflow,
     Capabilities,
     StateMachine { machine: Id },
-    Scenario { scenario: Id },
 }
 impl ProjectionKind {
     pub fn state_machine(self) -> Option<Id> {
@@ -1446,30 +1445,8 @@ impl ProjectionKind {
         }
     }
 
-    /// The semantic owner of a saved Scenario representation.
-    pub fn scenario(self) -> Option<Id> {
-        match self {
-            Self::Scenario { scenario } => Some(scenario),
-            _ => None,
-        }
-    }
-
-    /// Explicitly classify architecture views; absence of a state machine is insufficient.
-    pub fn is_architecture(self) -> bool {
-        match self {
-            Self::Overview
-            | Self::Decomposition
-            | Self::Allocation
-            | Self::Traceability
-            | Self::FunctionalDataflow
-            | Self::Capabilities => true,
-            Self::StateMachine { .. } | Self::Scenario { .. } => false,
-        }
-    }
-
     pub fn includes(self, kind: Kind) -> bool {
         match self {
-            Self::Scenario { .. } => false,
             Self::StateMachine { .. } => {
                 matches!(kind, Kind::StateMachine | Kind::Region) || kind.is_state()
             }
@@ -1494,7 +1471,6 @@ impl std::fmt::Display for ProjectionKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(match self {
             Self::StateMachine { .. } => "State machine",
-            Self::Scenario { .. } => "Scenario",
             Self::Allocation => "Architecture · allocated work",
             Self::FunctionalDataflow => "Functional dataflow",
             Self::Capabilities => "Missions & capabilities",
@@ -1519,8 +1495,6 @@ pub struct Diagram {
     pub nodes: BTreeMap<Id, NodePlacement>,
     #[serde(default)]
     pub routes: Vec<EdgeRoute>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub layout: Option<crate::scenario_layout::DiagramLayout>,
 }
 /// Authored presentation for one existing relation or trace in one diagram.
 /// Computed endpoints and automatic routing elbows are never persisted here.
@@ -1528,45 +1502,11 @@ pub struct Diagram {
 #[serde(deny_unknown_fields)]
 pub struct EdgeRoute {
     pub edge: Id,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub source_attachment: Option<EdgeAttachment>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub target_attachment: Option<EdgeAttachment>,
     #[serde(default)]
     pub waypoints: Vec<Position>,
     #[serde(default)]
     pub label: Option<EdgeLabel>,
 }
-
-/// Presentation preference on one end of a connection. Real ports take precedence.
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct EdgeAttachment {
-    pub side: PortAnchorSide,
-    pub offset: f32,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum EdgeEnd {
-    Source,
-    Target,
-}
-
-impl EdgeRoute {
-    pub fn attachment(&self, end: EdgeEnd) -> Option<EdgeAttachment> {
-        match end {
-            EdgeEnd::Source => self.source_attachment,
-            EdgeEnd::Target => self.target_attachment,
-        }
-    }
-
-    pub fn set_attachment(&mut self, end: EdgeEnd, attachment: Option<EdgeAttachment>) {
-        match end {
-            EdgeEnd::Source => self.source_attachment = attachment,
-            EdgeEnd::Target => self.target_attachment = attachment,
-        }
-    }
-}
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct EdgeLabel {
@@ -1981,7 +1921,6 @@ impl Project {
                 view_options: crate::view_options::ViewOptions::default(),
                 nodes: BTreeMap::new(),
                 routes: vec![],
-                layout: None,
             },
         );
         id

crates/oa-core/src/projection.rs

@@ -278,11 +278,6 @@ fn project_diagram_impl(
     mut availability: Option<&mut BTreeMap<Id, crate::view_options::EdgeAvailability>>,
     index: Option<&crate::view_options::ViewIndex>,
 ) -> ProjectedView {
-    // Saved Scenario layout is not an architecture/state projection. Its dedicated
-    // renderer is not wired yet; never interpret its payload through this fallback.
-    if d.projection.scenario().is_some() {
-        return ProjectedView::default();
-    }
     let parents = parents(p, d);
     let mut nodes = Vec::new();
     for n in d.nodes.values() {
@@ -399,7 +394,6 @@ fn project_diagram_impl(
             continue;
         }
         let included = match d.projection {
-            ProjectionKind::Scenario { .. } => false,
             ProjectionKind::StateMachine { machine } => matches!(&r.body,
                 RelationBody::StateTransition { transition_kind, .. }
                     if *transition_kind != TransitionKind::Internal

crates/oa-core/src/references.rs

@@ -203,81 +203,7 @@ pub fn visit_relation_refs(r: &mut Relation, mut visit: impl FnMut(&mut Id)) {
         _ => {}
     }
 }
-/// Every semantic/presentation reference in a diagram, excluding its own identities.
-pub fn diagram_references(d: &Diagram) -> Vec<Id> {
-    let mut copy = d.clone();
-    let mut refs = Vec::new();
-    visit_diagram_refs(&mut copy, |id| refs.push(*id));
-    refs
-}
-
-pub fn visit_diagram_refs(d: &mut Diagram, mut visit: impl FnMut(&mut Id)) {
-    d.view_options.visit_references(&mut visit);
-    match &mut d.projection {
-        ProjectionKind::StateMachine { machine } => visit(machine),
-        ProjectionKind::Scenario { scenario } => visit(scenario),
-        _ => {}
-    }
-    if let Some(layout) = &mut d.layout {
-        layout.visit_references(&mut visit);
-    }
-    for route in &mut d.routes {
-        visit(&mut route.edge);
-    }
-    for node in d.nodes.values_mut() {
-        for anchor in &mut node.port_anchors {
-            visit(&mut anchor.port);
-        }
-        visit(&mut node.element);
-    }
-}
-
-/// Preflight reference-key collisions before the caller changes object identities.
-/// Fresh targets are allowed. This is not whole-project admission: unrelated
-/// invalid records remain repairable within a transaction. Future typed reference
-/// domains must compose their own preflight here before any remap mutation.
-pub fn check_remap(p: &Project, old: Id, new: Id) -> Result<(), ModelError> {
-    if old == new {
-        return Ok(());
-    }
-    let remap = |id: Id| if id == old { new } else { id };
-    for diagram in p.diagrams.values() {
-        let Some(DiagramLayout::Scenario(layout)) = &diagram.layout else {
-            continue;
-        };
-        let mut lanes = std::collections::BTreeMap::new();
-        for lane in &layout.lanes {
-            let affected = lane.lifeline == old;
-            if let Some(previous_affected) = lanes.insert(remap(lane.lifeline), affected)
-                && (affected || previous_affected)
-            {
-                return Err(ModelError(
-                    "Identity remap would collide with a Scenario lane position.".into(),
-                ));
-            }
-        }
-        let mut messages = std::collections::BTreeMap::new();
-        for message in &layout.messages {
-            let mut address = message.address.clone();
-            let affected = address.occurrence == old || address.references.contains(&old);
-            address.occurrence = remap(address.occurrence);
-            for reference in &mut address.references {
-                *reference = remap(*reference);
-            }
-            if let Some(previous_affected) = messages.insert(address, affected)
-                && (affected || previous_affected)
-            {
-                return Err(ModelError(
-                    "Identity remap would collide with a Scenario message position.".into(),
-                ));
-            }
-        }
-    }
-    Ok(())
-}
-
-pub fn remap_references(p: &mut Project, old: Id, new: Id) -> Result<(), ModelError> {
-    check_remap(p, old, new)?;
+pub fn remap_references(p: &mut Project, old: Id, new: Id) {
     for e in p.elements.values_mut() {
         visit_element_refs(e, |id| {
             if *id == old {
@@ -293,11 +219,31 @@ pub fn remap_references(p: &mut Project, old: Id, new: Id) -> Result<(), ModelEr
         });
     }
     for d in p.diagrams.values_mut() {
-        visit_diagram_refs(d, |id| {
+        d.view_options.visit_references(|id| {
             if *id == old {
                 *id = new;
             }
         });
+        if let ProjectionKind::StateMachine { machine } = &mut d.projection
+            && *machine == old
+        {
+            *machine = new;
+        }
+        for route in &mut d.routes {
+            if route.edge == old {
+                route.edge = new;
+            }
+        }
+        for n in d.nodes.values_mut() {
+            for anchor in &mut n.port_anchors {
+                if anchor.port == old {
+                    anchor.port = new;
+                }
+            }
+            if n.element == old {
+                n.element = new;
+            }
+        }
     }
     for a in p.artifact_links.values_mut() {
         if a.owner == old {
@@ -319,7 +265,6 @@ pub fn remap_references(p: &mut Project, old: Id, new: Id) -> Result<(), ModelEr
             });
         }
     }
-    Ok(())
 }
 /// IDs removed by a cascade. Cross-layer traced counterparts are never included.
 pub fn deletion_impact(p: &Project, id: Id) -> BTreeSet<Id> {
@@ -394,8 +339,7 @@ fn deletion_impact_inner(p: &Project, id: Id, defer_exchange_allocations: bool)
         for d in p.diagrams.values() {
             if d.projection
                 .state_machine()
-                .or_else(|| d.projection.scenario())
-                .is_some_and(|owner| removed.contains(&owner))
+                .is_some_and(|machine| removed.contains(&machine))
             {
                 removed.insert(d.id);
             }
@@ -468,7 +412,6 @@ fn remove_objects(p: &mut Project, removed: BTreeSet<Id>) {
     p.artifact_links.retain(|id, _| !removed.contains(id));
     for d in p.diagrams.values_mut() {
         d.view_options.retain_references(|id| !removed.contains(id));
-        crate::scenario_layout::prune_deleted(d, &removed);
         d.nodes.retain(|id, _| !removed.contains(id));
         d.routes.retain(|route| !removed.contains(&route.edge));
         for node in d.nodes.values_mut() {
@@ -646,7 +589,3 @@ fn remove_objects(p: &mut Project, removed: BTreeSet<Id>) {
         }
     }
 }
-
-#[cfg(test)]
-#[path = "references/scenario_layout_tests.rs"]
-mod scenario_layout_tests;

crates/oa-core/src/references/scenario_layout_tests.rs

@@ -1,388 +0,0 @@
-use super::*;
-use std::collections::BTreeMap;
-
-struct Fixture {
-    project: Project,
-    owner: Id,
-    lanes: [Id; 2],
-    messages: [Id; 2],
-    views: [Id; 2],
-}
-
-fn address(occurrence: Id) -> OccurrenceEndpoint {
-    OccurrenceEndpoint {
-        references: vec![],
-        occurrence,
-    }
-}
-
-fn layout(project: &Project, view: Id) -> &ScenarioLayout {
-    let Some(DiagramLayout::Scenario(layout)) = &project.diagrams[&view].layout else {
-        panic!("expected authored Scenario positions")
-    };
-    layout
-}
-
-fn layout_mut(project: &mut Project, view: Id) -> &mut ScenarioLayout {
-    let Some(DiagramLayout::Scenario(layout)) =
-        &mut project.diagrams.get_mut(&view).unwrap().layout
-    else {
-        panic!("expected authored Scenario positions")
-    };
-    layout
-}
-
-fn admitted(project: &Project) {
-    let errors: Vec<_> = crate::validation::validate(project)
-        .into_iter()
-        .filter(|issue| issue.severity == crate::validation::Severity::Error)
-        .collect();
-    assert!(errors.is_empty(), "{errors:?}");
-}
-
-fn fixture() -> Fixture {
-    let mut project = Project::empty();
-    let owner = project
-        .add_element(Kind::Scenario, Layer::Oa, "Delivery", None)
-        .unwrap();
-    let lanes = ["Sender", "Receiver"].map(|name| {
-        project
-            .add_element(Kind::Lifeline, Layer::Oa, name, Some(owner))
-            .unwrap()
-    });
-    let messages = ["First message", "Second message"].map(|name| {
-        let id = project
-            .add_element(Kind::Occurrence, Layer::Oa, name, Some(owner))
-            .unwrap();
-        *project.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange {
-                exchange: None,
-                sender: Some(lanes[0]),
-                receiver: Some(lanes[1]),
-                message_kind: MessageKind::Asynchronous,
-                reply_to: None,
-                values: vec![],
-                operation: None,
-            },
-            precondition: String::new(),
-            postcondition: String::new(),
-        };
-        id
-    });
-    *project
-        .elements
-        .get_mut(&owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap() = messages.to_vec();
-    let views = ["delivery_view", "review_view"].map(|alias| {
-        let id = Id::new_v4();
-        project.diagrams.insert(
-            id,
-            Diagram {
-                id,
-                alias: alias.into(),
-                name: alias.into(),
-                description: String::new(),
-                layer: Layer::Oa,
-                projection: ProjectionKind::Scenario { scenario: owner },
-                view_options: Default::default(),
-                nodes: BTreeMap::new(),
-                routes: vec![],
-                layout: Some(DiagramLayout::Scenario(ScenarioLayout {
-                    lanes: vec![
-                        ScenarioLanePosition {
-                            lifeline: lanes[0],
-                            x: 120.,
-                        },
-                        ScenarioLanePosition {
-                            lifeline: lanes[1],
-                            x: 420.,
-                        },
-                    ],
-                    messages: vec![
-                        ScenarioMessagePosition {
-                            address: address(messages[0]),
-                            send_y: 220.,
-                        },
-                        ScenarioMessagePosition {
-                            address: address(messages[1]),
-                            send_y: 360.,
-                        },
-                    ],
-                })),
-            },
-        );
-        id
-    });
-    admitted(&project);
-    Fixture {
-        project,
-        owner,
-        lanes,
-        messages,
-        views,
-    }
-}
-
-#[test]
-fn fresh_identity_swap_preserves_coordinates_and_semantic_sequence() {
-    let mut f = fixture();
-    let before = f.project.clone();
-    let temporary = Id::new_v4();
-    for ids in [f.lanes, f.messages] {
-        f.project = crate::execute_batch(
-            &f.project,
-            &[
-                Command::Reidentify(ids[0], temporary),
-                Command::Reidentify(ids[1], ids[0]),
-                Command::Reidentify(temporary, ids[1]),
-            ],
-        )
-        .unwrap();
-    }
-    admitted(&f.project);
-    assert_eq!(
-        f.project.elements[&f.owner].steps().unwrap(),
-        &vec![f.messages[1], f.messages[0]]
-    );
-    for view in f.views {
-        let rows = layout(&f.project, view);
-        assert_eq!(
-            rows.lanes,
-            vec![
-                ScenarioLanePosition {
-                    lifeline: f.lanes[1],
-                    x: 120.
-                },
-                ScenarioLanePosition {
-                    lifeline: f.lanes[0],
-                    x: 420.
-                }
-            ]
-        );
-        assert_eq!(
-            rows.messages,
-            vec![
-                ScenarioMessagePosition {
-                    address: address(f.messages[1]),
-                    send_y: 220.
-                },
-                ScenarioMessagePosition {
-                    address: address(f.messages[0]),
-                    send_y: 360.
-                }
-            ]
-        );
-    }
-    // Reverse the swaps: no values or identities other than those requested drift.
-    for ids in [f.lanes, f.messages] {
-        f.project = crate::execute_batch(
-            &f.project,
-            &[
-                Command::Reidentify(ids[0], temporary),
-                Command::Reidentify(ids[1], ids[0]),
-                Command::Reidentify(temporary, ids[1]),
-            ],
-        )
-        .unwrap();
-    }
-    assert_eq!(f.project, before);
-}
-
-#[test]
-fn colliding_lane_or_message_remap_rejects_before_any_reference_changes() {
-    for message in [false, true] {
-        let mut f = fixture();
-        let [old, new] = if message { f.messages } else { f.lanes };
-        let before = f.project.clone();
-        assert!(check_remap(&f.project, old, new).is_err());
-        assert!(remap_references(&mut f.project, old, new).is_err());
-        assert_eq!(f.project, before);
-    }
-}
-
-#[test]
-fn reidentify_preflight_precedes_object_map_mutation_for_fresh_colliding_target() {
-    let mut f = fixture();
-    let fresh = Id::new_v4();
-    // A repair candidate can already have a dangling coordinate key. It must not
-    // silently merge with the live lane, even though the destination ID is vacant.
-    layout_mut(&mut f.project, f.views[0]).lanes[1].lifeline = fresh;
-    let before = f.project.clone();
-    assert!(crate::session::reidentify(&mut f.project, f.lanes[0], fresh).is_err());
-    assert_eq!(f.project, before);
-}
-
-#[test]
-fn full_address_paths_are_walked_and_collision_checked_without_admitting_expansion() {
-    let mut f = fixture();
-    let [old, new] = [Id::new_v4(), Id::new_v4()];
-    let rows = layout_mut(&mut f.project, f.views[0]);
-    // Future/invalid expanded candidates still participate in reference safety.
-    rows.messages[0].address.references = vec![old];
-    rows.messages[1].address = OccurrenceEndpoint {
-        references: vec![new],
-        occurrence: f.messages[0],
-    };
-    let refs = diagram_references(&f.project.diagrams[&f.views[0]]);
-    assert!(refs.contains(&f.owner) && refs.contains(&old) && refs.contains(&new));
-    let before = f.project.clone();
-    assert!(remap_references(&mut f.project, old, new).is_err());
-    assert_eq!(f.project, before);
-    let fresh = Id::new_v4();
-    remap_references(&mut f.project, old, fresh).unwrap();
-    let rows = layout(&f.project, f.views[0]);
-    assert_eq!(rows.messages[0].address.references, vec![fresh]);
-    assert_eq!(rows.messages[0].address.occurrence, f.messages[0]);
-    assert_eq!(rows.messages[1].address.references, vec![new]);
-}
-
-#[test]
-fn owner_reidentify_and_delete_cover_all_saved_views_without_deleting_other_owners() {
-    let mut f = fixture();
-    let other_owner = f
-        .project
-        .add_element(Kind::Scenario, Layer::Oa, "Independent", None)
-        .unwrap();
-    let mut other_view = f.project.diagrams[&f.views[0]].clone();
-    other_view.id = Id::new_v4();
-    other_view.alias = "independent_view".into();
-    other_view.projection = ProjectionKind::Scenario {
-        scenario: other_owner,
-    };
-    other_view.layout = None;
-    f.project.diagrams.insert(other_view.id, other_view.clone());
-    admitted(&f.project);
-    let fresh_owner = Id::new_v4();
-    f.project = crate::prepare_command(&f.project, &Command::Reidentify(f.owner, fresh_owner))
-        .unwrap()
-        .project;
-    for view in f.views {
-        assert_eq!(
-            f.project.diagrams[&view].projection.scenario(),
-            Some(fresh_owner)
-        );
-    }
-    let impact = deletion_impact(&f.project, fresh_owner);
-    assert!(
-        f.views
-            .iter()
-            .chain(&f.lanes)
-            .chain(&f.messages)
-            .all(|id| impact.contains(id))
-    );
-    assert!(!impact.contains(&other_owner) && !impact.contains(&other_view.id));
-    delete_cascade(&mut f.project, fresh_owner);
-    assert_eq!(f.project.diagrams[&other_view.id], other_view);
-    assert!(
-        f.views
-            .iter()
-            .all(|id| !f.project.diagrams.contains_key(id))
-    );
-    admitted(&f.project);
-}
-
-#[test]
-fn deletion_then_recreation_never_resurrects_lane_or_message_coordinates() {
-    let mut f = fixture();
-    let lane = f.project.elements[&f.lanes[0]].clone();
-    let message = f.project.elements[&f.messages[0]].clone();
-    delete_cascade(&mut f.project, lane.id);
-    for view in f.views {
-        let rows = layout(&f.project, view);
-        assert_eq!(rows.lanes.len(), 1);
-        assert_eq!(rows.lanes[0].lifeline, f.lanes[1]);
-        // Missing endpoint assignment does not erase a still-live message's spacing.
-        assert_eq!(rows.messages.len(), 2);
-    }
-    let mut pending = BTreeSet::new();
-    delete_cascade_deferred(&mut f.project, message.id, &mut pending);
-    // Pruning happens during deletion, before later batch commands can recreate IDs.
-    assert!(
-        layout(&f.project, f.views[0])
-            .messages
-            .iter()
-            .all(|row| row.address.occurrence != message.id)
-    );
-    f.project.elements.insert(lane.id, lane);
-    f.project.elements.insert(message.id, message);
-    f.project
-        .elements
-        .get_mut(&f.owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .insert(0, f.messages[0]);
-    finish_deletions(&mut f.project, &pending);
-    for view in f.views {
-        let rows = layout(&f.project, view);
-        assert_eq!(rows.lanes.len(), 1);
-        assert_eq!(
-            rows.messages,
-            vec![ScenarioMessagePosition {
-                address: address(f.messages[1]),
-                send_y: 360.
-            }]
-        );
-    }
-    admitted(&f.project);
-}
-
-#[test]
-fn unrelated_invalid_records_do_not_block_scoped_remap_or_get_repaired_implicitly() {
-    let mut f = fixture();
-    let unrelated = Id::new_v4();
-    let rows = layout_mut(&mut f.project, f.views[1]);
-    let invalid = ScenarioLanePosition {
-        lifeline: unrelated,
-        x: MAX_COORDINATE * 2.,
-    };
-    rows.lanes.extend([invalid.clone(), invalid]);
-    let fresh = Id::new_v4();
-    let untouched = f.project.diagrams[&f.views[1]].clone();
-    let before = f.project.clone();
-    remap_references(&mut f.project, f.owner, f.owner).unwrap();
-    assert_eq!(f.project, before);
-    // The duplicate lane records do not involve the remapped message identity.
-    remap_references(&mut f.project, f.messages[0], fresh).unwrap();
-    assert_eq!(
-        layout(&f.project, f.views[1]).lanes,
-        layout_from(&untouched).lanes
-    );
-    assert_eq!(
-        layout(&f.project, f.views[1]).messages[0]
-            .address
-            .occurrence,
-        fresh
-    );
-    assert_eq!(layout(&f.project, f.views[1]).messages[0].send_y, 220.);
-}
-
-fn layout_from(diagram: &Diagram) -> &ScenarioLayout {
-    let Some(DiagramLayout::Scenario(layout)) = &diagram.layout else {
-        panic!("missing layout")
-    };
-    layout
-}
-
-#[test]
-fn deletion_prunes_an_explicit_address_path_without_pruning_other_message_rows() {
-    let mut f = fixture();
-    // Expanded addresses are not admitted in this slice, but deleting their
-    // explicit references must still make an intermediate repair candidate safe.
-    layout_mut(&mut f.project, f.views[0]).messages[0]
-        .address
-        .references = vec![f.lanes[0]];
-    delete_cascade(&mut f.project, f.lanes[0]);
-    assert_eq!(
-        layout(&f.project, f.views[0]).messages,
-        vec![ScenarioMessagePosition {
-            address: address(f.messages[1]),
-            send_y: 360.
-        }]
-    );
-    assert_eq!(layout(&f.project, f.views[1]).messages.len(), 2);
-    assert!(f.project.elements.contains_key(&f.messages[0]));
-    admitted(&f.project);
-}

crates/oa-core/src/routing.rs

@@ -1,14 +1,7 @@
 //! Deterministic, bounded diagram geometry. Only authored pins belong in the model;
 //! callers share this derived geometry for drawing, picking, fitting and export.
 use crate::projection::{self, ProjectedEdge, ProjectedNode, ProjectedView};
-use crate::{
-    Diagram, EdgeAttachment, EdgeEnd, Id, PortAnchorSide, Position, Project, Relation,
-    RelationBody, RelationKind, Size,
-};
-mod attachments;
-mod leads;
-pub use attachments::{attachment_from_point, attachment_point, semantic_port_endpoint};
-pub use leads::{LeadBlocker, LeadEndpoint, LeadIncompatibility, lead_incompatibilities};
+use crate::{Diagram, Id, Position, Project, Relation, RelationBody, RelationKind, Size};
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap};
 use std::fmt;
@@ -48,7 +41,6 @@ pub struct RoutedEdge {
     // Derived solver state, never persisted. A preview must inherit the same
     // remaining work budget as this edge had in stable-ID settled traversal.
     search_budget_before: usize,
-    attachments: [Option<EdgeAttachment>; 2],
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -181,7 +173,6 @@ pub fn association_end_geometry(
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RouteWarning {
-    CoincidentAttachments,
     PinInsideObstacle { pin: usize, obstacle: Id },
     NoClearPath,
     SearchBudgetExhausted,
@@ -190,9 +181,6 @@ pub enum RouteWarning {
 impl fmt::Display for RouteWarning {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::CoincidentAttachments => f.write_str(
-                "The two attachments coincide; move either end to separate the loop tips.",
-            ),
             Self::PinInsideObstacle { pin, .. } => {
                 write!(f, "Bend {} is inside a card or its clearance", pin + 1)
             }
@@ -386,14 +374,7 @@ struct Endpoint {
     point: Position,
     stub: Position,
 }
-fn endpoints(
-    project: &Project,
-    diagram: &Diagram,
-    node: &ProjectedNode,
-    port: Option<Id>,
-    view: &ProjectedView,
-    attachment: Option<EdgeAttachment>,
-) -> Vec<Endpoint> {
+fn endpoints(node: &ProjectedNode, port: Option<Id>, view: &ProjectedView) -> Vec<Endpoint> {
     if let Some(port) = port.and_then(|id| {
         view.ports
             .iter()
@@ -408,85 +389,26 @@ fn endpoints(
             ),
         }];
     }
-    if let Some(attachment) = attachment {
-        return vec![attachments::endpoint(project, diagram, node, attachment)];
-    }
-    [
-        PortAnchorSide::Left,
-        PortAnchorSide::Right,
-        PortAnchorSide::Top,
-        PortAnchorSide::Bottom,
+    let r = Rect::node(node);
+    let mid = pos((r.left + r.right) / 2.0, (r.top + r.bottom) / 2.0);
+    vec![
+        Endpoint {
+            point: pos(r.left, mid.y),
+            stub: pos(r.left - PORT_STUB, mid.y),
+        },
+        Endpoint {
+            point: pos(r.right, mid.y),
+            stub: pos(r.right + PORT_STUB, mid.y),
+        },
+        Endpoint {
+            point: pos(mid.x, r.top),
+            stub: pos(mid.x, r.top - PORT_STUB),
+        },
+        Endpoint {
+            point: pos(mid.x, r.bottom),
+            stub: pos(mid.x, r.bottom + PORT_STUB),
+        },
     ]
-    .into_iter()
-    .map(|side| attachments::endpoint(project, diagram, node, EdgeAttachment { side, offset: 0.5 }))
-    .collect()
-}
-
-fn effective_route<'a>(
-    project: &Project,
-    diagram: &Diagram,
-    edge: &ProjectedEdge,
-    stored: Option<&'a crate::EdgeRoute>,
-) -> (
-    bool,
-    Option<&'a crate::EdgeRoute>,
-    [Option<EdgeAttachment>; 2],
-) {
-    let promoted = projection::edge_endpoint_placements(project, diagram, edge.id)
-        .is_some_and(|(source, target)| source != edge.source || target != edge.target);
-    let route = if promoted { None } else { stored };
-    let attachments = [EdgeEnd::Source, EdgeEnd::Target].map(|end| {
-        semantic_port_endpoint(project, edge.id, end)
-            .is_none()
-            .then(|| route.and_then(|r| r.attachment(end)))
-            .flatten()
-    });
-    (promoted, route, attachments)
-}
-#[allow(clippy::too_many_arguments)]
-fn edge_endpoints(
-    project: &Project,
-    diagram: &Diagram,
-    edge: &ProjectedEdge,
-    source: &ProjectedNode,
-    target: &ProjectedNode,
-    view: &ProjectedView,
-    attachments: [Option<EdgeAttachment>; 2],
-) -> [Vec<Endpoint>; 2] {
-    [
-        endpoints(
-            project,
-            diagram,
-            source,
-            semantic_port_endpoint(project, edge.id, EdgeEnd::Source).or(edge.source_port),
-            view,
-            attachments[0],
-        ),
-        endpoints(
-            project,
-            diagram,
-            target,
-            semantic_port_endpoint(project, edge.id, EdgeEnd::Target).or(edge.target_port),
-            view,
-            attachments[1],
-        ),
-    ]
-}
-fn allowed_endpoint_pair(edge: &ProjectedEdge, a: Endpoint, b: Endpoint, coincident: bool) -> bool {
-    !(edge.source == edge.target
-        && edge.source_port.is_none()
-        && edge.target_port.is_none()
-        && a.point == b.point
-        && a.stub == b.stub
-        && !coincident)
-}
-fn lead_pair_clear(edge: &ProjectedEdge, a: Endpoint, b: Endpoint, obstacles: &[Rect]) -> bool {
-    !obstacles
-        .iter()
-        .any(|r| r.id != edge.source && r.crosses(a.point, a.stub))
-        && !obstacles
-            .iter()
-            .any(|r| r.id != edge.target && r.crosses(b.point, b.stub))
 }
 
 fn ancestors(id: Id, nodes: &BTreeMap<Id, &ProjectedNode>, out: &mut BTreeSet<Id>) {
@@ -581,8 +503,10 @@ fn route_diagram_impl(
             continue;
         };
         let stored = authored.get(&edge.id).copied();
-        let (custom_suspended, route, attachments) =
-            effective_route(project, diagram, edge, stored);
+        let promoted = projection::edge_endpoint_placements(project, diagram, edge.id)
+            .is_some_and(|(source, target)| source != edge.source || target != edge.target);
+        let custom_suspended = promoted;
+        let route = if promoted { None } else { stored };
         let pins = route.map_or_else(Vec::new, |r| r.waypoints.clone());
         let obstacles = edge_obstacles(edge, &nodes, &rectangles, &headers);
 
@@ -593,10 +517,7 @@ fn route_diagram_impl(
         });
         if let Some(cached) = cached {
             budget = cached.search_budget_before;
-            if cached.pins == pins
-                && cached.attachments == attachments
-                && cached.custom_suspended == custom_suspended
-            {
+            if cached.pins == pins && cached.custom_suspended == custom_suspended {
                 // Label-only editing cannot change the connection beneath the
                 // pointer, including a settled fallback with routing warnings.
                 for &point in &cached.points {
@@ -620,11 +541,11 @@ fn route_diagram_impl(
                 });
             }
         }
-        let ends = edge_endpoints(project, diagram, edge, source, target, view, attachments);
         let (points, pin_lengths, failure) = route_edge(
             edge,
-            &ends[0],
-            &ends[1],
+            source,
+            target,
+            view,
             &pins,
             &obstacles,
             &previous,
@@ -653,7 +574,6 @@ fn route_diagram_impl(
                 warnings,
                 custom_suspended,
                 search_budget_before,
-                attachments,
             },
         );
     }
@@ -759,46 +679,6 @@ struct RoutingSpace<'a> {
     xs: Vec<f32>,
     ys: Vec<f32>,
 }
-
-fn coincident_detour(a: Endpoint, obstacles: &[Rect]) -> [Position; 3] {
-    let direction = |delta: f32| if delta == 0. { 0. } else { delta.signum() };
-    let normal = pos(
-        direction(a.stub.x - a.point.x),
-        direction(a.stub.y - a.point.y),
-    );
-    let tangent = pos(-normal.y, normal.x);
-    let candidates: Vec<_> = [36., 72., 144., 288.]
-        .into_iter()
-        .flat_map(|extent| {
-            [-1., 1.].into_iter().map(move |side| {
-                [
-                    pos(a.stub.x + normal.x * extent, a.stub.y + normal.y * extent),
-                    pos(
-                        a.stub.x + (normal.x + tangent.x * side) * extent,
-                        a.stub.y + (normal.y + tangent.y * side) * extent,
-                    ),
-                    pos(
-                        a.stub.x + tangent.x * side * extent,
-                        a.stub.y + tangent.y * side * extent,
-                    ),
-                ]
-            })
-        })
-        .collect();
-    // These are computed loop guards, not authored hard pins. Prefer a clear
-    // orientation/size before asking the bounded router to connect them.
-    candidates
-        .iter()
-        .find(|p| clear_path(&[a.stub, p[0], p[1], p[2], a.stub], obstacles))
-        .or_else(|| {
-            candidates.iter().find(|p| {
-                p.iter()
-                    .all(|point| !obstacles.iter().any(|r| r.contains(*point)))
-            })
-        })
-        .copied()
-        .unwrap_or(candidates[0])
-}
 impl<'a> RoutingSpace<'a> {
     fn new(obstacles: &'a [Rect]) -> Self {
         Self {
@@ -812,36 +692,25 @@ impl<'a> RoutingSpace<'a> {
 #[allow(clippy::too_many_arguments)]
 fn route_edge(
     edge: &ProjectedEdge,
-    source_ends: &[Endpoint],
-    target_ends: &[Endpoint],
+    source: &ProjectedNode,
+    target: &ProjectedNode,
+    view: &ProjectedView,
     pins: &[Position],
     obstacles: &[Rect],
     previous: &[Segment],
     budget: &mut usize,
 ) -> EdgePath {
-    // Coincident authored tips are valid presentation, including on self loops.
-    // Preserve them and add an external detour; never index an empty candidate
-    // list or turn the connection into an out-and-back degenerate stub.
-    let coincident = edge.source == edge.target
-        && source_ends.len() == 1
-        && target_ends.len() == 1
-        && source_ends[0].point == target_ends[0].point
-        && source_ends[0].stub == target_ends[0].stub;
-    let authored_pin_count = pins.len();
-    let mut loop_pins = Vec::new();
-    if coincident {
-        let a = source_ends[0];
-        loop_pins.extend_from_slice(pins);
-        loop_pins.extend(coincident_detour(a, obstacles));
-    }
-    let pins = if coincident { &loop_pins[..] } else { pins };
     let space = RoutingSpace::new(obstacles);
     let mut candidates = Vec::new();
-    for &a in source_ends {
-        for &b in target_ends {
+    for a in endpoints(source, edge.source_port, view) {
+        for b in endpoints(target, edge.target_port, view) {
             // A real self-relation must leave and return at distinct anchors.
             // Reusing one anchor makes the cheapest path a degenerate stub.
-            if !allowed_endpoint_pair(edge, a, b, coincident) {
+            if edge.source == edge.target
+                && edge.source_port.is_none()
+                && edge.target_port.is_none()
+                && a.point == b.point
+            {
                 continue;
             }
             let estimate = manhattan(a.stub, pins.first().copied().unwrap_or(b.stub))
@@ -860,19 +729,26 @@ fn route_edge(
     // Try all side combinations cheaply before spending the bounded grid budget.
     for search in [false, true] {
         for &(estimate, a, b) in &candidates {
-            if best.as_ref().is_some_and(|(cost, _, _)| {
-                estimate + manhattan(a.point, a.stub) + manhattan(b.point, b.stub) > *cost
-            }) {
+            if best
+                .as_ref()
+                .is_some_and(|(cost, _, _)| estimate + 2.0 * PORT_STUB > *cost)
+            {
                 continue;
             }
-            if !lead_pair_clear(edge, a, b, obstacles) {
+            if obstacles
+                .iter()
+                .any(|r| r.id != edge.source && r.crosses(a.point, a.stub))
+                || obstacles
+                    .iter()
+                    .any(|r| r.id != edge.target && r.crosses(b.point, b.stub))
+            {
                 continue;
             }
             let mut points = vec![a.point, a.stub];
             let mut occupied = previous.to_vec();
             record_segments(&mut occupied, &points);
             let mut pin_lengths = Vec::new();
-            let mut distance = manhattan(a.point, a.stub);
+            let mut distance = PORT_STUB;
             let mut start = a.stub;
             let mut failed = false;
             for (index, end) in pins
@@ -916,20 +792,15 @@ fn route_edge(
             break;
         }
     }
-    if let Some((_, points, mut pin_lengths)) = best {
-        pin_lengths.truncate(authored_pin_count);
-        return (
-            points,
-            pin_lengths,
-            coincident.then_some(RouteWarning::CoincidentAttachments),
-        );
+    if let Some((_, points, pin_lengths)) = best {
+        return (points, pin_lengths, None);
     }
     // Recoverable fallback retains every hard pin, in order, and the actual port
     // leads. Its warning is deliberately visible to consumers.
     let (_, a, b) = candidates[0];
     let mut points = vec![a.point, a.stub];
     let mut pin_lengths = Vec::new();
-    let mut distance = manhattan(a.point, a.stub);
+    let mut distance = PORT_STUB;
     let mut start = a.stub;
     for (index, end) in pins
         .iter()
@@ -962,7 +833,6 @@ fn route_edge(
         start = end;
     }
     points.push(b.point);
-    pin_lengths.truncate(authored_pin_count);
     (
         points,
         pin_lengths,

crates/oa-core/src/routing/attachments.rs

@@ -1,160 +0,0 @@
-//! One boundary definition shared by persisted routing and attachment gestures.
-use super::*;
-use crate::{EdgeAttachment, EdgeEnd, Kind, PortAnchorSide};
-
-/// Semantic authority, independent of whether projection currently exposes a port.
-pub fn semantic_port_endpoint(project: &Project, edge: Id, end: EdgeEnd) -> Option<Id> {
-    let endpoint = if let Some(relation) = project.relations.get(&edge) {
-        match (&relation.body, end) {
-            (RelationBody::FunctionalExchange { source_port, .. }, EdgeEnd::Source) => *source_port,
-            (RelationBody::FunctionalExchange { target_port, .. }, EdgeEnd::Target) => *target_port,
-            (_, EdgeEnd::Source) => relation.source(),
-            (_, EdgeEnd::Target) => relation.target(),
-        }
-    } else {
-        let trace = project.traces.get(&edge)?;
-        match end {
-            EdgeEnd::Source => trace.oa,
-            EdgeEnd::Target => trace.sa,
-        }
-    };
-    project
-        .elements
-        .get(&endpoint)
-        .filter(|e| e.kind() == Kind::Port)
-        .map(|_| endpoint)
-}
-
-/// Intersect the chosen cardinal scan line with the painted shape. Offset is
-/// measured over the complete projected bounding side, including its corners.
-/// Terminate's X uses its outermost stroke intersection rather than a contour.
-pub fn attachment_point(
-    project: &Project,
-    diagram: &Diagram,
-    node: &ProjectedNode,
-    attachment: &EdgeAttachment,
-) -> Position {
-    let vertical = matches!(
-        attachment.side,
-        PortAnchorSide::Left | PortAnchorSide::Right
-    );
-    let (extent, depth) = if vertical {
-        (node.size.height, node.size.width)
-    } else {
-        (node.size.width, node.size.height)
-    };
-    let along = attachment.offset.clamp(0., 1.) * extent;
-    let t = 2. * attachment.offset.clamp(0., 1.) - 1.;
-    let kind = diagram
-        .projection
-        .state_machine()
-        .and_then(|_| project.elements.get(&node.element))
-        .map(|e| e.kind());
-    let inset = match kind {
-        Some(Kind::Choice) => depth * 0.5 * t.abs(),
-        Some(Kind::Terminate) => {
-            depth
-                * attachment
-                    .offset
-                    .clamp(0., 1.)
-                    .min(1. - attachment.offset.clamp(0., 1.))
-        }
-        Some(
-            Kind::Initial
-            | Kind::Junction
-            | Kind::Final
-            | Kind::ShallowHistory
-            | Kind::DeepHistory
-            | Kind::EntryPoint
-            | Kind::ExitPoint,
-        ) => depth * 0.5 * (1. - (1. - t * t).max(0.).sqrt()),
-        Some(Kind::Region | Kind::Fork | Kind::Join) => 0.,
-        _ => {
-            let radius = 10_f32.min(extent / 2.).min(depth / 2.);
-            let corner = (radius - along.min(extent - along)).max(0.);
-            radius - (radius * radius - corner * corner).max(0.).sqrt()
-        }
-    };
-    match attachment.side {
-        PortAnchorSide::Left => pos(node.position.x + inset, node.position.y + along),
-        PortAnchorSide::Right => pos(
-            node.position.x + node.size.width - inset,
-            node.position.y + along,
-        ),
-        PortAnchorSide::Top => pos(node.position.x + along, node.position.y + inset),
-        PortAnchorSide::Bottom => pos(
-            node.position.x + along,
-            node.position.y + node.size.height - inset,
-        ),
-    }
-}
-
-/// Choose a cardinal bounding side, then map its fraction onto the painted
-/// contour. Contour distances cannot distinguish the sides of a circle at its
-/// extrema: Right/0 and Top/0.5 denote the same point but different lead directions.
-/// Hysteresis is in diagram units, capped for small symbols. Only UI snapping
-/// rounds to hundredths: source/API values retain their complete precision.
-pub fn attachment_from_point(
-    node: &ProjectedNode,
-    cursor: Position,
-    previous: Option<PortAnchorSide>,
-    hysteresis: f32,
-) -> EdgeAttachment {
-    let candidate = |side| EdgeAttachment {
-        side,
-        offset: projection::port_anchor_offset(node, side, cursor),
-    };
-    // Measure side intent at the box, not from a distant overshoot: Euclidean
-    // distance differences converge outside a small symbol and would otherwise
-    // let hysteresis retain a perpendicular side indefinitely.
-    let boundary_cursor = pos(
-        cursor
-            .x
-            .clamp(node.position.x, node.position.x + node.size.width),
-        cursor
-            .y
-            .clamp(node.position.y, node.position.y + node.size.height),
-    );
-    let distance = |side| {
-        length(
-            projection::port_anchor_position(node, side, candidate(side).offset),
-            boundary_cursor,
-        )
-    };
-    let mut side = [
-        PortAnchorSide::Left,
-        PortAnchorSide::Right,
-        PortAnchorSide::Top,
-        PortAnchorSide::Bottom,
-    ]
-    .into_iter()
-    .min_by(|a, b| distance(*a).total_cmp(&distance(*b)))
-    .unwrap();
-    let hysteresis = hysteresis
-        .max(0.)
-        .min(node.size.width.min(node.size.height) * 0.2);
-    if let Some(old) = previous
-        && distance(old) <= distance(side) + hysteresis
-    {
-        side = old;
-    }
-    let mut attachment = candidate(side);
-    attachment.offset = (attachment.offset * 100.).round() / 100.;
-    attachment
-}
-
-pub(super) fn endpoint(
-    project: &Project,
-    diagram: &Diagram,
-    node: &ProjectedNode,
-    attachment: EdgeAttachment,
-) -> Endpoint {
-    let point = attachment_point(project, diagram, node, &attachment);
-    let stub = match attachment.side {
-        PortAnchorSide::Left => pos(node.position.x - PORT_STUB, point.y),
-        PortAnchorSide::Right => pos(node.position.x + node.size.width + PORT_STUB, point.y),
-        PortAnchorSide::Top => pos(point.x, node.position.y - PORT_STUB),
-        PortAnchorSide::Bottom => pos(point.x, node.position.y + node.size.height + PORT_STUB),
-    };
-    Endpoint { point, stub }
-}

crates/oa-core/src/routing/leads.rs

@@ -1,173 +0,0 @@
-//! Necessary terminal-lead checks shared with experimental placement consumers.
-use super::*;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct LeadBlocker {
-    pub id: Id,
-    /// The actual routing obstacle: clearance inflated, ancestor body excluded.
-    pub bounds: RoutingBounds,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct LeadEndpoint {
-    pub owner: Id,
-    pub tip: Position,
-    pub stub: Position,
-    pub blockers: Vec<LeadBlocker>,
-    /// Separate information only; not part of the router's early lead guard.
-    pub stub_containers: Vec<LeadBlocker>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct LeadIncompatibility {
-    pub edge: Id,
-    pub source: Vec<LeadEndpoint>,
-    pub target: Vec<LeadEndpoint>,
-    pub allowed_pair_count: usize,
-    pub lead_clear_pair_count: usize,
-}
-
-fn blocker(r: &Rect) -> LeadBlocker {
-    LeadBlocker {
-        id: r.id,
-        bounds: RoutingBounds {
-            position: pos(r.left, r.top),
-            size: Size {
-                width: r.right - r.left,
-                height: r.bottom - r.top,
-            },
-        },
-    }
-}
-
-fn describe(owner: Id, endpoint: Endpoint, obstacles: &[Rect]) -> LeadEndpoint {
-    LeadEndpoint {
-        owner,
-        tip: endpoint.point,
-        stub: endpoint.stub,
-        blockers: obstacles
-            .iter()
-            .filter(|r| r.id != owner && r.crosses(endpoint.point, endpoint.stub))
-            .map(blocker)
-            .collect(),
-        stub_containers: obstacles
-            .iter()
-            .filter(|r| r.contains(endpoint.stub))
-            .map(blocker)
-            .collect(),
-    }
-}
-
-/// Return only edges for which every allowed endpoint pair fails the router's
-/// existing mandatory-lead guard. Empty output is NECESSARY ONLY: it does not
-/// establish a clear route, clear pins, successful search, or label clearance.
-/// Uses the supplied final projection; does not modify the Project or choose
-/// different ports/attachments. Stub containment is reported separately and
-/// does not change the lead guard or its historical pinned/degenerate behavior.
-pub fn lead_incompatibilities(
-    project: &Project,
-    diagram: &Diagram,
-    view: &ProjectedView,
-) -> Vec<LeadIncompatibility> {
-    let nodes: BTreeMap<_, _> = view.nodes.iter().map(|n| (n.id, n)).collect();
-    let rectangles: Vec<_> = nodes.values().map(|n| Rect::node(n)).collect();
-    let authored: BTreeMap<_, _> = diagram.routes.iter().map(|r| (r.edge, r)).collect();
-    let headers: BTreeMap<_, _> = nodes
-        .values()
-        .map(|node| {
-            (
-                node.id,
-                if diagram.projection.state_machine().is_some() && !node.collapsed {
-                    projection::state_header_height(project, node.element)
-                } else {
-                    HEADER
-                },
-            )
-        })
-        .collect();
-    let mut ordered: Vec<_> = view.edges.iter().collect();
-    ordered.sort_by_key(|e| e.id);
-    let mut result = Vec::new();
-    for edge in ordered {
-        let (Some(source), Some(target)) = (nodes.get(&edge.source), nodes.get(&edge.target))
-        else {
-            continue;
-        };
-        let (_, _, attachments) =
-            effective_route(project, diagram, edge, authored.get(&edge.id).copied());
-        let ends = edge_endpoints(project, diagram, edge, source, target, view, attachments);
-        let obstacles = edge_obstacles(edge, &nodes, &rectangles, &headers);
-        let coincident = edge.source == edge.target
-            && ends[0].len() == 1
-            && ends[1].len() == 1
-            && ends[0][0].point == ends[1][0].point
-            && ends[0][0].stub == ends[1][0].stub;
-        let mut allowed_pair_count = 0;
-        let mut lead_clear_pair_count = 0;
-        for &a in &ends[0] {
-            for &b in &ends[1] {
-                if !allowed_endpoint_pair(edge, a, b, coincident) {
-                    continue;
-                }
-                allowed_pair_count += 1;
-                if lead_pair_clear(edge, a, b, &obstacles) {
-                    lead_clear_pair_count += 1;
-                }
-            }
-        }
-        if lead_clear_pair_count == 0 {
-            result.push(LeadIncompatibility {
-                edge: edge.id,
-                source: ends[0]
-                    .iter()
-                    .map(|&e| describe(edge.source, e, &obstacles))
-                    .collect(),
-                target: ends[1]
-                    .iter()
-                    .map(|&e| describe(edge.target, e, &obstacles))
-                    .collect(),
-                allowed_pair_count,
-                lead_clear_pair_count,
-            });
-        }
-    }
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn coincident_selfloop_exception_and_stub_containment_remain_separate() {
-        let owner = Id::from_u128(1);
-        let edge = ProjectedEdge {
-            id: Id::from_u128(2),
-            source: owner,
-            target: owner,
-            source_port: None,
-            target_port: None,
-            trace: false,
-            oriented: true,
-        };
-        let endpoint = Endpoint {
-            point: pos(0., 0.),
-            stub: pos(18., 0.),
-        };
-        assert!(!allowed_endpoint_pair(&edge, endpoint, endpoint, false));
-        assert!(allowed_endpoint_pair(&edge, endpoint, endpoint, true));
-        let obstacles = [Rect {
-            id: owner,
-            left: -1.,
-            right: 20.,
-            top: -1.,
-            bottom: 1.,
-        }];
-        assert!(lead_pair_clear(&edge, endpoint, endpoint, &obstacles));
-        let diagnostic = describe(owner, endpoint, &obstacles);
-        assert!(diagnostic.blockers.is_empty());
-        assert_eq!(diagnostic.stub_containers.len(), 1);
-        // This diagnostic must not be folded into the historical early guard.
-        assert_eq!(diagnostic.stub_containers[0].id, owner);
-    }
-}

crates/oa-core/src/scenario_layout.rs

@@ -1,429 +0,0 @@
-//! Authored Scenario presentation. Structural admission never changes event order.
-use crate::{
-    Diagram, Id, Kind, Layer, MAX_COORDINATE, ModelError, OccurrenceBody, OccurrenceEndpoint,
-    Project, SharedBody, validation,
-};
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeSet;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub enum DiagramLayout {
-    Scenario(ScenarioLayout),
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
-#[serde(deny_unknown_fields)]
-pub struct ScenarioLayout {
-    #[serde(default)]
-    pub lanes: Vec<ScenarioLanePosition>,
-    #[serde(default)]
-    pub messages: Vec<ScenarioMessagePosition>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct ScenarioLanePosition {
-    pub lifeline: Id,
-    pub x: f32,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct ScenarioMessagePosition {
-    pub address: OccurrenceEndpoint,
-    /// Actual send endpoint, not the renderer's receive-oriented lifecycle row.
-    pub send_y: f32,
-}
-
-impl DiagramLayout {
-    /// Visit every explicit reference, including unsupported paths in a candidate.
-    /// The caller owns remap preflight and final atomic validation.
-    pub fn visit_references(&mut self, mut visit: impl FnMut(&mut Id)) {
-        match self {
-            Self::Scenario(layout) => {
-                for lane in &mut layout.lanes {
-                    visit(&mut lane.lifeline);
-                }
-                for message in &mut layout.messages {
-                    for reference in &mut message.address.references {
-                        visit(reference);
-                    }
-                    visit(&mut message.address.occurrence);
-                }
-            }
-        }
-    }
-}
-
-/// Proposed aggregate accounting contribution; the shared admission owner applies it.
-/// One payload plus one record per lane/message. No graph objects are introduced.
-pub fn record_count(diagram: &Diagram) -> usize {
-    match &diagram.layout {
-        None => 0,
-        Some(DiagramLayout::Scenario(layout)) => 1usize
-            .saturating_add(layout.lanes.len())
-            .saturating_add(layout.messages.len()),
-    }
-}
-
-fn coordinate(value: f32) -> bool {
-    value.is_finite() && value.abs() <= MAX_COORDINATE
-}
-
-fn owner(p: &Project, diagram: &Diagram) -> Result<Id, ModelError> {
-    let scenario = diagram
-        .projection
-        .scenario()
-        .ok_or_else(|| ModelError("Scenario layout requires a Scenario projection.".into()))?;
-    if !p
-        .elements
-        .get(&scenario)
-        .is_some_and(|element| element.kind() == Kind::Scenario && element.layer() == diagram.layer)
-    {
-        return Err(ModelError(
-            "Scenario projection requires an existing Scenario in the diagram layer.".into(),
-        ));
-    }
-    Ok(scenario)
-}
-
-fn lane_member(p: &Project, owner: Id, layer: Layer, lifeline: Id) -> bool {
-    p.elements.get(&lifeline).is_some_and(|element| {
-        element.kind() == Kind::Lifeline
-            && element.parent == Some(owner)
-            && element.layer() == layer
-    })
-}
-
-/// Only actual steps of this Scenario and its own Fragment/Branch sequences.
-/// ScenarioUse/SequenceReference are deliberately never expanded. Invalid graph
-/// cycles terminate, and malformed parent/step links do not manufacture membership.
-fn direct_messages(p: &Project, owner: Id, layer: Layer) -> BTreeSet<Id> {
-    let mut messages = BTreeSet::new();
-    let mut visited = BTreeSet::new();
-    let mut pending = vec![owner];
-    while let Some(scope) = pending.pop() {
-        if !visited.insert(scope) {
-            continue;
-        }
-        let Some(element) = p.elements.get(&scope) else {
-            continue;
-        };
-        for id in element.steps().into_iter().flatten() {
-            let Some(item) = p.elements.get(id) else {
-                continue;
-            };
-            if item.parent != Some(scope) || item.layer() != layer {
-                continue;
-            }
-            match item.shared() {
-                Some(SharedBody::Occurrence {
-                    body: OccurrenceBody::Exchange { .. },
-                    ..
-                }) => {
-                    messages.insert(*id);
-                }
-                Some(SharedBody::Occurrence {
-                    body: OccurrenceBody::Fragment { branches, .. },
-                    ..
-                }) => {
-                    for branch in branches {
-                        if p.elements.get(branch).is_some_and(|operand| {
-                            operand.parent == Some(*id)
-                                && operand.layer() == layer
-                                && matches!(
-                                    operand.shared(),
-                                    Some(SharedBody::Occurrence {
-                                        body: OccurrenceBody::Branch { .. },
-                                        ..
-                                    })
-                                )
-                        }) {
-                            pending.push(*branch);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-    messages
-}
-
-pub(crate) fn validate_diagram(p: &Project, diagram: &Diagram, out: &mut Vec<validation::Issue>) {
-    if diagram.projection.scenario().is_none() {
-        if diagram.layout.is_some() {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_projection",
-                "layout",
-                "Only a Scenario projection accepts a Scenario layout, including an empty payload.",
-            );
-        }
-        return;
-    }
-    let scenario = match owner(p, diagram) {
-        Ok(owner) => owner,
-        Err(error) => {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_diagram_context",
-                "projection",
-                error.0,
-            );
-            return;
-        }
-    };
-    if !diagram.nodes.is_empty() || !diagram.routes.is_empty() {
-        validation::error(
-            out,
-            diagram.id,
-            "scenario_diagram_content",
-            "layout",
-            "Scenario views do not accept architecture node placements or edge routes.",
-        );
-    }
-    let Some(DiagramLayout::Scenario(layout)) = &diagram.layout else {
-        return;
-    };
-    let mut lanes = BTreeSet::new();
-    for lane in &layout.lanes {
-        if !lanes.insert(lane.lifeline) {
-            validation::error(
-                out,
-                diagram.id,
-                "duplicate_scenario_lane",
-                "layout",
-                "A Scenario layout has at most one position per lifeline.",
-            );
-        }
-        if !lane_member(p, scenario, diagram.layer, lane.lifeline) {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_lifeline",
-                "layout",
-                "Lane positions reference a Lifeline directly owned by the projected Scenario.",
-            );
-        }
-        if !coordinate(lane.x) {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_coordinate",
-                "layout",
-                "Scenario positions must be finite and within the shared coordinate bounds.",
-            );
-        }
-    }
-    let members = direct_messages(p, scenario, diagram.layer);
-    let mut addresses = BTreeSet::new();
-    for message in &layout.messages {
-        // Reject expanded paths without cloning or indexing their potentially large contents.
-        if !message.address.references.is_empty() {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_address",
-                "layout",
-                "Expanded-reference message positions are not supported; references must be empty.",
-            );
-        } else if !addresses.insert(message.address.occurrence) {
-            validation::error(
-                out,
-                diagram.id,
-                "duplicate_scenario_message",
-                "layout",
-                "A Scenario layout has at most one position per message address.",
-            );
-        }
-        if !members.contains(&message.address.occurrence) {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_message",
-                "layout",
-                "Message positions reference Exchange occurrences in the Scenario's own ordered sequence tree.",
-            );
-        }
-        if !coordinate(message.send_y) {
-            validation::error(
-                out,
-                diagram.id,
-                "scenario_layout_coordinate",
-                "layout",
-                "Scenario positions must be finite and within the shared coordinate bounds.",
-            );
-        }
-    }
-}
-
-fn editable(p: &Project, id: Id) -> Result<(&Diagram, Id), ModelError> {
-    let diagram = p
-        .diagrams
-        .get(&id)
-        .ok_or_else(|| ModelError("Scenario diagram does not exist.".into()))?;
-    let scenario = owner(p, diagram)?;
-    if !diagram.nodes.is_empty() || !diagram.routes.is_empty() {
-        return Err(ModelError(
-            "Scenario views do not accept architecture node placements or edge routes.".into(),
-        ));
-    }
-    Ok((diagram, scenario))
-}
-
-fn check_message(
-    p: &Project,
-    diagram: &Diagram,
-    owner: Id,
-    address: &OccurrenceEndpoint,
-) -> Result<(), ModelError> {
-    if !address.references.is_empty() {
-        return Err(ModelError(
-            "Expanded-reference message positions are not supported; references must be empty."
-                .into(),
-        ));
-    }
-    if !direct_messages(p, owner, diagram.layer).contains(&address.occurrence) {
-        return Err(ModelError("Message position requires an Exchange occurrence in the Scenario's own ordered sequence tree.".into()));
-    }
-    Ok(())
-}
-
-fn payload(diagram: &mut Diagram) -> &mut ScenarioLayout {
-    let DiagramLayout::Scenario(layout) = diagram
-        .layout
-        .get_or_insert_with(|| DiagramLayout::Scenario(ScenarioLayout::default()));
-    layout
-}
-
-/// Target-scoped preparation, not whole-project or whole-layout validation.
-/// Unrelated intermediate errors remain repairable by later commands in a batch.
-pub fn set_lane(
-    p: &Project,
-    diagram: Id,
-    position: ScenarioLanePosition,
-) -> Result<Diagram, ModelError> {
-    let (current, owner) = editable(p, diagram)?;
-    if !lane_member(p, owner, current.layer, position.lifeline) || !coordinate(position.x) {
-        return Err(ModelError(
-            "Lane position requires an owned Lifeline and a finite bounded x coordinate.".into(),
-        ));
-    }
-    let mut result = current.clone();
-    let layout = payload(&mut result);
-    if layout
-        .lanes
-        .iter()
-        .filter(|row| row.lifeline == position.lifeline)
-        .count()
-        > 1
-    {
-        return Err(ModelError(
-            "Cannot set an ambiguous duplicate lane position.".into(),
-        ));
-    }
-    if let Some(existing) = layout
-        .lanes
-        .iter_mut()
-        .find(|row| row.lifeline == position.lifeline)
-    {
-        if existing.x != position.x {
-            *existing = position;
-        }
-    } else {
-        layout.lanes.push(position);
-    }
-    Ok(result)
-}
-
-pub fn remove_lane(p: &Project, diagram: Id, lifeline: Id) -> Result<Diagram, ModelError> {
-    let (current, owner) = editable(p, diagram)?;
-    if !lane_member(p, owner, current.layer, lifeline) {
-        return Err(ModelError(
-            "Removing a lane position requires an owned Lifeline.".into(),
-        ));
-    }
-    let mut result = current.clone();
-    if let Some(DiagramLayout::Scenario(layout)) = &mut result.layout {
-        layout.lanes.retain(|row| row.lifeline != lifeline);
-    }
-    Ok(result)
-}
-
-pub fn set_message(
-    p: &Project,
-    diagram: Id,
-    position: ScenarioMessagePosition,
-) -> Result<Diagram, ModelError> {
-    let (current, owner) = editable(p, diagram)?;
-    check_message(p, current, owner, &position.address)?;
-    if !coordinate(position.send_y) {
-        return Err(ModelError(
-            "Message position requires a finite bounded send_y coordinate.".into(),
-        ));
-    }
-    let mut result = current.clone();
-    let layout = payload(&mut result);
-    if layout
-        .messages
-        .iter()
-        .filter(|row| row.address == position.address)
-        .count()
-        > 1
-    {
-        return Err(ModelError(
-            "Cannot set an ambiguous duplicate message position.".into(),
-        ));
-    }
-    if let Some(existing) = layout
-        .messages
-        .iter_mut()
-        .find(|row| row.address == position.address)
-    {
-        if existing.send_y != position.send_y {
-            *existing = position;
-        }
-    } else {
-        layout.messages.push(position);
-    }
-    Ok(result)
-}
-
-pub fn remove_message(
-    p: &Project,
-    diagram: Id,
-    address: &OccurrenceEndpoint,
-) -> Result<Diagram, ModelError> {
-    let (current, owner) = editable(p, diagram)?;
-    check_message(p, current, owner, address)?;
-    let mut result = current.clone();
-    if let Some(DiagramLayout::Scenario(layout)) = &mut result.layout {
-        layout.messages.retain(|row| &row.address != address);
-    }
-    Ok(result)
-}
-
-/// Prune only identities in the caller's actual deletion closure, never visibility
-/// or missing endpoint assignments. Owner-view cascade remains the caller's job.
-pub fn prune_deleted(diagram: &mut Diagram, deleted: &BTreeSet<Id>) {
-    if let Some(DiagramLayout::Scenario(layout)) = &mut diagram.layout {
-        layout
-            .lanes
-            .retain(|lane| !deleted.contains(&lane.lifeline));
-        layout.messages.retain(|message| {
-            !deleted.contains(&message.address.occurrence)
-                && !message
-                    .address
-                    .references
-                    .iter()
-                    .any(|id| deleted.contains(id))
-        });
-    }
-}
-
-#[cfg(test)]
-mod tests;

crates/oa-core/src/scenario_layout/tests.rs

@@ -1,802 +0,0 @@
-use super::*;
-use crate::{
-    Element, FragmentOperator, MessageKind, ProjectionKind, Relation, RelationBody, RelationKind,
-    ScenarioViewpoint,
-};
-use std::collections::BTreeMap;
-
-struct Fixture {
-    project: Project,
-    owner: Id,
-    performer: Id,
-    lane: Id,
-    repeated_lane: Id,
-    first: Id,
-    second: Id,
-    nested: Id,
-    fragment: Id,
-    branch: Id,
-    view: Id,
-    other_view: Id,
-    exchange: Id,
-}
-
-fn set_body(element: &mut Element, body: OccurrenceBody) {
-    *element.shared_mut().unwrap() = SharedBody::Occurrence {
-        body,
-        precondition: String::new(),
-        postcondition: String::new(),
-    };
-}
-fn address(occurrence: Id) -> OccurrenceEndpoint {
-    OccurrenceEndpoint {
-        references: vec![],
-        occurrence,
-    }
-}
-fn diagram(owner: Id, alias: &str) -> Diagram {
-    Diagram {
-        id: Id::new_v4(),
-        alias: alias.into(),
-        name: alias.into(),
-        description: String::new(),
-        layer: Layer::Oa,
-        projection: ProjectionKind::Scenario { scenario: owner },
-        view_options: Default::default(),
-        nodes: BTreeMap::new(),
-        routes: vec![],
-        layout: None,
-    }
-}
-fn assert_admitted(project: &Project) {
-    let errors: Vec<_> = validation::validate(project)
-        .into_iter()
-        .filter(|issue| issue.severity == validation::Severity::Error)
-        .collect();
-    assert!(errors.is_empty(), "{errors:?}");
-}
-fn has_code(project: &Project, code: &str) -> bool {
-    validation::validate(project)
-        .iter()
-        .any(|issue| issue.code == code)
-}
-fn layout(diagram: &Diagram) -> &ScenarioLayout {
-    let Some(DiagramLayout::Scenario(layout)) = &diagram.layout else {
-        panic!("expected saved payload")
-    };
-    layout
-}
-fn save(project: &mut Project, replacement: Diagram) {
-    project.diagrams.insert(replacement.id, replacement);
-}
-fn fixture() -> Fixture {
-    let mut project = Project::empty();
-    let owner = project
-        .add_element(Kind::Scenario, Layer::Oa, "Nominal", None)
-        .unwrap();
-    let Some(SharedBody::Scenario { viewpoint, .. }) =
-        project.elements.get_mut(&owner).unwrap().shared_mut()
-    else {
-        panic!("Scenario fixture body");
-    };
-    *viewpoint = ScenarioViewpoint::ParticipantInteraction;
-    let performer = project
-        .add_element(Kind::Entity, Layer::Oa, "Controller", None)
-        .unwrap();
-    let receiver = project
-        .add_element(Kind::Entity, Layer::Oa, "Provider", None)
-        .unwrap();
-    let lane = project
-        .add_element(Kind::Lifeline, Layer::Oa, "Controller lane", Some(owner))
-        .unwrap();
-    let repeated_lane = project
-        .add_element(
-            Kind::Lifeline,
-            Layer::Oa,
-            "Controller review lane",
-            Some(owner),
-        )
-        .unwrap();
-    let receiver_lane = project
-        .add_element(Kind::Lifeline, Layer::Oa, "Provider lane", Some(owner))
-        .unwrap();
-    for (id, represented) in [
-        (lane, performer),
-        (repeated_lane, performer),
-        (receiver_lane, receiver),
-    ] {
-        *project.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Lifeline {
-            represented: Some(represented),
-        };
-    }
-    let exchange = Id::new_v4();
-    project.relations.insert(
-        exchange,
-        Relation {
-            id: exchange,
-            alias: "delivery_channel".into(),
-            name: "Delivery".into(),
-            description: String::new(),
-            body: RelationBody::new(RelationKind::CommunicationMean, performer, receiver),
-        },
-    );
-    let first = project
-        .add_element(Kind::Occurrence, Layer::Oa, "First delivery", Some(owner))
-        .unwrap();
-    let second = project
-        .add_element(Kind::Occurrence, Layer::Oa, "Second delivery", Some(owner))
-        .unwrap();
-    for (id, sender) in [(first, lane), (second, repeated_lane)] {
-        set_body(
-            project.elements.get_mut(&id).unwrap(),
-            OccurrenceBody::Exchange {
-                exchange: Some(exchange),
-                sender: Some(sender),
-                receiver: Some(receiver_lane),
-                message_kind: MessageKind::Asynchronous,
-                reply_to: None,
-                values: vec![],
-                operation: None,
-            },
-        );
-    }
-    let fragment = project
-        .add_element(
-            Kind::Occurrence,
-            Layer::Oa,
-            "Optional delivery",
-            Some(owner),
-        )
-        .unwrap();
-    set_body(
-        project.elements.get_mut(&fragment).unwrap(),
-        OccurrenceBody::Fragment {
-            operator: FragmentOperator::Optional,
-            branches: vec![],
-        },
-    );
-    let branch = project
-        .add_element(Kind::Occurrence, Layer::Oa, "Option body", Some(fragment))
-        .unwrap();
-    let nested = project
-        .add_element(
-            Kind::Occurrence,
-            Layer::Oa,
-            "Unfinished nested delivery",
-            Some(branch),
-        )
-        .unwrap();
-    set_body(
-        project.elements.get_mut(&nested).unwrap(),
-        OccurrenceBody::Exchange {
-            exchange: None,
-            sender: None,
-            receiver: None,
-            message_kind: MessageKind::Asynchronous,
-            reply_to: None,
-            values: vec![],
-            operation: None,
-        },
-    );
-    set_body(
-        project.elements.get_mut(&branch).unwrap(),
-        OccurrenceBody::Branch {
-            guard: "requested".into(),
-            occurrences: vec![nested],
-        },
-    );
-    set_body(
-        project.elements.get_mut(&fragment).unwrap(),
-        OccurrenceBody::Fragment {
-            operator: FragmentOperator::Optional,
-            branches: vec![branch],
-        },
-    );
-    *project
-        .elements
-        .get_mut(&owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap() = vec![first, second, fragment];
-    let view_record = diagram(owner, "nominal_view");
-    let other_record = diagram(owner, "review_view");
-    let view = view_record.id;
-    let other_view = other_record.id;
-    save(&mut project, view_record);
-    save(&mut project, other_record);
-    assert_admitted(&project);
-    Fixture {
-        project,
-        owner,
-        performer,
-        lane,
-        repeated_lane,
-        first,
-        second,
-        nested,
-        fragment,
-        branch,
-        view,
-        other_view,
-        exchange,
-    }
-}
-
-#[test]
-fn two_views_and_repeated_semantic_definitions_keep_independent_overrides() {
-    let mut f = fixture();
-    let semantics = (f.project.elements.clone(), f.project.relations.clone());
-    for (view, line, x) in [
-        (f.view, f.lane, 420.),
-        (f.view, f.repeated_lane, 680.),
-        (f.other_view, f.lane, 900.),
-    ] {
-        let result =
-            set_lane(&f.project, view, ScenarioLanePosition { lifeline: line, x }).unwrap();
-        save(&mut f.project, result);
-    }
-    for (view, id, y) in [
-        (f.view, f.first, 200.),
-        (f.view, f.second, 350.),
-        (f.other_view, f.first, 260.),
-    ] {
-        let result = set_message(
-            &f.project,
-            view,
-            ScenarioMessagePosition {
-                address: address(id),
-                send_y: y,
-            },
-        )
-        .unwrap();
-        save(&mut f.project, result);
-    }
-    assert_eq!(
-        layout(&f.project.diagrams[&f.view]).lanes,
-        vec![
-            ScenarioLanePosition {
-                lifeline: f.lane,
-                x: 420.
-            },
-            ScenarioLanePosition {
-                lifeline: f.repeated_lane,
-                x: 680.
-            },
-        ]
-    );
-    assert_eq!(
-        layout(&f.project.diagrams[&f.view])
-            .messages
-            .iter()
-            .map(|r| (r.address.occurrence, r.send_y))
-            .collect::<Vec<_>>(),
-        vec![(f.first, 200.), (f.second, 350.)]
-    );
-    assert_eq!(
-        layout(&f.project.diagrams[&f.other_view]).messages[0].send_y,
-        260.
-    );
-    assert_eq!(layout(&f.project.diagrams[&f.other_view]).lanes[0].x, 900.);
-    assert_eq!(
-        (f.project.elements.clone(), f.project.relations.clone()),
-        semantics
-    );
-    assert_admitted(&f.project);
-}
-
-#[test]
-fn own_nested_unfinished_message_is_admitted_but_expansion_is_not() {
-    let mut f = fixture();
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.nested),
-            send_y: -80.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    assert_admitted(&f.project);
-    let before = f.project.clone();
-    let expanded = OccurrenceEndpoint {
-        references: vec![f.fragment],
-        occurrence: f.nested,
-    };
-    assert!(
-        set_message(
-            &f.project,
-            f.view,
-            ScenarioMessagePosition {
-                address: expanded.clone(),
-                send_y: 400.
-            }
-        )
-        .is_err()
-    );
-    assert!(remove_message(&f.project, f.view, &expanded).is_err());
-    assert_eq!(f.project, before);
-    payload(f.project.diagrams.get_mut(&f.view).unwrap()).messages[0].address = expanded;
-    assert!(has_code(&f.project, "scenario_layout_address"));
-}
-
-#[test]
-fn only_ordered_message_appearances_and_owned_lifelines_are_targets() {
-    let mut f = fixture();
-    assert!(
-        set_lane(
-            &f.project,
-            f.view,
-            ScenarioLanePosition {
-                lifeline: f.performer,
-                x: 10.
-            }
-        )
-        .is_err()
-    );
-    for id in [f.exchange, f.fragment, f.branch, f.owner, Id::new_v4()] {
-        assert!(
-            set_message(
-                &f.project,
-                f.view,
-                ScenarioMessagePosition {
-                    address: address(id),
-                    send_y: 100.
-                }
-            )
-            .is_err()
-        );
-    }
-    let foreign = f
-        .project
-        .add_element(Kind::Scenario, Layer::Oa, "Foreign", None)
-        .unwrap();
-    let foreign_lane = f
-        .project
-        .add_element(Kind::Lifeline, Layer::Oa, "Foreign lane", Some(foreign))
-        .unwrap();
-    assert!(remove_lane(&f.project, f.view, foreign_lane).is_err());
-    f.project.elements.get_mut(&f.first).unwrap().parent = Some(foreign);
-    assert!(
-        set_message(
-            &f.project,
-            f.view,
-            ScenarioMessagePosition {
-                address: address(f.first),
-                send_y: 100.
-            }
-        )
-        .is_err()
-    );
-    f.project.elements.get_mut(&f.first).unwrap().parent = Some(f.owner);
-    f.project
-        .elements
-        .get_mut(&f.owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .retain(|id| *id != f.first);
-    assert!(
-        set_message(
-            &f.project,
-            f.view,
-            ScenarioMessagePosition {
-                address: address(f.first),
-                send_y: 100.
-            }
-        )
-        .is_err()
-    );
-}
-
-#[test]
-fn duplicate_positions_reject_even_when_values_match() {
-    let mut f = fixture();
-    let lane = ScenarioLanePosition {
-        lifeline: f.lane,
-        x: 10.,
-    };
-    let message = ScenarioMessagePosition {
-        address: address(f.first),
-        send_y: 100.,
-    };
-    let entries = payload(f.project.diagrams.get_mut(&f.view).unwrap());
-    entries.lanes = vec![lane.clone(), lane.clone()];
-    entries.messages = vec![message.clone(), message.clone()];
-    assert!(has_code(&f.project, "duplicate_scenario_lane"));
-    assert!(has_code(&f.project, "duplicate_scenario_message"));
-    assert!(set_lane(&f.project, f.view, lane).is_err());
-    assert!(set_message(&f.project, f.view, message).is_err());
-    // Explicit removal can repair all duplicates of the targeted identity.
-    let result = remove_lane(&f.project, f.view, f.lane).unwrap();
-    save(&mut f.project, result);
-    let result = remove_message(&f.project, f.view, &address(f.first)).unwrap();
-    save(&mut f.project, result);
-    assert_admitted(&f.project);
-}
-
-#[test]
-fn sparse_absence_empty_payload_and_signed_zero_are_preserved() {
-    let mut f = fixture();
-    let absent = f.project.diagrams[&f.view].clone();
-    assert_eq!(remove_lane(&f.project, f.view, f.lane).unwrap(), absent);
-    assert_eq!(
-        remove_message(&f.project, f.view, &address(f.first)).unwrap(),
-        absent
-    );
-    assert!(
-        serde_json::to_value(&absent)
-            .unwrap()
-            .get("layout")
-            .is_none()
-    );
-    let result = set_lane(
-        &f.project,
-        f.view,
-        ScenarioLanePosition {
-            lifeline: f.lane,
-            x: -0.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.first),
-            send_y: -0.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    let result = set_lane(
-        &f.project,
-        f.view,
-        ScenarioLanePosition {
-            lifeline: f.lane,
-            x: 0.,
-        },
-    )
-    .unwrap();
-    assert_eq!(layout(&result).lanes[0].x.to_bits(), (-0.0_f32).to_bits());
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.first),
-            send_y: 0.,
-        },
-    )
-    .unwrap();
-    assert_eq!(
-        layout(&result).messages[0].send_y.to_bits(),
-        (-0.0_f32).to_bits()
-    );
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        serde_json::to_string(&f.project.diagrams[&f.view]).unwrap()
-    );
-    let result = remove_lane(&f.project, f.view, f.lane).unwrap();
-    save(&mut f.project, result);
-    let result = remove_message(&f.project, f.view, &address(f.first)).unwrap();
-    assert_eq!(
-        result.layout,
-        Some(DiagramLayout::Scenario(ScenarioLayout::default()))
-    );
-    assert_ne!(result, absent);
-}
-
-#[test]
-fn bounds_are_structural_and_rejected_helpers_do_not_mutate_project() {
-    let mut f = fixture();
-    for value in [-MAX_COORDINATE, MAX_COORDINATE, -7., 0.] {
-        let result = set_lane(
-            &f.project,
-            f.view,
-            ScenarioLanePosition {
-                lifeline: f.lane,
-                x: value,
-            },
-        )
-        .unwrap();
-        save(&mut f.project, result);
-        let result = set_message(
-            &f.project,
-            f.view,
-            ScenarioMessagePosition {
-                address: address(f.first),
-                send_y: value,
-            },
-        )
-        .unwrap();
-        save(&mut f.project, result);
-        assert_admitted(&f.project);
-    }
-    let before = serde_json::to_string(&f.project).unwrap();
-    for value in [
-        f32::NAN,
-        f32::INFINITY,
-        f32::NEG_INFINITY,
-        MAX_COORDINATE + 1.,
-    ] {
-        assert!(
-            set_lane(
-                &f.project,
-                f.view,
-                ScenarioLanePosition {
-                    lifeline: f.lane,
-                    x: value
-                }
-            )
-            .is_err()
-        );
-        assert!(
-            set_message(
-                &f.project,
-                f.view,
-                ScenarioMessagePosition {
-                    address: address(f.first),
-                    send_y: value
-                }
-            )
-            .is_err()
-        );
-    }
-    assert_eq!(serde_json::to_string(&f.project).unwrap(), before);
-    payload(f.project.diagrams.get_mut(&f.view).unwrap()).messages[0].send_y = f32::NAN;
-    assert!(has_code(&f.project, "scenario_layout_coordinate"));
-}
-
-#[test]
-fn helpers_do_not_validate_unrelated_transient_records_in_repair_batches() {
-    let mut f = fixture();
-    payload(f.project.diagrams.get_mut(&f.view).unwrap())
-        .messages
-        .push(ScenarioMessagePosition {
-            address: address(f.second),
-            send_y: f32::INFINITY,
-        });
-    let result = set_lane(
-        &f.project,
-        f.view,
-        ScenarioLanePosition {
-            lifeline: f.lane,
-            x: 420.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    assert!(has_code(&f.project, "scenario_layout_coordinate"));
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.second),
-            send_y: 300.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    assert_admitted(&f.project);
-}
-
-#[test]
-fn projection_context_and_architecture_payloads_are_explicitly_separate() {
-    let mut f = fixture();
-    let scenario = f.project.diagrams[&f.view].projection;
-    assert_eq!(scenario.scenario(), Some(f.owner));
-    assert!(!scenario.is_architecture());
-    assert!(!scenario.includes(Kind::Lifeline));
-    assert!(ProjectionKind::Overview.is_architecture());
-    assert!(!ProjectionKind::StateMachine { machine: f.owner }.is_architecture());
-    f.project.diagrams.get_mut(&f.view).unwrap().layer = Layer::Sa;
-    assert!(has_code(&f.project, "scenario_diagram_context"));
-    assert!(remove_lane(&f.project, f.view, f.lane).is_err());
-    f.project.diagrams.get_mut(&f.view).unwrap().layer = Layer::Oa;
-    f.project
-        .diagrams
-        .get_mut(&f.view)
-        .unwrap()
-        .routes
-        .push(crate::EdgeRoute {
-            edge: f.exchange,
-            source_attachment: None,
-            target_attachment: None,
-            waypoints: vec![],
-            label: None,
-        });
-    assert!(has_code(&f.project, "scenario_diagram_content"));
-    f.project.diagrams.get_mut(&f.view).unwrap().routes.clear();
-    payload(f.project.diagrams.get_mut(&f.view).unwrap());
-    f.project.diagrams.get_mut(&f.view).unwrap().projection = ProjectionKind::Overview;
-    assert!(has_code(&f.project, "scenario_layout_projection"));
-    assert!(
-        set_lane(
-            &f.project,
-            f.view,
-            ScenarioLanePosition {
-                lifeline: f.lane,
-                x: 10.
-            }
-        )
-        .is_err()
-    );
-}
-
-#[test]
-fn typed_json_records_round_trip_and_reject_unknown_or_missing_fields() {
-    let mut f = fixture();
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.first),
-            send_y: 200.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    let encoded = serde_json::to_value(&f.project.diagrams[&f.view]).unwrap();
-    assert_eq!(
-        serde_json::from_value::<Diagram>(encoded.clone()).unwrap(),
-        f.project.diagrams[&f.view]
-    );
-    assert_eq!(
-        encoded["layout"]["Scenario"]["messages"][0]["address"]["occurrence"],
-        serde_json::json!(f.first)
-    );
-    let mut unknown = encoded.clone();
-    unknown["layout"]["Scenario"]["messages"][0]["extra"] = serde_json::json!(1);
-    assert!(serde_json::from_value::<Diagram>(unknown).is_err());
-    let mut missing = encoded;
-    missing["layout"]["Scenario"]["messages"][0]["address"]
-        .as_object_mut()
-        .unwrap()
-        .remove("references");
-    assert!(serde_json::from_value::<Diagram>(missing).is_err());
-}
-
-#[test]
-fn deleting_only_actual_ids_preserves_latent_message_positions_and_other_views() {
-    let mut f = fixture();
-    let result = set_lane(
-        &f.project,
-        f.view,
-        ScenarioLanePosition {
-            lifeline: f.lane,
-            x: 420.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    let result = set_message(
-        &f.project,
-        f.view,
-        ScenarioMessagePosition {
-            address: address(f.first),
-            send_y: 200.,
-        },
-    )
-    .unwrap();
-    save(&mut f.project, result);
-    let mut copied = f.project.diagrams[&f.view].clone();
-    copied.id = f.other_view;
-    copied.alias = "review_view".into();
-    copied.name = "Review view".into();
-    save(&mut f.project, copied.clone());
-    assert_admitted(&f.project);
-    assert_eq!(layout(&copied).messages[0].address.occurrence, f.first);
-    let mut candidate = f.project.diagrams[&f.view].clone();
-    prune_deleted(&mut candidate, &BTreeSet::from([f.lane, f.exchange]));
-    assert!(layout(&candidate).lanes.is_empty());
-    assert_eq!(layout(&candidate).messages.len(), 1);
-    prune_deleted(&mut candidate, &BTreeSet::from([f.first]));
-    assert!(layout(&candidate).messages.is_empty());
-    assert!(candidate.layout.is_some());
-    assert_eq!(f.project.diagrams[&f.other_view], copied);
-}
-
-#[test]
-fn reference_visitor_and_record_count_cover_explicit_rows() {
-    let f = fixture();
-    let mut d = f.project.diagrams[&f.view].clone();
-    assert_eq!(record_count(&d), 0);
-    let rows = payload(&mut d);
-    rows.lanes.push(ScenarioLanePosition {
-        lifeline: f.lane,
-        x: 50.,
-    });
-    rows.messages.push(ScenarioMessagePosition {
-        address: address(f.first),
-        send_y: 100.,
-    });
-    assert_eq!(record_count(&d), 3);
-    let replacement = Id::new_v4();
-    d.layout.as_mut().unwrap().visit_references(|id| {
-        if *id == f.first {
-            *id = replacement;
-        }
-    });
-    assert_eq!(layout(&d).messages[0].address.occurrence, replacement);
-    assert_eq!(layout(&d).messages[0].send_y, 100.);
-    assert_eq!(layout(&d).lanes[0].lifeline, f.lane);
-}
-
-#[test]
-fn a_real_scenario_use_never_imports_its_called_message_as_a_direct_target() {
-    let mut f = fixture();
-    let called = f
-        .project
-        .add_element(Kind::Scenario, Layer::Oa, "Called sequence", None)
-        .unwrap();
-    let Some(SharedBody::Scenario { viewpoint, .. }) =
-        f.project.elements.get_mut(&called).unwrap().shared_mut()
-    else {
-        panic!("Called Scenario fixture body");
-    };
-    *viewpoint = ScenarioViewpoint::ParticipantInteraction;
-    let called_message = f
-        .project
-        .add_element(Kind::Occurrence, Layer::Oa, "Called delivery", Some(called))
-        .unwrap();
-    set_body(
-        f.project.elements.get_mut(&called_message).unwrap(),
-        OccurrenceBody::Exchange {
-            exchange: None,
-            sender: None,
-            receiver: None,
-            message_kind: MessageKind::Asynchronous,
-            reply_to: None,
-            values: vec![],
-            operation: None,
-        },
-    );
-    *f.project
-        .elements
-        .get_mut(&called)
-        .unwrap()
-        .steps_mut()
-        .unwrap() = vec![called_message];
-    let usage = f
-        .project
-        .add_element(Kind::Occurrence, Layer::Oa, "Call sequence", Some(f.owner))
-        .unwrap();
-    set_body(
-        f.project.elements.get_mut(&usage).unwrap(),
-        OccurrenceBody::ScenarioUse {
-            scenario: Some(called),
-            bindings: vec![],
-        },
-    );
-    f.project
-        .elements
-        .get_mut(&f.owner)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .push(usage);
-    assert_admitted(&f.project);
-    for target in [
-        address(called_message),
-        address(usage),
-        OccurrenceEndpoint {
-            references: vec![usage],
-            occurrence: called_message,
-        },
-    ] {
-        assert!(
-            set_message(
-                &f.project,
-                f.view,
-                ScenarioMessagePosition {
-                    address: target,
-                    send_y: 200.
-                }
-            )
-            .is_err()
-        );
-    }
-}
-
-mod source_lifecycle;

crates/oa-core/src/scenario_layout/tests/source_lifecycle.rs

@@ -1,302 +0,0 @@
-//! Source/command lifecycle checks for the candidate payload. Public version
-//! assignment remains the coordinated codec integration gate.
-use super::*;
-use crate::{Command, Session, language, prepare_command, source_project::*};
-
-fn authored(f: &Fixture) -> CompiledSourceProject {
-    let mut bundle = format_bundle(&f.project);
-    let initial = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let location = &initial.index.declarations[&f.view];
-    let source = bundle.files.get_mut(&location.path).unwrap();
-    let text = format!(
-        r#"diagram nominal_view "Nominal review" id "{}" {{
- projection {{ Scenario {{ scenario @{}; }}; }};
- layout {{ Scenario {{
-  lanes [
-   // Controller spacing rationale.
-   {{ lifeline @ // first lane identity
-      {}; x 4.20e2; }},
-   // Repeated performer has its own lane.
-   {{ lifeline @{}; x 680; }}
-  ];
-  messages [
-   // First delivery timing rationale.
-   {{ address {{ references []; occurrence @{}; }}; send_y 2.00e2; }},
-   // Second delivery timing rationale.
-   {{ address {{ references []; occurrence @{}; }}; send_y 350; }}
-  ];
- }}; }};
-}}
-"#,
-        f.view,
-        f.project.elements[&f.owner].alias,
-        f.project.elements[&f.lane].alias,
-        f.project.elements[&f.repeated_lane].alias,
-        f.project.elements[&f.first].alias,
-        f.project.elements[&f.second].alias
-    );
-    source.replace_range(location.span.start..location.span.end, &text);
-    compile_bundle(&bundle, ProjectLimits::default()).unwrap()
-}
-
-#[test]
-fn source_rows_follow_identity_order_and_keep_comments_numeric_spelling_and_file_ownership() {
-    let f = fixture();
-    let original = authored(&f);
-    let mut changed = original.decoded.project.clone();
-    let rows = payload(changed.diagrams.get_mut(&f.view).unwrap());
-    rows.lanes.swap(0, 1);
-    rows.messages.swap(0, 1);
-    rows.messages[0].send_y = 390.;
-    changed.elements.get_mut(&f.lane).unwrap().alias = "renamed_controller_lane".into();
-    let updated = update_bundle(&original, &changed, ProjectLimits::default()).unwrap();
-    assert_eq!(updated.decoded.project, changed);
-    let path = &original.index.declarations[&f.view].path;
-    assert_eq!(&updated.index.declarations[&f.view].path, path);
-    let text = &updated.bundle.files[path];
-    assert!(
-        text.find("// Repeated performer").unwrap() < text.find("// Controller spacing").unwrap(),
-        "{text}"
-    );
-    assert!(
-        text.find("// Second delivery").unwrap() < text.find("// First delivery").unwrap(),
-        "{text}"
-    );
-    assert!(
-        text.contains(
-            "lifeline @ // first lane identity\n      renamed_controller_lane; x 4.20e2;"
-        ),
-        "{text}"
-    );
-    assert!(text.contains("send_y 2.00e2"), "{text}");
-    assert!(text.contains("send_y 390"), "{text}");
-    for (other, bytes) in &original.bundle.files {
-        if other != path && !bytes.contains(&f.project.elements[&f.lane].alias) {
-            assert_eq!(&updated.bundle.files[other], bytes);
-        }
-    }
-    assert_eq!(
-        compile_bundle(&updated.bundle, ProjectLimits::default())
-            .unwrap()
-            .decoded
-            .project,
-        changed
-    );
-}
-
-#[test]
-fn source_identity_swap_keeps_each_coordinate_comment_with_its_original_object() {
-    let f = fixture();
-    let original = authored(&f);
-    let temporary = Id::new_v4();
-    let command = Command::Batch(vec![
-        Command::Reidentify(f.first, temporary),
-        Command::Reidentify(f.second, f.first),
-        Command::Reidentify(temporary, f.second),
-    ]);
-    let prepared = prepare_command(&original.decoded.project, &command).unwrap();
-    let mut changed = prepared.project;
-    payload(changed.diagrams.get_mut(&f.view).unwrap())
-        .messages
-        .swap(0, 1);
-    let updated = update_bundle_with_identity_map(
-        &original,
-        &changed,
-        &prepared.identity_map,
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    assert_eq!(updated.decoded.project, changed);
-    let path = &original.index.declarations[&f.view].path;
-    let text = &updated.bundle.files[path];
-    assert!(
-        text.find("// Second delivery").unwrap() < text.find("// First delivery").unwrap(),
-        "{text}"
-    );
-    let first_comment = text.find("// First delivery").unwrap();
-    assert!(text[first_comment..].contains(&format!(
-        "occurrence @{}",
-        changed.elements[&f.second].alias
-    )));
-    assert!(text[first_comment..].contains("send_y 2.00e2"));
-}
-
-#[test]
-fn coordinate_batch_is_one_undo_and_numeric_noop_keeps_source_exact() {
-    let f = fixture();
-    let original = authored(&f);
-    let mut session = Session::new(original.decoded.project.clone());
-    session
-        .execute(Command::Batch(vec![
-            Command::SetScenarioLanePosition {
-                diagram: f.view,
-                position: ScenarioLanePosition {
-                    lifeline: f.lane,
-                    x: 510.,
-                },
-            },
-            Command::SetScenarioMessagePosition {
-                diagram: f.view,
-                position: ScenarioMessagePosition {
-                    address: address(f.second),
-                    send_y: 430.,
-                },
-            },
-        ]))
-        .unwrap();
-    let changed = session.project().clone();
-    assert_eq!(session.revision(), 1);
-    assert_eq!(changed.elements, original.decoded.project.elements);
-    assert_eq!(changed.relations, original.decoded.project.relations);
-    let updated = update_bundle(&original, &changed, ProjectLimits::default()).unwrap();
-    session.undo();
-    assert_eq!(session.project(), &original.decoded.project);
-    assert!(!session.can_undo());
-    session.redo();
-    assert_eq!(session.project(), &changed);
-    session
-        .execute(Command::SetScenarioMessagePosition {
-            diagram: f.view,
-            position: ScenarioMessagePosition {
-                address: address(f.second),
-                send_y: 430.,
-            },
-        })
-        .unwrap();
-    assert_eq!(session.revision(), 3);
-    let noop = update_bundle(&updated, session.project(), ProjectLimits::default()).unwrap();
-    assert_eq!(noop.bundle, updated.bundle);
-}
-
-#[test]
-fn absent_and_empty_payload_round_trip_distinctly_and_remove_does_not_materialize_absence() {
-    let f = fixture();
-    let before = language::format(&f.project);
-    let mut session = Session::new(f.project.clone());
-    session
-        .execute(Command::RemoveScenarioLanePosition {
-            diagram: f.view,
-            lifeline: f.lane,
-        })
-        .unwrap();
-    assert_eq!(session.project(), &f.project);
-    assert!(!session.can_undo());
-    assert_eq!(language::format(session.project()), before);
-    let mut present = f.project.clone();
-    present.diagrams.get_mut(&f.view).unwrap().layout =
-        Some(DiagramLayout::Scenario(ScenarioLayout::default()));
-    let text = language::format(&present);
-    assert_ne!(text, before);
-    assert_eq!(language::parse(&text).unwrap(), present);
-    assert_eq!(language::parse(&before).unwrap(), f.project);
-}
-
-#[test]
-fn invalid_layout_source_rejects_without_changing_last_compiled_workspace() {
-    let f = fixture();
-    let original = authored(&f);
-    let before = original.bundle.clone();
-    let path = original.index.declarations[&f.view].path.clone();
-    for replacement in ["x 1e30", "x not_a_number"] {
-        let mut candidate = before.clone();
-        let source = candidate.files.get_mut(&path).unwrap();
-        *source = source.replace("x 4.20e2", replacement);
-        assert!(compile_bundle(&candidate, ProjectLimits::default()).is_err());
-        assert_eq!(original.bundle, before);
-    }
-    let mut candidate = before.clone();
-    let source = candidate.files.get_mut(&path).unwrap();
-    *source = source.replace(
-        &format!("occurrence @{}", f.project.elements[&f.first].alias),
-        &format!("occurrence @{}", f.project.elements[&f.performer].alias),
-    );
-    assert!(compile_bundle(&candidate, ProjectLimits::default()).is_err());
-    assert_eq!(original.bundle, before);
-}
-
-#[test]
-fn explicit_none_survives_other_edits_while_real_payload_clear_removes_values() {
-    let f = fixture();
-    let mut bundle = format_bundle(&f.project);
-    let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let location = &compiled.index.declarations[&f.view];
-    let path = location.path.clone();
-    bundle.files.get_mut(&path).unwrap().insert_str(
-        location.span.end - 1,
-        "\n layout // explicitly automatic\n none;\n",
-    );
-    let original = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let mut described = original.decoded.project.clone();
-    described.diagrams.get_mut(&f.view).unwrap().description =
-        "Review spacing independently".into();
-    let updated = update_bundle(&original, &described, ProjectLimits::default()).unwrap();
-    assert!(updated.bundle.files[&path].contains("layout // explicitly automatic\n none;"));
-    assert_eq!(updated.decoded.project, described);
-    let mut empty = described.clone();
-    empty.diagrams.get_mut(&f.view).unwrap().layout =
-        Some(DiagramLayout::Scenario(ScenarioLayout::default()));
-    let present = update_bundle(&updated, &empty, ProjectLimits::default()).unwrap();
-    assert_eq!(present.decoded.project, empty);
-    assert!(present.bundle.files[&path].contains("// explicitly automatic"));
-    let cleared = update_bundle(&present, &described, ProjectLimits::default()).unwrap();
-    assert_eq!(cleared.decoded.project, described);
-    assert!(!cleared.bundle.files[&path].contains("layout"));
-    assert!(cleared.bundle.files[&path].contains("// explicitly automatic"));
-}
-
-#[test]
-fn compact_defaults_and_scenario_row_identity_compose_through_rename_and_clear() {
-    let f = fixture();
-    let initial = authored(&f);
-    let mut bundle = initial.bundle.clone();
-    let location = &initial.index.declarations[&f.performer];
-    bundle.files.get_mut(&location.path).unwrap().insert_str(
-        location.span.end - 1,
-        "\n description // explicitly default prose\n \"\";\n",
-    );
-    let original = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let mut expected = original.decoded.project.clone();
-    let performer = expected.elements.get_mut(&f.performer).unwrap();
-    performer.name = "Reviewed controller".into();
-    performer.alias = "reviewed_controller".into();
-    expected.elements.get_mut(&f.lane).unwrap().alias = "reviewed_lane".into();
-    let rows = payload(expected.diagrams.get_mut(&f.view).unwrap());
-    rows.lanes.swap(0, 1);
-    rows.messages.swap(0, 1);
-    rows.messages[0].send_y = 390.;
-    let updated = update_bundle(&original, &expected, ProjectLimits::default()).unwrap();
-    assert_eq!(updated.decoded.project, expected);
-    let element = &updated.index.declarations[&f.performer];
-    let text = &updated.bundle.files[&element.path][element.span.start..element.span.end];
-    assert!(
-        text.contains("description // explicitly default prose\n \"\";"),
-        "{text}"
-    );
-    assert!(
-        !text.contains("categories"),
-        "an omitted default must stay omitted: {text}"
-    );
-    let diagram = &updated.index.declarations[&f.view];
-    let text = &updated.bundle.files[&diagram.path][diagram.span.start..diagram.span.end];
-    assert!(
-        text.find("// Repeated performer").unwrap() < text.find("// Controller spacing").unwrap()
-    );
-    assert!(text.contains("reviewed_lane; x 4.20e2;"), "{text}");
-    assert!(text.find("// Second delivery").unwrap() < text.find("// First delivery").unwrap());
-    assert!(text.contains("send_y 2.00e2"), "{text}");
-    assert!(!text.contains("view_options"), "{text}");
-    expected.diagrams.get_mut(&f.view).unwrap().layout = None;
-    let cleared = update_bundle(&updated, &expected, ProjectLimits::default()).unwrap();
-    assert_eq!(cleared.decoded.project, expected);
-    let declaration = &cleared.index.declarations[&f.view];
-    let text =
-        &cleared.bundle.files[&declaration.path][declaration.span.start..declaration.span.end];
-    assert!(!text.contains("layout"), "{text}");
-    assert!(text.contains("// Controller spacing rationale."), "{text}");
-    assert_eq!(
-        update_bundle(&cleared, &expected, ProjectLimits::default())
-            .unwrap()
-            .bundle,
-        cleared.bundle,
-    );
-}

crates/oa-core/src/session.rs

@@ -23,22 +23,6 @@ pub enum Command {
     EditRelation(Id, Relation),
     CreateDiagram(Diagram),
     EditDiagram(Id, Diagram),
-    SetScenarioLanePosition {
-        diagram: Id,
-        position: ScenarioLanePosition,
-    },
-    RemoveScenarioLanePosition {
-        diagram: Id,
-        lifeline: Id,
-    },
-    SetScenarioMessagePosition {
-        diagram: Id,
-        position: ScenarioMessagePosition,
-    },
-    RemoveScenarioMessagePosition {
-        diagram: Id,
-        address: OccurrenceEndpoint,
-    },
     CreateArtifact(ArtifactLink),
     EditArtifact(Id, ArtifactLink),
     CreateTrace(Trace),
@@ -504,26 +488,6 @@ fn apply_command(
             reidentify_tracked(p, *old, value.id, provenance)?;
             Some(value.id)
         }
-        Command::SetScenarioLanePosition { diagram, position } => {
-            let replacement = crate::scenario_layout::set_lane(p, *diagram, position.clone())?;
-            p.diagrams.insert(*diagram, replacement);
-            Some(*diagram)
-        }
-        Command::RemoveScenarioLanePosition { diagram, lifeline } => {
-            let replacement = crate::scenario_layout::remove_lane(p, *diagram, *lifeline)?;
-            p.diagrams.insert(*diagram, replacement);
-            Some(*diagram)
-        }
-        Command::SetScenarioMessagePosition { diagram, position } => {
-            let replacement = crate::scenario_layout::set_message(p, *diagram, position.clone())?;
-            p.diagrams.insert(*diagram, replacement);
-            Some(*diagram)
-        }
-        Command::RemoveScenarioMessagePosition { diagram, address } => {
-            let replacement = crate::scenario_layout::remove_message(p, *diagram, address)?;
-            p.diagrams.insert(*diagram, replacement);
-            Some(*diagram)
-        }
         Command::CreateArtifact(value) => {
             vacant(p, value.id)?;
             p.artifact_links.insert(value.id, value.clone());
@@ -914,7 +878,6 @@ pub fn reidentify(p: &mut Project, old: Id, new: Id) -> Result<(), ModelError> {
         return Ok(());
     }
     vacant(p, new)?;
-    crate::references::check_remap(p, old, new)?;
     if p.id == old {
         p.id = new;
     } else if let Some(mut v) = p.elements.remove(&old) {
@@ -941,17 +904,12 @@ pub fn reidentify(p: &mut Project, old: Id, new: Id) -> Result<(), ModelError> {
             }
         }
     }
-    crate::references::remap_references(p, old, new)?;
+    crate::references::remap_references(p, old, new);
     Ok(())
 }
 fn layout(p: &mut Project, diagram: Id) -> Result<(), ModelError> {
     use std::collections::{BTreeMap, BTreeSet};
     let d = p.diagrams.get(&diagram).ok_or_else(missing)?;
-    if d.projection.scenario().is_some() {
-        return Err(ModelError(
-            "Scenario layout requires the Scenario geometry operation.".into(),
-        ));
-    }
     let parents = crate::projection::parents(p, d);
     let mut children: BTreeMap<Option<Id>, Vec<Id>> = BTreeMap::new();
     for (id, parent) in &parents {

crates/oa-core/src/source_defaults.rs

@@ -52,13 +52,7 @@ pub(crate) fn parser_fields(context: Context) -> Map<String, Value> {
                 _ => &["source", "target"],
             }
         }
-        Context::Diagram => {
-            // Admit the optional payload without restoring a synthetic null in
-            // CompleteForEdit: absence there distinguishes a real layout clear
-            // from an unrelated edit beside an authored explicit `layout none`.
-            fields.insert("layout".into(), Value::Null);
-            &[]
-        }
+        Context::Diagram => &[],
         Context::Node => &["element"],
         Context::Artifact => &["owner"],
         Context::Trace => &["oa", "sa"],
@@ -99,18 +93,6 @@ fn restore_serialization_skips(context: Context, fields: &mut Map<String, Value>
                     .or_insert(Value::Null);
             }
         }
-        Context::Diagram => {
-            if let Some(routes) = fields.get_mut("routes").and_then(Value::as_array_mut) {
-                for route in routes.iter_mut().filter_map(Value::as_object_mut) {
-                    route
-                        .entry("source_attachment".to_owned())
-                        .or_insert(Value::Null);
-                    route
-                        .entry("target_attachment".to_owned())
-                        .or_insert(Value::Null);
-                }
-            }
-        }
         Context::Node => {
             fields.entry("port_anchors".to_owned()).or_insert(json!([]));
         }
@@ -262,12 +244,7 @@ fn compact_nested(context: Context, fields: &mut Map<String, Value>) {
             if let Some(routes) = fields.get_mut("routes").and_then(Value::as_array_mut) {
                 for route in routes {
                     if let Some(route) = route.as_object_mut() {
-                        omit_defaults(
-                            route,
-                            &object(
-                                json!({"waypoints": [], "label": null, "source_attachment": null, "target_attachment": null}),
-                            ),
-                        );
+                        omit_defaults(route, &object(json!({"waypoints": [], "label": null})));
                     }
                 }
             }

crates/oa-core/src/source_project.rs

@@ -972,18 +972,7 @@ pub fn update_bundle_with_identity_map(
             };
             let local = edits.entry(path.clone()).or_default();
             update.header(&actual.header, &previous.header, &next.header, local);
-            let context = if old.diagrams.contains_key(&id) {
-                EditContext::Diagram
-            } else {
-                EditContext::Other
-            };
-            update.value(
-                &actual.fields,
-                Some(&previous.fields),
-                &next.fields,
-                context,
-                local,
-            );
+            update.value(&actual.fields, Some(&previous.fields), &next.fields, local);
         }
     }
     if old.id != project.id || old.alias != project.alias || old.name != project.name {
@@ -1235,29 +1224,6 @@ impl<'a> InsertionSyntax<'a> {
     }
 }
 
-// Schema context is explicit: similarly named fields in arbitrary records must
-// never acquire Scenario row identity or move their authored trivia.
-#[derive(Clone, Copy)]
-enum EditContext {
-    Other,
-    Diagram,
-    Layout,
-    Scenario,
-    Lanes,
-    Messages,
-}
-impl EditContext {
-    fn field(self, name: &str) -> Self {
-        match (self, name) {
-            (Self::Diagram, "layout") => Self::Layout,
-            (Self::Layout, "Scenario") => Self::Scenario,
-            (Self::Scenario, "lanes") => Self::Lanes,
-            (Self::Scenario, "messages") => Self::Messages,
-            _ => Self::Other,
-        }
-    }
-}
-
 struct SyntaxUpdate<'a> {
     source: &'a str,
     before: &'a str,
@@ -1335,7 +1301,6 @@ impl SyntaxUpdate<'_> {
         actual: &language::EditValue,
         before: Option<&language::EditValue>,
         after: &language::EditValue,
-        context: EditContext,
         edits: &mut LocalEdits,
     ) {
         use language::EditKind;
@@ -1351,7 +1316,7 @@ impl SyntaxUpdate<'_> {
                         None
                     }
                 });
-                self.record(actual.span, fields, previous, next, context, edits);
+                self.record(actual.span, fields, previous, next, edits);
             }
             (EditKind::List(items), EditKind::List(next)) => {
                 let previous = before.and_then(|old| {
@@ -1361,7 +1326,7 @@ impl SyntaxUpdate<'_> {
                         None
                     }
                 });
-                self.list(actual.span, items, previous, next, context, edits);
+                self.list(actual.span, items, previous, next, edits);
             }
             (EditKind::Reference(_), EditKind::Reference(alias)) => {
                 let token = significant(&self.source[actual.span.start..actual.span.end])
@@ -1414,7 +1379,6 @@ impl SyntaxUpdate<'_> {
         actual: &BTreeMap<String, language::EditField>,
         before: Option<&BTreeMap<String, language::EditField>>,
         after: &BTreeMap<String, language::EditField>,
-        context: EditContext,
         edits: &mut LocalEdits,
     ) {
         // A typed constructor tag change retains shared fields and their trivia.
@@ -1438,13 +1402,7 @@ impl SyntaxUpdate<'_> {
                     },
                     new_key.clone(),
                 ));
-                self.value(
-                    &field.value,
-                    Some(&old.value),
-                    &new.value,
-                    context.field(new_key),
-                    edits,
-                );
+                self.value(&field.value, Some(&old.value), &new.value, edits);
                 return;
             }
         }
@@ -1456,16 +1414,9 @@ impl SyntaxUpdate<'_> {
                         .and_then(|fields| fields.get(key))
                         .map(|field| &field.value),
                     &next.value,
-                    context.field(key),
                     edits,
                 );
-            } else if !(matches!(context, EditContext::Diagram)
-                && key == "layout"
-                && before.is_some_and(|fields| !fields.contains_key(key)))
-            {
-                // Canonical None omits layout. Preserve an authored explicit
-                // none while another field changes; a real Some->None clear
-                // still removes the former payload and retains its trivia.
+            } else {
                 erase_syntax(self.source, field.span, edits);
             }
         }
@@ -1519,7 +1470,6 @@ impl SyntaxUpdate<'_> {
         actual: &[language::EditValue],
         before: Option<&[language::EditValue]>,
         after: &[language::EditValue],
-        context: EditContext,
         edits: &mut LocalEdits,
     ) {
         let previous = before.unwrap_or(&[]);
@@ -1532,7 +1482,6 @@ impl SyntaxUpdate<'_> {
                     self.old_aliases,
                     self.legacy_value_paths,
                     None,
-                    context,
                 )
             })
             .collect();
@@ -1545,7 +1494,6 @@ impl SyntaxUpdate<'_> {
                     self.new_aliases,
                     self.legacy_value_paths,
                     self.identity_origins,
-                    context,
                 )
             })
             .collect();
@@ -1574,7 +1522,7 @@ impl SyntaxUpdate<'_> {
                 .all(|(i, source)| *source == Some(i))
         {
             for (i, (current, next)) in actual.iter().zip(after).enumerate() {
-                self.value(current, previous.get(i), next, EditContext::Other, edits);
+                self.value(current, previous.get(i), next, edits);
             }
             return;
         }
@@ -1607,13 +1555,7 @@ impl SyntaxUpdate<'_> {
                 let chunk = chunks[index];
                 text.push_str(&self.source[chunk.start..current.span.start]);
                 let mut local = Vec::new();
-                self.value(
-                    current,
-                    previous.get(index),
-                    next,
-                    EditContext::Other,
-                    &mut local,
-                );
+                self.value(current, previous.get(index), next, &mut local);
                 text.push_str(&changed_text(self.source, current.span, local));
                 suffix = &self.source[current.span.end..chunk.end];
             } else {
@@ -1652,58 +1594,14 @@ impl SyntaxUpdate<'_> {
     }
 }
 
-fn scenario_item_key(
-    value: &language::EditValue,
-    aliases: &BTreeMap<String, String>,
-    context: EditContext,
-) -> Option<String> {
-    use language::EditKind;
-    let EditKind::Record(fields) = &value.kind else {
-        return None;
-    };
-    let reference = |value: &language::EditValue| {
-        if let EditKind::Reference(alias) = &value.kind {
-            aliases.get(alias).cloned()
-        } else {
-            None
-        }
-    };
-    match context {
-        EditContext::Lanes => {
-            reference(&fields.get("lifeline")?.value).map(|id| format!("scenario-lane:{id}"))
-        }
-        EditContext::Messages => {
-            let EditKind::Record(address) = &fields.get("address")?.value.kind else {
-                return None;
-            };
-            let occurrence = reference(&address.get("occurrence")?.value)?;
-            let path: Vec<_> = match address.get("references") {
-                None => Vec::new(),
-                Some(field) => {
-                    let EditKind::List(path) = &field.value.kind else {
-                        return None;
-                    };
-                    path.iter().map(reference).collect::<Option<Vec<_>>>()?
-                }
-            };
-            Some(format!("scenario-message:{}:{occurrence}", path.join("/")))
-        }
-        _ => None,
-    }
-}
-
 fn item_key(
     value: &language::EditValue,
     source: &str,
     aliases: &BTreeMap<String, String>,
     legacy_value_paths: bool,
     origins: Option<&BTreeMap<Id, Id>>,
-    context: EditContext,
 ) -> Option<String> {
     use language::EditKind;
-    if matches!(context, EditContext::Lanes | EditContext::Messages) {
-        return scenario_item_key(value, aliases, context);
-    }
     if matches!(value.kind, EditKind::Record(_))
         && let Some(key) = language::semantic_row_key(
             &source[value.span.start..value.span.end],

crates/oa-core/src/source_project/source_migration.rs

@@ -72,11 +72,6 @@ pub(super) fn upgrade(
                 &actual.fields,
                 Some(&actual.fields),
                 &next.fields,
-                if project.diagrams.contains_key(&id) {
-                    EditContext::Diagram
-                } else {
-                    EditContext::Other
-                },
                 edits.entry(path.clone()).or_default(),
             );
         }

crates/oa-core/src/transitions.rs

@@ -750,7 +750,7 @@ pub fn plan_transition(
                 );
                 continue;
             }
-            if !counterpart_compatible(project, *source, target, request.direction) {
+            if !compatible_existing(project, *source, target, request.direction) {
                 conflict(
                     &mut plan,
                     Some(*source),
@@ -1317,22 +1317,12 @@ fn compatible_kinds(source: Kind, target: Kind, direction: TransitionDirection)
     }
     inferred_kind(source, direction) == Some(target)
 }
-/// Whether existing records have compatible layers, categories and kinds for
-/// an ordinary transition. This is candidate eligibility, not approval of a
-/// complete plan: properties, dependencies and structural conflicts still need
-/// the normal preview and apply validation. Manual traces are not restricted
-/// by this predicate.
-pub fn counterpart_compatible(
+fn compatible_existing(
     p: &Project,
     source: Id,
     target: Id,
     direction: TransitionDirection,
 ) -> bool {
-    if p.layer_of(source) != Some(direction.source_layer())
-        || p.layer_of(target) != Some(direction.target_layer())
-    {
-        return false;
-    }
     match (p.elements.get(&source), p.elements.get(&target)) {
         (Some(a), Some(b)) => compatible_kinds(a.kind(), b.kind(), direction),
         _ => match (p.relations.get(&source), p.relations.get(&target)) {

crates/oa-core/src/validation.rs

@@ -619,7 +619,6 @@ pub fn validate(p: &Project) -> Vec<Issue> {
         }
         text(&mut out, d.id, "name", &d.name);
         text(&mut out, d.id, "description", &d.description);
-        crate::scenario_layout::validate_diagram(p, d, &mut out);
         let option_issues = if d.projection == ProjectionKind::Traceability {
             crate::view_options::validate_options_cross_layer(p, &d.view_options)
         } else {
@@ -644,20 +643,6 @@ pub fn validate(p: &Project) -> Vec<Issue> {
         }
         let mut routed_edges = BTreeSet::new();
         for (index, route) in d.routes.iter().enumerate() {
-            for attachment in [route.source_attachment, route.target_attachment]
-                .into_iter()
-                .flatten()
-            {
-                if !attachment.offset.is_finite() || !(0.0..=1.0).contains(&attachment.offset) {
-                    error(
-                        &mut out,
-                        d.id,
-                        "invalid_attachment_offset",
-                        "routes",
-                        "Connection attachment offset must be finite and between zero and one.",
-                    );
-                }
-            }
             if !routed_edges.insert(route.edge) {
                 error(
                     &mut out,

crates/oa-core/tests/attachment_geometry.rs

@@ -1,385 +0,0 @@
-use oa_core::{projection::*, routing::*, *};
-
-fn pos(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-fn anchor(side: PortAnchorSide, offset: f32) -> EdgeAttachment {
-    EdgeAttachment { side, offset }
-}
-fn fixture() -> (Project, Id, Id, Id, Id) {
-    let mut p = Project::empty();
-    let a = p
-        .add_element(Kind::Activity, Layer::Oa, "Report", None)
-        .unwrap();
-    let b = p
-        .add_element(Kind::Activity, Layer::Oa, "Receive", None)
-        .unwrap();
-    let edge = p.relate(RelationKind::Interaction, "Report status", a, b);
-    let d = p.ensure_diagram(Layer::Oa);
-    p.place(d, a, pos(50., 50.));
-    p.place(d, b, pos(750., 200.));
-    (p, d, a, b, edge)
-}
-fn stored(edge: Id) -> EdgeRoute {
-    EdgeRoute {
-        edge,
-        source_attachment: None,
-        target_attachment: None,
-        waypoints: vec![],
-        label: None,
-    }
-}
-fn routed(p: &Project, d: Id) -> RoutedView {
-    let diagram = &p.diagrams[&d];
-    route_diagram(p, diagram, &project_diagram(p, diagram))
-}
-fn near(a: f32, b: f32) {
-    assert!((a - b).abs() < 0.002, "{a} != {b}");
-}
-fn orthogonal(points: &[Position]) {
-    assert!(points.len() >= 2);
-    for span in points.windows(2) {
-        assert!(span[0].x == span[1].x || span[0].y == span[1].y, "{span:?}");
-    }
-}
-fn length(points: &[Position]) -> f32 {
-    points
-        .windows(2)
-        .map(|p| (p[0].x - p[1].x).abs() + (p[0].y - p[1].y).abs())
-        .sum()
-}
-
-#[test]
-fn authored_boundary_follows_projected_owner_and_preview_matches_committed_geometry() {
-    let (mut p, d, a, _, edge) = fixture();
-    let initial = routed(&p, d);
-    let mut route = stored(edge);
-    route.source_attachment = Some(anchor(PortAnchorSide::Bottom, 0.25));
-    route.target_attachment = Some(anchor(PortAnchorSide::Top, 0.75));
-    route.waypoints = vec![pos(460., 350.)];
-    p.diagrams.get_mut(&d).unwrap().routes.push(route.clone());
-    let view = project_diagram(&p, &p.diagrams[&d]);
-    let preview = route_edge_preview(&p, &p.diagrams[&d], &view, &initial, edge);
-    let full = routed(&p, d);
-    assert_eq!(
-        preview, full,
-        "attachment-only changes must invalidate the label-only path cache"
-    );
-    let n = view.nodes.iter().find(|n| n.element == a).unwrap();
-    assert_eq!(
-        full.edges[&edge].points[0],
-        pos(
-            n.position.x + n.size.width * 0.25,
-            n.position.y + n.size.height
-        )
-    );
-    assert_eq!(full.edges[&edge].pins, route.waypoints);
-    orthogonal(&full.edges[&edge].points);
-    let node = p
-        .diagrams
-        .get_mut(&d)
-        .unwrap()
-        .nodes
-        .values_mut()
-        .find(|n| n.element == a)
-        .unwrap();
-    node.position.x += 75.;
-    node.size.width += 100.;
-    node.size.height += 50.;
-    let moved = routed(&p, d);
-    near(
-        moved.edges[&edge].points[0].x - full.edges[&edge].points[0].x,
-        100.,
-    );
-    near(
-        moved.edges[&edge].points[0].y - full.edges[&edge].points[0].y,
-        50.,
-    );
-    assert_eq!(p.diagrams[&d].routes[0], route);
-}
-
-#[test]
-fn attachment_only_preview_cannot_reuse_old_endpoints_with_unchanged_pins() {
-    let (mut p, d, _, _, edge) = fixture();
-    let baseline = routed(&p, d);
-    let mut route = stored(edge);
-    route.source_attachment = Some(anchor(PortAnchorSide::Top, 0.2));
-    p.diagrams.get_mut(&d).unwrap().routes.push(route);
-    let view = project_diagram(&p, &p.diagrams[&d]);
-    let preview = route_edge_preview(&p, &p.diagrams[&d], &view, &baseline, edge);
-    assert_ne!(preview.edges[&edge].points, baseline.edges[&edge].points);
-    assert_eq!(preview, routed(&p, d));
-}
-
-#[test]
-fn ports_remain_authoritative_even_when_projection_filters_the_port() {
-    let mut p = Project::empty();
-    let a = p
-        .add_element(Kind::Function, Layer::Sa, "Send", None)
-        .unwrap();
-    let b = p
-        .add_element(Kind::Function, Layer::Sa, "Receive", None)
-        .unwrap();
-    let edge = p.relate(RelationKind::FunctionalExchange, "Data", a, b);
-    let d = p.ensure_diagram(Layer::Sa);
-    p.place(d, a, pos(0., 0.));
-    p.place(d, b, pos(600., 0.));
-    let diagram = p.diagrams[&d].clone();
-    let view = project_diagram(&p, &diagram);
-    let expected = route_diagram(&p, &diagram, &view);
-    assert!(semantic_port_endpoint(&p, edge, EdgeEnd::Source).is_some());
-    let mut route = stored(edge);
-    route.source_attachment = Some(anchor(PortAnchorSide::Bottom, 0.1));
-    route.target_attachment = Some(anchor(PortAnchorSide::Top, 0.9));
-    p.diagrams.get_mut(&d).unwrap().routes.push(route);
-    assert_eq!(routed(&p, d), expected);
-    let mut hidden = view.clone();
-    hidden.ports.clear();
-    for e in &mut hidden.edges {
-        e.source_port = None;
-        e.target_port = None;
-    }
-    let absent = route_diagram(&p, &diagram, &hidden);
-    assert_eq!(
-        route_diagram(&p, &p.diagrams[&d], &hidden),
-        absent,
-        "hidden ports must not activate a dormant node preference"
-    );
-}
-
-fn state(kind: Kind) -> (Project, Id, Id, Id) {
-    let mut p = Project::empty();
-    let owner = p
-        .add_element(Kind::Entity, Layer::Oa, "Crew", None)
-        .unwrap();
-    let machine = p
-        .add_element(Kind::StateMachine, Layer::Oa, "Modes", Some(owner))
-        .unwrap();
-    let region = p
-        .add_element(Kind::Region, Layer::Oa, "Main", Some(machine))
-        .unwrap();
-    let a = p.add_element(kind, Layer::Oa, "A", Some(region)).unwrap();
-    let b = p
-        .add_element(Kind::State, Layer::Oa, "B", Some(region))
-        .unwrap();
-    let edge = p.relate(RelationKind::StateTransition, "Next", a, b);
-    let d = p.ensure_diagram(Layer::Oa);
-    p.diagrams.get_mut(&d).unwrap().projection = ProjectionKind::StateMachine { machine };
-    p.place(d, a, pos(100., 100.));
-    p.place(d, b, pos(600., 100.));
-    (p, d, a, edge)
-}
-
-#[test]
-fn nonrectangular_state_attachments_intersect_the_painted_shape() {
-    for kind in [
-        Kind::Initial,
-        Kind::Junction,
-        Kind::Final,
-        Kind::Choice,
-        Kind::ShallowHistory,
-        Kind::DeepHistory,
-        Kind::EntryPoint,
-        Kind::ExitPoint,
-        Kind::Terminate,
-        Kind::Fork,
-        Kind::Join,
-        Kind::State,
-    ] {
-        let (p, d, a, _) = state(kind);
-        let diagram = &p.diagrams[&d];
-        let view = project_diagram(&p, diagram);
-        let n = view.nodes.iter().find(|n| n.element == a).unwrap();
-        for side in [
-            PortAnchorSide::Left,
-            PortAnchorSide::Right,
-            PortAnchorSide::Top,
-            PortAnchorSide::Bottom,
-        ] {
-            for offset in [0., 0.2, 0.5, 0.8, 1.] {
-                let at = attachment_point(&p, diagram, n, &anchor(side, offset));
-                let x = (at.x - n.position.x) / n.size.width;
-                let y = (at.y - n.position.y) / n.size.height;
-                match kind {
-                    Kind::Choice => near((2. * x - 1.).abs() + (2. * y - 1.).abs(), 1.),
-                    Kind::Terminate => near((x - y).abs().min((x + y - 1.).abs()), 0.),
-                    Kind::Fork | Kind::Join => near(x.min(1. - x).min(y.min(1. - y)), 0.),
-                    Kind::State => {
-                        assert!((0. ..=1.).contains(&x) && (0. ..=1.).contains(&y));
-                        if offset == 0. || offset == 1. {
-                            assert!(
-                                x != 0. && x != 1. || y != 0. && y != 1.,
-                                "rounded corner cannot use bounding-box corner"
-                            );
-                        }
-                    }
-                    _ => near((2. * x - 1.).powi(2) + (2. * y - 1.).powi(2), 1.),
-                }
-            }
-        }
-    }
-}
-
-#[test]
-fn inset_contour_leads_keep_pin_fractions_and_labels_on_the_complete_path() {
-    let (mut p, d, _, edge) = state(Kind::Choice);
-    let mut route = stored(edge);
-    route.source_attachment = Some(anchor(PortAnchorSide::Right, 0.));
-    route.waypoints = vec![pos(380., 40.)];
-    route.label = Some(EdgeLabel {
-        fraction: 0.3,
-        offset: pos(0., 0.),
-    });
-    p.diagrams.get_mut(&d).unwrap().routes.push(route);
-    let result = routed(&p, d);
-    let r = &result.edges[&edge];
-    orthogonal(&r.points);
-    assert!(r.warnings.is_empty(), "{:?}", r.warnings);
-    let pin = r.pins[0];
-    let pin_index = r.points.iter().position(|p| *p == pin).unwrap();
-    near(
-        r.pin_fractions[0],
-        length(&r.points[..=pin_index]) / length(&r.points),
-    );
-    assert_eq!(
-        r.label.anchor,
-        point_along_polyline(&r.points, 0.3).unwrap()
-    );
-}
-
-#[test]
-fn small_symbol_drag_chooses_the_intended_exit_side_at_low_zoom() {
-    for kind in [
-        Kind::Initial,
-        Kind::Choice,
-        Kind::Terminate,
-        Kind::Fork,
-        Kind::State,
-    ] {
-        let (p, d, a, _) = state(kind);
-        let view = project_diagram(&p, &p.diagrams[&d]);
-        let n = view.nodes.iter().find(|n| n.element == a).unwrap();
-        for zoom in [0.5, 1., 2.] {
-            for overshoot in [0., 20.] {
-                let cursor = pos(n.position.x + n.size.width / 2., n.position.y - overshoot);
-                let chosen =
-                    attachment_from_point(n, cursor, Some(PortAnchorSide::Right), 6. / zoom);
-                assert_eq!(
-                    chosen,
-                    anchor(PortAnchorSide::Top, 0.5),
-                    "{kind:?}, zoom {zoom}, overshoot {overshoot}"
-                );
-                let painted = attachment_point(&p, &p.diagrams[&d], n, &chosen);
-                near(painted.x, n.position.x + n.size.width / 2.);
-                near(
-                    painted.y,
-                    n.position.y
-                        + if kind == Kind::Terminate {
-                            n.size.height / 2.
-                        } else {
-                            0.
-                        },
-                );
-            }
-            let near_corner = pos(n.position.x + n.size.width - 1., n.position.y + 1.);
-            let stable =
-                attachment_from_point(n, near_corner, Some(PortAnchorSide::Right), 6. / zoom);
-            assert_eq!(
-                stable.side,
-                PortAnchorSide::Right,
-                "corner hysteresis stays stable"
-            );
-        }
-    }
-}
-
-#[test]
-fn coincident_self_attachments_retain_hard_pins_and_form_a_visible_loop() {
-    let (mut p, d, a, edge) = state(Kind::State);
-    if let RelationBody::StateTransition { target, .. } =
-        &mut p.relations.get_mut(&edge).unwrap().body
-    {
-        *target = a;
-    }
-    for pins in [vec![], vec![pos(400., 30.)]] {
-        let mut route = stored(edge);
-        route.source_attachment = Some(anchor(PortAnchorSide::Top, 0.5));
-        route.target_attachment = route.source_attachment;
-        route.waypoints = pins.clone();
-        p.diagrams.get_mut(&d).unwrap().routes = vec![route.clone()];
-        let result = routed(&p, d);
-        let r = &result.edges[&edge];
-        orthogonal(&r.points);
-        assert_eq!(r.points.first(), r.points.last());
-        assert!(length(&r.points) > 2. * PORT_STUB + 70.);
-        assert_eq!(r.pins, pins);
-        assert_eq!(r.pin_fractions.len(), pins.len());
-        assert!(
-            r.warnings.contains(&RouteWarning::CoincidentAttachments),
-            "{:?}",
-            r.warnings
-        );
-        assert_eq!(routed(&p, d), result, "deterministic fallback");
-        assert_eq!(p.diagrams[&d].routes[0], route);
-    }
-}
-
-#[test]
-fn coincident_loop_chooses_clear_side_instead_of_inventing_an_obstructed_pin() {
-    for blocker_side in [-1., 1.] {
-        let (mut p, d, a, edge) = state(Kind::State);
-        if let RelationBody::StateTransition { target, .. } =
-            &mut p.relations.get_mut(&edge).unwrap().body
-        {
-            *target = a;
-        }
-        let mut route = stored(edge);
-        route.source_attachment = Some(anchor(PortAnchorSide::Top, 0.5));
-        route.target_attachment = route.source_attachment;
-        p.diagrams.get_mut(&d).unwrap().routes.push(route);
-        let view = project_diagram(&p, &p.diagrams[&d]);
-        let source = view.nodes.iter().find(|n| n.element == a).unwrap();
-        let tip = attachment_point(
-            &p,
-            &p.diagrams[&d],
-            source,
-            &anchor(PortAnchorSide::Top, 0.5),
-        );
-        let region = p.elements[&a].parent;
-        let blocker = p
-            .add_element(Kind::State, Layer::Oa, "Detour obstruction", region)
-            .unwrap();
-        let left = if blocker_side > 0. {
-            tip.x + 30.
-        } else {
-            tip.x - 30. - 224.
-        };
-        p.place(d, blocker, pos(left, tip.y - 144.));
-        let result = routed(&p, d);
-        let r = &result.edges[&edge];
-        assert_eq!(r.warnings, vec![RouteWarning::CoincidentAttachments]);
-        orthogonal(&r.points);
-        let view = project_diagram(&p, &p.diagrams[&d]);
-        let n = view.nodes.iter().find(|n| n.element == blocker).unwrap();
-        for segment in r.points.windows(2) {
-            for step in 0..=100 {
-                let t = step as f32 / 100.;
-                let q = pos(
-                    segment[0].x + (segment[1].x - segment[0].x) * t,
-                    segment[0].y + (segment[1].y - segment[0].y) * t,
-                );
-                assert!(
-                    !(q.x > n.position.x - CLEARANCE
-                        && q.x < n.position.x + n.size.width + CLEARANCE
-                        && q.y > n.position.y - CLEARANCE
-                        && q.y < n.position.y + n.size.height + CLEARANCE),
-                    "route crosses blocker: {q:?}"
-                );
-            }
-        }
-        assert!(
-            r.pins.is_empty(),
-            "generated detours must never become authored pins"
-        );
-    }
-}

crates/oa-core/tests/attachment_lifecycle.rs

@@ -1,272 +0,0 @@
-use oa_core::{language, projection::*, routing::*, *};
-
-fn pos(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-
-fn id(project: &Project, alias: &str) -> Id {
-    project
-        .identities()
-        .into_iter()
-        .find(|(_, a)| *a == alias)
-        .unwrap()
-        .0
-}
-
-fn authored(edge: Id) -> EdgeRoute {
-    EdgeRoute {
-        edge,
-        source_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Bottom,
-            offset: 0.2,
-        }),
-        target_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Top,
-            offset: 0.8,
-        }),
-        waypoints: vec![pos(520., 420.)],
-        label: Some(EdgeLabel {
-            fraction: 0.35,
-            offset: pos(17., -23.),
-        }),
-    }
-}
-
-fn routed(project: &Project, diagram: Id) -> RoutedView {
-    let d = &project.diagrams[&diagram];
-    route_diagram(project, d, &project_diagram(project, d))
-}
-
-fn fixture() -> (Project, Id, Id, Id, Id, Id, Id) {
-    let mut p = language::parse(
-        r#"arcadia 7;
-project lifecycle "Attachment lifecycle" {
- oa_activity group "Group" { oa_activity first "First" {} }
- oa_activity second "Second" {}
- oa_activity replacement "Replacement" {}
- interaction signal "Signal" { source @first; target @second; }
- diagram view "View" {}
- diagram other "Other" {}
-}"#,
-    )
-    .unwrap();
-    let (d, other, group, first, second, replacement, edge) = (
-        id(&p, "view"),
-        id(&p, "other"),
-        id(&p, "group"),
-        id(&p, "first"),
-        id(&p, "second"),
-        id(&p, "replacement"),
-        id(&p, "signal"),
-    );
-    for diagram in [d, other] {
-        p.place(diagram, group, pos(20., 20.));
-        p.place(diagram, first, pos(100., 130.));
-        p.place(diagram, second, pos(750., 150.));
-        p.place(diagram, replacement, pos(750., 570.));
-        p.diagrams
-            .get_mut(&diagram)
-            .unwrap()
-            .routes
-            .push(authored(edge));
-    }
-    (p, d, other, group, first, replacement, edge)
-}
-
-#[test]
-fn attachment_fold_promotion_suspends_the_complete_route_and_expand_restores_it() {
-    let (mut p, d, other, group, _, _, edge) = fixture();
-    assert_eq!(semantic_port_endpoint(&p, edge, EdgeEnd::Source), None);
-    assert_eq!(semantic_port_endpoint(&p, edge, EdgeEnd::Target), None);
-    let before = p.clone();
-    let expanded = routed(&p, d);
-    let other_geometry = routed(&p, other);
-    let parent = p.diagrams[&d]
-        .nodes
-        .values()
-        .find(|n| n.element == group)
-        .unwrap()
-        .id;
-    p.diagrams
-        .get_mut(&d)
-        .unwrap()
-        .nodes
-        .get_mut(&parent)
-        .unwrap()
-        .collapsed = true;
-    let folded = routed(&p, d);
-    assert!(folded.edges[&edge].custom_suspended);
-    assert_eq!(folded.edges[&edge].pins, []);
-    assert!(
-        folded.edges[&edge]
-            .warnings
-            .contains(&RouteWarning::PromotedEndpoints)
-    );
-    assert_eq!(p.diagrams[&d].routes, before.diagrams[&d].routes);
-    let mut automatic = p.clone();
-    automatic.diagrams.get_mut(&d).unwrap().routes.clear();
-    assert_eq!(
-        folded,
-        routed(&automatic, d),
-        "attachments, pins and label must all be dormant on promotion"
-    );
-    assert_eq!(p.diagrams[&other], before.diagrams[&other]);
-    assert_eq!(routed(&p, other), other_geometry);
-    p.diagrams
-        .get_mut(&d)
-        .unwrap()
-        .nodes
-        .get_mut(&parent)
-        .unwrap()
-        .collapsed = false;
-    assert_eq!(p, before);
-    assert_eq!(routed(&p, d), expanded);
-}
-
-#[test]
-fn attachment_reconnect_retains_slot_preferences_and_other_view_records_with_exact_history() {
-    let (p, d, other, _, _, replacement, edge) = fixture();
-    let before = routed(&p, d);
-    let mut relation = p.relations[&edge].clone();
-    let RelationBody::Interaction { target, .. } = &mut relation.body else {
-        unreachable!()
-    };
-    *target = replacement;
-    let mut expected = p.clone();
-    expected.relations.insert(edge, relation.clone());
-    let mut session = Session::new(p.clone());
-    session
-        .execute(Command::EditRelation(edge, relation))
-        .unwrap();
-    assert_eq!(
-        session.project(),
-        &expected,
-        "reconnect changes only the semantic endpoint; all per-view records remain exact"
-    );
-    assert_eq!(session.project().diagrams[&other], p.diagrams[&other]);
-    for diagram in [d, other] {
-        let current = session.project();
-        let view = project_diagram(current, &current.diagrams[&diagram]);
-        let node = view
-            .nodes
-            .iter()
-            .find(|n| n.element == replacement)
-            .unwrap();
-        let preference = current.diagrams[&diagram].routes[0]
-            .target_attachment
-            .unwrap();
-        let expected_tip =
-            attachment_point(current, &current.diagrams[&diagram], node, &preference);
-        let result = routed(current, diagram);
-        assert_eq!(result.edges[&edge].points.last(), Some(&expected_tip));
-        assert_eq!(
-            result.edges[&edge].pins,
-            p.diagrams[&diagram].routes[0].waypoints
-        );
-    }
-    assert_ne!(
-        routed(session.project(), d).edges[&edge].points.last(),
-        before.edges[&edge].points.last()
-    );
-    session.undo();
-    assert_eq!(session.project(), &p);
-    assert_eq!(routed(session.project(), d), before);
-    session.redo();
-    assert_eq!(session.project(), &expected);
-}
-
-#[test]
-fn attachment_direct_port_endpoints_remain_authoritative_when_their_glyphs_are_filtered() {
-    let mut p = Project::empty();
-    let system = p
-        .add_element(Kind::System, Layer::Sa, "System", None)
-        .unwrap();
-    let actor = p
-        .add_element(Kind::SystemActor, Layer::Sa, "Actor", None)
-        .unwrap();
-    let function = p
-        .add_element(Kind::Function, Layer::Sa, "Send", None)
-        .unwrap();
-    let mut ports = Vec::new();
-    for (owner, name, contract) in [
-        (
-            system,
-            "Output",
-            PortContract::Component {
-                kind: ComponentPortKind::Flow,
-                orientation: ComponentPortOrientation::Out,
-            },
-        ),
-        (
-            actor,
-            "Input",
-            PortContract::Component {
-                kind: ComponentPortKind::Flow,
-                orientation: ComponentPortOrientation::In,
-            },
-        ),
-        (
-            function,
-            "Function output",
-            PortContract::FunctionOutput {
-                outgoing_items: vec![],
-            },
-        ),
-    ] {
-        let port = Id::new_v4();
-        p.elements
-            .insert(port, make_port(&p, port, owner, name, contract).unwrap());
-        ports.push(port);
-    }
-    p.relate(
-        RelationKind::Allocation,
-        "Function allocation",
-        system,
-        function,
-    );
-    let boundary = p.relate(
-        RelationKind::BoundaryExchange,
-        "Boundary",
-        ports[0],
-        ports[1],
-    );
-    let allocation = p.relate(
-        RelationKind::PortAllocation,
-        "Port allocation",
-        ports[0],
-        ports[2],
-    );
-    let d = p.ensure_diagram(Layer::Sa);
-    p.place(d, system, pos(0., 0.));
-    p.place(d, actor, pos(700., 0.));
-    p.place(d, function, pos(0., 450.));
-    let original = p.clone();
-    let baseline = routed(&p, d);
-    for (edge, target) in [(boundary, ports[1]), (allocation, ports[2])] {
-        assert!(baseline.edges.contains_key(&edge));
-        assert_eq!(
-            semantic_port_endpoint(&p, edge, EdgeEnd::Source),
-            Some(ports[0])
-        );
-        assert_eq!(
-            semantic_port_endpoint(&p, edge, EdgeEnd::Target),
-            Some(target)
-        );
-        let mut route = authored(edge);
-        route.waypoints.clear();
-        route.label = None;
-        p.diagrams.get_mut(&d).unwrap().routes.push(route);
-    }
-    assert_eq!(routed(&p, d), baseline);
-    let mut hidden = project_diagram(&p, &p.diagrams[&d]);
-    hidden.ports.clear();
-    for edge in &mut hidden.edges {
-        edge.source_port = None;
-        edge.target_port = None;
-    }
-    assert_eq!(
-        route_diagram(&p, &p.diagrams[&d], &hidden),
-        route_diagram(&original, &original.diagrams[&d], &hidden),
-        "filtered direct Port endpoints must not activate their stored preferences"
-    );
-}

crates/oa-core/tests/attachment_trace_ports.rs

@@ -1,136 +0,0 @@
-use oa_core::{projection::*, routing::*, *};
-
-#[test]
-fn valid_item_trace_follows_manual_port_anchors_and_ignores_dormant_attachments() {
-    let mut project = Project::empty();
-    let oa = project
-        .add_element(Kind::Activity, Layer::Oa, "Send", None)
-        .unwrap();
-    let sa = project
-        .add_element(Kind::Function, Layer::Sa, "Receive", None)
-        .unwrap();
-    let ports = [(oa, Layer::Oa), (sa, Layer::Sa)].map(|(owner, layer)| {
-        let id = Id::new_v4();
-        project.elements.insert(
-            id,
-            Element {
-                id,
-                alias: format!("port_{}", id.simple()),
-                name: "Status port".into(),
-                description: "Existing legacy port retained by Item trace".into(),
-                parent: Some(owner),
-                body: ElementBody::shared_in(
-                    layer,
-                    SharedBody::Port {
-                        contract: PortContract::Legacy,
-                        legacy: Some(LegacyPortContract {
-                            direction: PortDirection::InOut,
-                            interface: None,
-                        }),
-                    },
-                ),
-            },
-        );
-        id
-    });
-    let trace = Trace {
-        id: Id::new_v4(),
-        alias: "status_correspondence".into(),
-        name: "Status correspondence".into(),
-        description: "Preserve this semantic evidence".into(),
-        oa: ports[0],
-        sa: ports[1],
-        kind: TraceKind::Item,
-        baseline: None,
-    };
-    project.traces.insert(trace.id, trace.clone());
-    let diagram = project.ensure_diagram(Layer::Oa);
-    project.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Traceability;
-    let owners = [
-        project.place(diagram, oa, Position { x: 100., y: 100. }),
-        project.place(diagram, sa, Position { x: 800., y: 300. }),
-    ];
-    validate_candidate(&project).unwrap();
-    let semantic_elements = project.elements.clone();
-    let semantic_relations = project.relations.clone();
-    let semantic_traces = project.traces.clone();
-    let view = project_diagram(&project, &project.diagrams[&diagram]);
-    let edge = view.edges.iter().find(|edge| edge.id == trace.id).unwrap();
-    assert!(edge.trace);
-    assert_eq!((edge.source, edge.target), (owners[0], owners[1]));
-    assert_eq!((edge.source_port, edge.target_port), (None, None));
-    let initial = route_diagram(&project, &project.diagrams[&diagram], &view);
-    for (index, (side, offset)) in [(PortAnchorSide::Top, 0.25), (PortAnchorSide::Bottom, 0.75)]
-        .into_iter()
-        .enumerate()
-    {
-        project
-            .diagrams
-            .get_mut(&diagram)
-            .unwrap()
-            .nodes
-            .get_mut(&owners[index])
-            .unwrap()
-            .port_anchors
-            .push(PortAnchor {
-                port: ports[index],
-                side,
-                offset,
-            });
-    }
-    validate_candidate(&project).unwrap();
-    let moved_view = project_diagram(&project, &project.diagrams[&diagram]);
-    let moved = route_diagram(&project, &project.diagrams[&diagram], &moved_view);
-    for index in 0..2 {
-        let marker = moved_view
-            .ports
-            .iter()
-            .find(|port| port.element == ports[index] && port.owner == owners[index])
-            .unwrap();
-        let points = &moved.edges[&trace.id].points;
-        let tip = if index == 0 {
-            points[0]
-        } else {
-            *points.last().unwrap()
-        };
-        assert_eq!(tip, marker.position);
-        let old = &initial.edges[&trace.id].points;
-        assert_ne!(
-            tip,
-            if index == 0 {
-                old[0]
-            } else {
-                *old.last().unwrap()
-            }
-        );
-    }
-    project
-        .diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .routes
-        .push(EdgeRoute {
-            edge: trace.id,
-            waypoints: vec![],
-            label: None,
-            source_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Bottom,
-                offset: 0.9,
-            }),
-            target_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Top,
-                offset: 0.1,
-            }),
-        });
-    validate_candidate(&project).unwrap();
-    let dormant_view = project_diagram(&project, &project.diagrams[&diagram]);
-    assert_eq!(dormant_view, moved_view);
-    assert_eq!(
-        route_diagram(&project, &project.diagrams[&diagram], &dormant_view),
-        moved
-    );
-    assert_eq!(project.elements, semantic_elements);
-    assert_eq!(project.relations, semantic_relations);
-    assert_eq!(project.traces, semantic_traces);
-    assert_eq!(project.traces[&trace.id], trace);
-}

crates/oa-core/tests/attachment_workshop.rs

@@ -1,154 +0,0 @@
-//! Route the exact native acceptance fixture and intended saved checkpoints.
-use oa_core::{projection::project_diagram, routing::route_diagram, *};
-
-const FIXTURE: &str =
-    include_str!("../../../harness/experiments/edge-attachments-20260922/native-fixture.arcadia");
-
-fn id(project: &Project, alias: &str) -> Id {
-    project
-        .identities()
-        .into_iter()
-        .find(|(_, name)| *name == alias)
-        .unwrap()
-        .0
-}
-
-fn set(
-    project: &mut Project,
-    view: &str,
-    edge: &str,
-    end: EdgeEnd,
-    attachment: Option<(PortAnchorSide, f32)>,
-) {
-    let view = id(project, view);
-    let edge = id(project, edge);
-    let route = project
-        .diagrams
-        .get_mut(&view)
-        .unwrap()
-        .routes
-        .iter_mut()
-        .find(|route| route.edge == edge)
-        .unwrap();
-    route.set_attachment(
-        end,
-        attachment.map(|(side, offset)| EdgeAttachment { side, offset }),
-    );
-}
-
-fn clear(project: &Project, checkpoint: &str) {
-    validate_candidate(project).unwrap();
-    for (view, edges) in [
-        ("dispatch_view", &["dispatch_request"][..]),
-        ("readiness_view", &["activate", "initialize", "finish"][..]),
-    ] {
-        let diagram = &project.diagrams[&id(project, view)];
-        let routed = route_diagram(project, diagram, &project_diagram(project, diagram));
-        for alias in edges {
-            let edge = &routed.edges[&id(project, alias)];
-            assert!(
-                edge.warnings.is_empty(),
-                "{checkpoint}/{view}/{alias}: {:?}",
-                edge.warnings
-            );
-            let stored = diagram
-                .routes
-                .iter()
-                .find(|r| r.edge == id(project, alias))
-                .unwrap();
-            assert_eq!(
-                edge.pins, stored.waypoints,
-                "{checkpoint}/{alias}: manual pins retained"
-            );
-        }
-    }
-}
-
-#[test]
-fn native_workshop_baseline_and_planned_attachments_have_clear_routes() {
-    use EdgeEnd::{Source, Target};
-    use PortAnchorSide::{Bottom, Top};
-    let mut project = language::parse(FIXTURE).unwrap();
-    let baseline = project.clone();
-    clear(&project, "B");
-    set(
-        &mut project,
-        "dispatch_view",
-        "dispatch_request",
-        Source,
-        Some((Top, 0.25)),
-    );
-    clear(&project, "O1");
-    set(
-        &mut project,
-        "dispatch_view",
-        "dispatch_request",
-        Target,
-        Some((Bottom, 0.75)),
-    );
-    clear(&project, "O2");
-    set(
-        &mut project,
-        "dispatch_view",
-        "dispatch_request",
-        Source,
-        None,
-    );
-    clear(&project, "O3");
-    set(
-        &mut project,
-        "readiness_view",
-        "activate",
-        Source,
-        Some((Top, 0.25)),
-    );
-    clear(&project, "S1");
-    set(
-        &mut project,
-        "readiness_view",
-        "activate",
-        Target,
-        Some((Bottom, 0.75)),
-    );
-    clear(&project, "S2");
-    set(&mut project, "readiness_view", "activate", Target, None);
-    clear(&project, "S3");
-    set(
-        &mut project,
-        "readiness_view",
-        "initialize",
-        Source,
-        Some((Top, 0.5)),
-    );
-    clear(&project, "S4");
-    set(
-        &mut project,
-        "readiness_view",
-        "finish",
-        Source,
-        Some((Top, 0.5)),
-    );
-    clear(&project, "S5");
-    assert_eq!(project.elements, baseline.elements);
-    assert_eq!(project.relations, baseline.relations);
-    for alias in ["dispatch_reference", "readiness_reference", "ports_view"] {
-        let view = id(&project, alias);
-        assert_eq!(project.diagrams[&view], baseline.diagrams[&view]);
-    }
-    for alias in ["dispatch_view", "readiness_view"] {
-        let view = id(&project, alias);
-        assert_eq!(
-            project.diagrams[&view].nodes,
-            baseline.diagrams[&view].nodes
-        );
-        for route in &project.diagrams[&view].routes {
-            let original = baseline.diagrams[&view]
-                .routes
-                .iter()
-                .find(|r| r.edge == route.edge)
-                .unwrap();
-            assert_eq!(route.waypoints, original.waypoints);
-            assert_eq!(route.label, original.label);
-        }
-    }
-}

crates/oa-core/tests/default_omission_preservation.rs

@@ -231,7 +231,6 @@ fn node_project() -> Project {
                 },
             )]),
             routes: vec![],
-            layout: None,
         },
     );
     expected

crates/oa-core/tests/edge_attachments.rs

@@ -1,290 +0,0 @@
-use oa_core::{language, persistence, source_project::*, *};
-use serde_json::{Value, json};
-use std::collections::BTreeMap;
-
-const SOURCE: &str = r#"arcadia 7;
-project attachments "Connection ends" id "70000000-0000-4000-8000-000000000001" {
- oa_activity first "First" id "70000000-0000-4000-8000-000000000002" {}
- oa_activity second "Second" id "70000000-0000-4000-8000-000000000003" {}
- interaction signal "Signal" id "70000000-0000-4000-8000-000000000004" { source @first; target @second; }
- diagram view "View" id "70000000-0000-4000-8000-000000000005" {
-  routes [{ edge @signal; waypoints [{ x 120; y 80; }];
-   label { fraction 0.5; offset { x 3; y -7; }; };
-   source_attachment { side Left; offset 0.25; };
-   target_attachment { side Bottom; offset 1; };
-  }];
- }
- diagram other "Other" id "70000000-0000-4000-8000-000000000006" { routes [{ edge @signal; }]; }
-}
-"#;
-
-fn id(project: &Project, alias: &str) -> Id {
-    project
-        .identities()
-        .into_iter()
-        .find(|(_, a)| *a == alias)
-        .unwrap()
-        .0
-}
-
-fn original() -> Project {
-    language::parse(SOURCE).unwrap()
-}
-
-fn set(diagram: Id, route: EdgeRoute) -> Command {
-    Command::SetEdgeRoute { diagram, route }
-}
-
-#[test]
-fn edge_attachments_roundtrip_source_json_bundle_and_automatic_defaults() {
-    let project = original();
-    let view = id(&project, "view");
-    let route = &project.diagrams[&view].routes[0];
-    assert_eq!(
-        route.source_attachment,
-        Some(EdgeAttachment {
-            side: PortAnchorSide::Left,
-            offset: 0.25
-        })
-    );
-    assert_eq!(
-        route.target_attachment,
-        Some(EdgeAttachment {
-            side: PortAnchorSide::Bottom,
-            offset: 1.0
-        })
-    );
-    for text in [SOURCE.to_owned(), language::format(&project)] {
-        assert_eq!(language::parse(&text).unwrap(), project);
-    }
-    assert_eq!(
-        persistence::decode(&serde_json::to_vec(&project).unwrap()).unwrap(),
-        project
-    );
-    assert_eq!(
-        compile_bundle(&format_bundle(&project), ProjectLimits::default())
-            .unwrap()
-            .decoded
-            .project,
-        project
-    );
-
-    let automatic = &project.diagrams[&id(&project, "other")].routes[0];
-    assert_eq!(automatic.source_attachment, None);
-    assert_eq!(automatic.target_attachment, None);
-    let encoded = serde_json::to_value(automatic).unwrap();
-    assert!(encoded.get("source_attachment").is_none());
-    assert!(encoded.get("target_attachment").is_none());
-    let mut with_null = encoded.clone();
-    with_null["source_attachment"] = Value::Null;
-    with_null["target_attachment"] = Value::Null;
-    assert_eq!(
-        serde_json::from_value::<EdgeRoute>(with_null).unwrap(),
-        *automatic
-    );
-    assert_eq!(
-        serde_json::from_value::<EdgeRoute>(encoded).unwrap(),
-        *automatic
-    );
-
-    // Old source without either new field still means automatic presentation.
-    let old = SOURCE
-        .replace("   source_attachment { side Left; offset 0.25; };\n", "")
-        .replace("   target_attachment { side Bottom; offset 1; };\n", "");
-    let old = language::parse(&old).unwrap();
-    assert!(
-        old.diagrams
-            .values()
-            .flat_map(|d| &d.routes)
-            .all(|r| r.source_attachment.is_none() && r.target_attachment.is_none())
-    );
-    assert!(!language::format(&old).contains("_attachment"));
-    assert_eq!(
-        persistence::decode(&serde_json::to_vec(&old).unwrap()).unwrap(),
-        old
-    );
-}
-
-#[test]
-fn edge_attachments_reject_malformed_nested_source_and_json_without_defaults() {
-    let project = original();
-    let edge = id(&project, "signal");
-    for bad in [
-        json!({}),
-        json!({"side":"Top"}),
-        json!({"offset":0.5}),
-        json!({"side":"Diagonal","offset":0.5}),
-        json!({"side":"Top","offset":null}),
-        json!({"side":"Top","offset":0.5,"unknown":true}),
-        json!({"side":"Top","offset":"NaN"}),
-    ] {
-        for field in ["source_attachment", "target_attachment"] {
-            let mut route = json!({"edge":edge});
-            route[field] = bad.clone();
-            assert!(
-                serde_json::from_value::<EdgeRoute>(route).is_err(),
-                "{field}: {bad}"
-            );
-        }
-    }
-    for bad in [
-        "{}",
-        "{ side Top; }",
-        "{ offset 0.5; }",
-        "{ side Diagonal; offset 0.5; }",
-        "{ side Top; offset null; }",
-        "{ side Top; offset 0.5; unknown true; }",
-        "{ side Top; offset -0.01; }",
-        "{ side Top; offset 1.01; }",
-        "{ side Top; offset NaN; }",
-        "{ side Top; offset 1e999; }",
-    ] {
-        let source = SOURCE.replace("{ side Left; offset 0.25; }", bad);
-        assert!(language::parse(&source).is_err(), "{bad}");
-        let bundle = SourceBundle {
-            entry: "p.arcadia".into(),
-            files: BTreeMap::from([("p.arcadia".into(), source)]),
-        };
-        assert!(
-            compile_bundle(&bundle, ProjectLimits::default()).is_err(),
-            "{bad}"
-        );
-    }
-    for version in [1, 2] {
-        let legacy =
-            format!("arcadia {version}; project p \"P\" {{ diagram v \"V\" {{ routes []; }} }}");
-        assert!(
-            language::parse(&legacy).is_err(),
-            "legacy route extension must not be silently admitted"
-        );
-    }
-}
-
-#[test]
-fn edge_attachments_nonfinite_and_out_of_range_commands_reject_atomically() {
-    let project = original();
-    let view = id(&project, "view");
-    let first = id(&project, "first");
-    for offset in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -0.01, 1.01] {
-        for end in [EdgeEnd::Source, EdgeEnd::Target] {
-            let mut route = project.diagrams[&view].routes[0].clone();
-            route.set_attachment(
-                end,
-                Some(EdgeAttachment {
-                    side: PortAnchorSide::Top,
-                    offset,
-                }),
-            );
-            let mut session = Session::new(project.clone());
-            assert!(
-                session
-                    .execute(Command::Batch(vec![
-                        Command::Rename(first, "Must roll back".into()),
-                        set(view, route)
-                    ]))
-                    .is_err()
-            );
-            assert_eq!(session.project(), &project);
-            assert!(!session.can_undo() && !session.can_redo());
-        }
-    }
-    for offset in [-0.01, 1.01] {
-        let mut value = serde_json::to_value(&project).unwrap();
-        value["diagrams"][view.to_string()]["routes"][0]["source_attachment"]["offset"] =
-            json!(offset);
-        assert!(persistence::decode(&serde_json::to_vec(&value).unwrap()).is_err());
-    }
-}
-
-#[test]
-fn edge_attachments_reset_one_end_and_all_routing_have_exact_history_and_view_scope() {
-    let project = original();
-    let view = id(&project, "view");
-    let edge = id(&project, "signal");
-    let mut session = Session::new(project.clone());
-    let mut route = project.diagrams[&view].routes[0].clone();
-    route.source_attachment = Some(EdgeAttachment {
-        side: PortAnchorSide::Right,
-        offset: 0.75,
-    });
-    let command = set(view, route.clone());
-    assert_eq!(
-        serde_json::from_value::<Command>(serde_json::to_value(&command).unwrap()).unwrap(),
-        command
-    );
-    session.execute(command).unwrap();
-    let mut expected = project.clone();
-    expected.diagrams.get_mut(&view).unwrap().routes[0] = route.clone();
-    assert_eq!(
-        session.project(),
-        &expected,
-        "only this view/end changes; semantic fields and other view stay exact"
-    );
-    session.undo();
-    assert_eq!(session.project(), &project);
-    assert!(!session.can_undo() && session.can_redo());
-    session.redo();
-    assert_eq!(session.project(), &expected);
-    route.source_attachment = None;
-    session.execute(set(view, route.clone())).unwrap();
-    let mut reset = expected.clone();
-    reset.diagrams.get_mut(&view).unwrap().routes[0] = route;
-    assert_eq!(
-        session.project(),
-        &reset,
-        "opposite attachment, pins and label survive endpoint reset"
-    );
-    session.undo();
-    assert_eq!(session.project(), &expected);
-    session
-        .execute(Command::RemoveEdgeRoute {
-            diagram: view,
-            edge,
-        })
-        .unwrap();
-    let mut removed = expected.clone();
-    removed.diagrams.get_mut(&view).unwrap().routes.clear();
-    assert_eq!(session.project(), &removed);
-    session.undo();
-    assert_eq!(session.project(), &expected);
-}
-
-#[test]
-fn edge_attachments_nested_writeback_preserves_comments_adjacent_tokens_and_other_files() {
-    let current = compile_bundle(&SourceBundle {
-        entry: "p.arcadia".into(),
-        files: BTreeMap::from([
-            ("p.arcadia".into(), "// project rationale\narcadia 7; project p \"P\" { include \"model.arcadia\"; include \"views.arcadia\"; }\n".into()),
-            ("model.arcadia".into(), "// untouched semantic ownership\noa_activity a \"A\" {}\noa_activity b \"B\" {}\ninteraction signal \"Signal\" { source @a; target @b; }\n".into()),
-            ("views.arcadia".into(), "// view rationale\r\ndiagram view \"View\" {\r\n routes [ { edge @signal; // endpoint explanation\r\n source_attachment { side Left; offset  0.25 ; // exact nested rationale\r\n }; target_attachment { side Bottom; offset 1; };\r\n waypoints [{ x 120; y 80; }]; label { fraction 0.5; offset { x 3; y -7; }; }; } ];\r\n}\r\ndiagram other \"Other\" { routes [{ edge @signal; }]; } // adjacent view\r\n".into()),
-        ]),
-    }, ProjectLimits::default()).unwrap();
-    let mut project = current.decoded.project.clone();
-    let view = id(&project, "view");
-    project.diagrams.get_mut(&view).unwrap().routes[0]
-        .source_attachment
-        .as_mut()
-        .unwrap()
-        .offset = 0.375;
-    let changed = update_bundle(&current, &project, ProjectLimits::default()).unwrap();
-    assert_eq!(changed.decoded.project, project);
-    for path in ["p.arcadia", "model.arcadia"] {
-        assert_eq!(changed.bundle.files[path], current.bundle.files[path]);
-    }
-    assert_eq!(
-        changed.bundle.files["views.arcadia"],
-        current.bundle.files["views.arcadia"].replace("offset  0.25 ;", "offset  0.375 ;")
-    );
-    assert_eq!(
-        compile_bundle(&changed.bundle, ProjectLimits::default())
-            .unwrap()
-            .bundle,
-        changed.bundle
-    );
-    assert_eq!(
-        update_bundle(&changed, &project, ProjectLimits::default())
-            .unwrap()
-            .bundle,
-        changed.bundle
-    );
-}

crates/oa-core/tests/group_movement.rs

@@ -1,427 +0,0 @@
-use oa_core::{diagram_edit::translate_placements, source_project::*, *};
-use std::collections::BTreeSet;
-
-fn point(x: f32, y: f32) -> Position {
-    Position { x, y }
-}
-fn route(edge: Id, x: f32, y: f32) -> EdgeRoute {
-    EdgeRoute {
-        edge,
-        source_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Bottom,
-            offset: 0.2,
-        }),
-        target_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Top,
-            offset: 0.8,
-        }),
-        waypoints: vec![point(x, y)],
-        label: Some(EdgeLabel {
-            fraction: 0.4,
-            offset: point(3., -9.),
-        }),
-    }
-}
-struct Fixture {
-    project: Project,
-    diagram: Id,
-    a: Id,
-    b: Id,
-    child: Id,
-    foreign: Id,
-}
-fn fixture() -> Fixture {
-    let mut p = Project::empty();
-    let a = p.add_element(Kind::Activity, Layer::Oa, "A", None).unwrap();
-    let b = p.add_element(Kind::Activity, Layer::Oa, "B", None).unwrap();
-    let c = p.add_element(Kind::Activity, Layer::Oa, "C", None).unwrap();
-    let child = p
-        .add_element(Kind::Activity, Layer::Oa, "Child", Some(a))
-        .unwrap();
-    let internal = p.relate(RelationKind::Interaction, "Internal", a, b);
-    let external = p.relate(RelationKind::Interaction, "External", b, c);
-    let d = p.ensure_diagram(Layer::Oa);
-    let na = p.place(d, a, point(10., 20.));
-    let nb = p.place(d, b, point(400., 20.));
-    let nc = p.place(d, child, point(30., 80.));
-    p.place(d, c, point(800., 20.));
-    p.diagrams.get_mut(&d).unwrap().routes =
-        vec![route(internal, 320., 150.), route(external, 720., 170.)];
-    p.diagrams
-        .get_mut(&d)
-        .unwrap()
-        .nodes
-        .get_mut(&na)
-        .unwrap()
-        .collapsed = true;
-    let other = Id::new_v4();
-    let mut other_view = p.diagrams[&d].clone();
-    other_view.id = other;
-    other_view.alias = "other_view".into();
-    other_view.nodes.clear();
-    other_view.routes.clear();
-    p.diagrams.insert(other, other_view);
-    let foreign = p.place(other, a, point(-40., -50.));
-    validate_candidate(&p).unwrap();
-    Fixture {
-        project: p,
-        diagram: d,
-        a: na,
-        b: nb,
-        child: nc,
-        foreign,
-    }
-}
-
-#[test]
-fn simultaneous_siblings_translate_internal_pins_once_and_preserve_complete_project() {
-    let f = fixture();
-    let before = f.project.clone();
-    let command = translate_placements(
-        &before,
-        f.diagram,
-        &BTreeSet::from([f.a, f.b]),
-        point(40., 60.),
-    )
-    .unwrap();
-    assert_eq!(
-        before, f.project,
-        "command construction must not mutate input"
-    );
-    // Independently enumerated expected edits, without the projection helpers.
-    let mut expected = before.clone();
-    let view = expected.diagrams.get_mut(&f.diagram).unwrap();
-    view.nodes.get_mut(&f.a).unwrap().position = point(50., 80.);
-    view.nodes.get_mut(&f.b).unwrap().position = point(440., 80.);
-    view.nodes.get_mut(&f.child).unwrap().position = point(70., 140.);
-    view.routes[0].waypoints = vec![point(360., 210.)];
-    let mut session = Session::new(before.clone());
-    session.execute(command.clone()).unwrap();
-    assert_eq!(session.project(), &expected);
-    session.undo();
-    assert_eq!(session.project(), &before);
-    assert!(
-        !session.can_undo(),
-        "one movement must be one history entry"
-    );
-    session.redo();
-    assert_eq!(session.project(), &expected);
-    assert!(!session.can_redo());
-
-    // Independent one-node moves cannot see the shared endpoint displacement.
-    let mut sequential = Session::new(before.clone());
-    for (node, position) in [(f.a, point(50., 80.)), (f.b, point(440., 80.))] {
-        sequential
-            .execute(Command::MoveNode {
-                diagram: f.diagram,
-                node,
-                position,
-                with_descendants: true,
-            })
-            .unwrap();
-    }
-    assert_eq!(
-        sequential.project().diagrams[&f.diagram].routes[0],
-        before.diagrams[&f.diagram].routes[0]
-    );
-    assert_ne!(sequential.project(), &expected);
-
-    let json = serde_json::to_string(&expected).unwrap();
-    assert_eq!(serde_json::from_str::<Project>(&json).unwrap(), expected);
-    let mut bundle = format_bundle(&before);
-    bundle
-        .files
-        .get_mut(&bundle.entry.clone())
-        .unwrap()
-        .insert_str(0, "// preserve movement rationale\n");
-    let original = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let prepared = prepare_command(&before, &command).unwrap();
-    let updated = update_bundle_with_identity_map(
-        &original,
-        &prepared.project,
-        &prepared.identity_map,
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    assert_eq!(updated.decoded.project, expected);
-    assert!(updated.bundle.files[&bundle.entry].starts_with("// preserve movement rationale\n"));
-    let reread = compile_bundle(&updated.bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(reread.decoded.project, expected);
-    assert_eq!(reread.bundle, updated.bundle);
-}
-
-#[test]
-fn selecting_folded_ancestor_and_hidden_descendant_moves_each_once() {
-    let f = fixture();
-    assert!(
-        !projection::project_view(&f.project, f.diagram)
-            .nodes
-            .iter()
-            .any(|n| n.id == f.child)
-    );
-    let ancestor = translate_placements(
-        &f.project,
-        f.diagram,
-        &BTreeSet::from([f.a]),
-        point(-15., 25.),
-    )
-    .unwrap();
-    let overlap = translate_placements(
-        &f.project,
-        f.diagram,
-        &BTreeSet::from([f.a, f.child]),
-        point(-15., 25.),
-    )
-    .unwrap();
-    assert_eq!(overlap, ancestor);
-    let after = prepare_command(&f.project, &overlap).unwrap().project;
-    assert_eq!(
-        after.diagrams[&f.diagram].nodes[&f.child].position,
-        point(15., 105.)
-    );
-    assert_eq!(
-        after.diagrams[&f.diagram].routes,
-        f.project.diagrams[&f.diagram].routes
-    );
-}
-
-#[test]
-fn invalid_movements_refuse_atomically_and_zero_has_no_history() {
-    let f = fixture();
-    let selected = BTreeSet::from([f.a, f.b]);
-    for (diagram, ids, delta) in [
-        (Id::new_v4(), selected.clone(), point(1., 1.)),
-        (f.diagram, BTreeSet::new(), point(1., 1.)),
-        (
-            f.diagram,
-            BTreeSet::from([f.a, Id::new_v4()]),
-            point(1., 1.),
-        ),
-        (f.diagram, BTreeSet::from([f.a, f.foreign]), point(0., 0.)),
-        (f.diagram, selected.clone(), point(f32::NAN, 1.)),
-        (f.diagram, selected.clone(), point(1., f32::INFINITY)),
-        (f.diagram, selected.clone(), point(MAX_COORDINATE, 0.)),
-        (f.diagram, selected.clone(), point(f32::MAX, f32::MAX)),
-    ] {
-        let before = f.project.clone();
-        assert!(translate_placements(&f.project, diagram, &ids, delta).is_err());
-        assert_eq!(f.project, before);
-    }
-    let mut bad_route = f.project.clone();
-    bad_route.diagrams.get_mut(&f.diagram).unwrap().routes[0].waypoints =
-        vec![point(MAX_COORDINATE, 0.)];
-    validate_candidate(&bad_route).unwrap();
-    let snapshot = bad_route.clone();
-    assert!(translate_placements(&bad_route, f.diagram, &selected, point(1., 0.)).is_err());
-    assert_eq!(bad_route, snapshot);
-    let zero = translate_placements(&f.project, f.diagram, &selected, point(0., -0.)).unwrap();
-    assert_eq!(zero, Command::Batch(vec![]));
-    let mut session = Session::new(f.project.clone());
-    session.execute(zero).unwrap();
-    assert_eq!(session.project(), &f.project);
-    assert!(!session.can_undo());
-    assert_eq!(session.revision(), 0);
-}
-
-#[test]
-fn typed_component_port_endpoints_follow_their_owner_placements() {
-    let mut p = Project::empty();
-    let a = p
-        .add_element(Kind::System, Layer::Sa, "System", None)
-        .unwrap();
-    let b = p
-        .add_element(Kind::SystemActor, Layer::Sa, "Actor", None)
-        .unwrap();
-    let output = Id::new_v4();
-    let input = Id::new_v4();
-    for (id, owner, name, orientation) in [
-        (output, a, "Output", ComponentPortOrientation::Out),
-        (input, b, "Input", ComponentPortOrientation::In),
-    ] {
-        let port = make_port(
-            &p,
-            id,
-            owner,
-            name,
-            PortContract::Component {
-                kind: ComponentPortKind::Flow,
-                orientation,
-            },
-        )
-        .unwrap();
-        p.elements.insert(id, port);
-    }
-    let edge = p.relate(RelationKind::BoundaryExchange, "Boundary", output, input);
-    let d = p.ensure_diagram(Layer::Sa);
-    let na = p.place(d, a, point(0., 0.));
-    let nb = p.place(d, b, point(400., 0.));
-    for (node, port, side, offset) in [
-        (na, output, PortAnchorSide::Bottom, 0.3),
-        (nb, input, PortAnchorSide::Top, 0.7),
-    ] {
-        p.diagrams
-            .get_mut(&d)
-            .unwrap()
-            .nodes
-            .get_mut(&node)
-            .unwrap()
-            .port_anchors
-            .push(PortAnchor { port, side, offset });
-    }
-    p.diagrams
-        .get_mut(&d)
-        .unwrap()
-        .routes
-        .push(route(edge, 300., 100.));
-    validate_candidate(&p).unwrap();
-    let command = translate_placements(&p, d, &BTreeSet::from([na, nb]), point(10., -20.)).unwrap();
-    let after = prepare_command(&p, &command).unwrap().project;
-    let mut expected = p.clone();
-    let view = expected.diagrams.get_mut(&d).unwrap();
-    view.nodes.get_mut(&na).unwrap().position = point(10., -20.);
-    view.nodes.get_mut(&nb).unwrap().position = point(410., -20.);
-    view.routes[0].waypoints = vec![point(310., 80.)];
-    assert_eq!(after, expected);
-}
-
-#[test]
-fn allocation_movement_follows_visual_performers_and_same_performer_work_groups() {
-    let mut p = Project::empty();
-    let performer_a = p
-        .add_element(Kind::Entity, Layer::Oa, "Performer A", None)
-        .unwrap();
-    let performer_b = p
-        .add_element(Kind::Entity, Layer::Oa, "Performer B", None)
-        .unwrap();
-    let mixed = p
-        .add_element(Kind::Activity, Layer::Oa, "Mixed work", None)
-        .unwrap();
-    let branch = p
-        .add_element(Kind::Activity, Layer::Oa, "A work", Some(mixed))
-        .unwrap();
-    let leaf_a = p
-        .add_element(Kind::Activity, Layer::Oa, "A leaf", Some(branch))
-        .unwrap();
-    let leaf_b = p
-        .add_element(Kind::Activity, Layer::Oa, "B leaf", Some(mixed))
-        .unwrap();
-    p.relate(RelationKind::Allocation, "A performs", performer_a, leaf_a);
-    p.relate(RelationKind::Allocation, "B performs", performer_b, leaf_b);
-    let d = p.ensure_diagram(Layer::Oa);
-    p.diagrams.get_mut(&d).unwrap().projection = ProjectionKind::Allocation;
-    let na = p.place(d, performer_a, point(0., 0.));
-    p.place(d, performer_b, point(600., 0.));
-    let nm = p.place(d, mixed, point(1000., 0.));
-    let branch_node = p.place(d, branch, point(20., 80.));
-    let leaf_node = p.place(d, leaf_a, point(40., 160.));
-    p.place(d, leaf_b, point(620., 80.));
-    validate_candidate(&p).unwrap();
-
-    // Mixed work retains semantic ownership of both branches, but its leaves
-    // have different performers. A work is visually nested under Performer A,
-    // with its own same-performer leaf nested inside it.
-    let command =
-        translate_placements(&p, d, &BTreeSet::from([na, branch_node]), point(15., -25.)).unwrap();
-    let after = prepare_command(&p, &command).unwrap().project;
-    let mut expected = p.clone();
-    let view = expected.diagrams.get_mut(&d).unwrap();
-    view.nodes.get_mut(&na).unwrap().position = point(15., -25.);
-    view.nodes.get_mut(&branch_node).unwrap().position = point(35., 55.);
-    view.nodes.get_mut(&leaf_node).unwrap().position = point(55., 135.);
-    assert_eq!(after, expected);
-
-    // Moving the semantic parent does not move children displayed elsewhere.
-    let command = translate_placements(&p, d, &BTreeSet::from([nm]), point(15., -25.)).unwrap();
-    let after = prepare_command(&p, &command).unwrap().project;
-    let mut expected = p.clone();
-    expected
-        .diagrams
-        .get_mut(&d)
-        .unwrap()
-        .nodes
-        .get_mut(&nm)
-        .unwrap()
-        .position = point(1015., -25.);
-    assert_eq!(after, expected);
-}
-
-#[test]
-fn traceability_movement_is_flat_even_for_a_semantic_parent() {
-    let mut f = fixture();
-    f.project.diagrams.get_mut(&f.diagram).unwrap().projection = ProjectionKind::Traceability;
-    validate_candidate(&f.project).unwrap();
-    let command = translate_placements(
-        &f.project,
-        f.diagram,
-        &BTreeSet::from([f.a]),
-        point(40., 60.),
-    )
-    .unwrap();
-    let after = prepare_command(&f.project, &command).unwrap().project;
-    let mut expected = f.project.clone();
-    expected
-        .diagrams
-        .get_mut(&f.diagram)
-        .unwrap()
-        .nodes
-        .get_mut(&f.a)
-        .unwrap()
-        .position = point(50., 80.);
-    assert_eq!(
-        after, expected,
-        "flat view movement must preserve semantic descendants, routes, other views and all semantics"
-    );
-}
-
-#[test]
-fn state_entry_pins_follow_the_boundary_only_when_it_also_moves() {
-    let mut p = Project::empty();
-    let machine = p
-        .add_element(Kind::StateMachine, Layer::Oa, "Machine", None)
-        .unwrap();
-    let region = p
-        .add_element(Kind::Region, Layer::Oa, "Region", Some(machine))
-        .unwrap();
-    let composite = p
-        .add_element(Kind::State, Layer::Oa, "Composite", Some(region))
-        .unwrap();
-    let inner = p
-        .add_element(Kind::Region, Layer::Oa, "Inner", Some(composite))
-        .unwrap();
-    let entry = p
-        .add_element(Kind::EntryPoint, Layer::Oa, "Entry", Some(inner))
-        .unwrap();
-    let leaf = p
-        .add_element(Kind::State, Layer::Oa, "Leaf", Some(inner))
-        .unwrap();
-    let edge = p.relate(RelationKind::StateTransition, "Enter", entry, leaf);
-    if let RelationBody::StateTransition {
-        transition_kind, ..
-    } = &mut p.relations.get_mut(&edge).unwrap().body
-    {
-        *transition_kind = TransitionKind::Local;
-    }
-    let d = p.ensure_diagram(Layer::Oa);
-    p.diagrams.get_mut(&d).unwrap().projection = ProjectionKind::StateMachine { machine };
-    let boundary = p.place(d, composite, point(0., 0.));
-    let ne = p.place(d, entry, point(20., 80.));
-    let nl = p.place(d, leaf, point(100., 80.));
-    p.diagrams
-        .get_mut(&d)
-        .unwrap()
-        .routes
-        .push(route(edge, 90., 100.));
-    validate_candidate(&p).unwrap();
-    let endpoints =
-        translate_placements(&p, d, &BTreeSet::from([ne, nl]), point(10., 20.)).unwrap();
-    let after = prepare_command(&p, &endpoints).unwrap().project;
-    assert_eq!(after.diagrams[&d].routes, p.diagrams[&d].routes);
-    let with_boundary =
-        translate_placements(&p, d, &BTreeSet::from([boundary, ne, nl]), point(10., 20.)).unwrap();
-    let after = prepare_command(&p, &with_boundary).unwrap().project;
-    assert_eq!(
-        after.diagrams[&d].routes[0].waypoints,
-        vec![point(100., 120.)]
-    );
-    assert_eq!(after.diagrams[&d].nodes[&ne].position, point(30., 100.));
-}

crates/oa-core/tests/lead_feasibility.rs

@@ -1,238 +0,0 @@
-use oa_core::{projection, routing, *};
-
-struct Fixture {
-    p: Project,
-    d: Id,
-    edge: Id,
-    source: Id,
-    target: Id,
-    blocker: Id,
-}
-fn fixture(ports: bool, gap: f32) -> Fixture {
-    let mut p = Project::empty();
-    let kind = if ports {
-        Kind::Function
-    } else {
-        Kind::DataType
-    };
-    let a = p.add_element(kind, Layer::Sa, "Source", None).unwrap();
-    let b = p.add_element(kind, Layer::Sa, "Target", None).unwrap();
-    let c = p.add_element(kind, Layer::Sa, "Blocker", None).unwrap();
-    for element in p.elements.values_mut() {
-        if let Some(SharedBody::DataType { definition, .. }) = element.shared_mut() {
-            *definition = DataTypeDefinition::Record { supertype: None };
-        }
-    }
-    let edge = p.relate(
-        if ports {
-            RelationKind::FunctionalExchange
-        } else {
-            RelationKind::DataAssociation
-        },
-        "Flow",
-        a,
-        b,
-    );
-    let d = p.ensure_diagram(Layer::Sa);
-    let source = p.place(d, a, Position { x: 0., y: 0. });
-    let target = p.place(
-        d,
-        b,
-        Position {
-            x: 500.,
-            y: 180. + gap,
-        },
-    );
-    let blocker = p.place(d, c, Position { x: 500., y: 20. });
-    for n in p.diagrams.get_mut(&d).unwrap().nodes.values_mut() {
-        n.size = Size {
-            width: 224.,
-            height: 160.,
-        };
-    }
-    if ports {
-        for (owner, end, side) in [
-            (source, EdgeEnd::Source, PortAnchorSide::Right),
-            (target, EdgeEnd::Target, PortAnchorSide::Top),
-        ] {
-            let port = routing::semantic_port_endpoint(&p, edge, end).unwrap();
-            p.diagrams
-                .get_mut(&d)
-                .unwrap()
-                .nodes
-                .get_mut(&owner)
-                .unwrap()
-                .port_anchors
-                .push(PortAnchor {
-                    port,
-                    side,
-                    offset: 0.5,
-                });
-        }
-    }
-    validate_candidate(&p).unwrap();
-    Fixture {
-        p,
-        d,
-        edge,
-        source,
-        target,
-        blocker,
-    }
-}
-fn report(f: &Fixture) -> Vec<routing::LeadIncompatibility> {
-    routing::lead_incompatibilities(
-        &f.p,
-        &f.p.diagrams[&f.d],
-        &projection::project_view(&f.p, f.d),
-    )
-}
-fn attachment_route(edge: Id) -> EdgeRoute {
-    EdgeRoute {
-        edge,
-        source_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Top,
-            offset: 0.25,
-        }),
-        target_attachment: Some(EdgeAttachment {
-            side: PortAnchorSide::Bottom,
-            offset: 0.75,
-        }),
-        waypoints: vec![Position { x: 300., y: 400. }],
-        label: None,
-    }
-}
-
-#[test]
-fn exact_twenty_gap_is_blocked_thirty_plus_clears_without_mutation() {
-    let f = fixture(true, 20.);
-    let original = f.p.clone();
-    let r = report(&f);
-    assert_eq!(r.len(), 1);
-    assert_eq!(
-        (
-            r[0].edge,
-            r[0].allowed_pair_count,
-            r[0].lead_clear_pair_count
-        ),
-        (f.edge, 1, 0)
-    );
-    assert_eq!(r[0].source[0].owner, f.source);
-    let end = &r[0].target[0];
-    assert_eq!(end.owner, f.target);
-    assert_eq!(end.tip, Position { x: 612., y: 200. });
-    assert_eq!(end.stub, Position { x: 612., y: 182. });
-    assert_eq!(end.blockers.len(), 1);
-    assert_eq!(end.blockers[0].id, f.blocker);
-    assert_eq!(
-        end.blockers[0].bounds,
-        routing::RoutingBounds {
-            position: Position { x: 488., y: 8. },
-            size: Size {
-                width: 248.,
-                height: 184.
-            },
-        }
-    );
-    assert_eq!(end.stub_containers, end.blockers);
-    assert_eq!(f.p, original);
-    assert!(report(&fixture(true, 30.)).is_empty());
-    assert!(report(&fixture(true, 31.)).is_empty());
-}
-
-#[test]
-fn semantic_manual_ports_override_dormant_route_attachments_and_pins() {
-    let mut f = fixture(true, 20.);
-    let expected = report(&f);
-    f.p.diagrams
-        .get_mut(&f.d)
-        .unwrap()
-        .routes
-        .push(attachment_route(f.edge));
-    assert_eq!(report(&f), expected);
-    let view = projection::project_view(&f.p, f.d);
-    let routed = routing::route_diagram(&f.p, &f.p.diagrams[&f.d], &view);
-    assert_eq!(
-        routed.edges[&f.edge].points.last(),
-        Some(&expected[0].target[0].tip)
-    );
-    assert!(
-        routed.edges[&f.edge]
-            .warnings
-            .contains(&routing::RouteWarning::NoClearPath)
-    );
-}
-
-#[test]
-fn unconstrained_nonport_alternative_is_not_hard_blocked() {
-    let mut f = fixture(false, 20.);
-    assert!(report(&f).is_empty());
-    let mut route = attachment_route(f.edge);
-    route.source_attachment = Some(EdgeAttachment {
-        side: PortAnchorSide::Right,
-        offset: 0.5,
-    });
-    route.target_attachment = Some(EdgeAttachment {
-        side: PortAnchorSide::Top,
-        offset: 0.5,
-    });
-    f.p.diagrams.get_mut(&f.d).unwrap().routes.push(route);
-    let r = report(&f);
-    assert_eq!(r.len(), 1);
-    assert_eq!(r[0].allowed_pair_count, 1);
-    assert_eq!(r[0].target[0].blockers[0].id, f.blocker);
-}
-
-#[test]
-fn nested_endpoint_body_is_traversable_and_promoted_attachments_are_suspended() {
-    let mut f = fixture(false, 20.);
-    // DataType containment is not required for this routing-only view witness:
-    // construct the supplied projected forest explicitly, retaining real owners.
-    let mut view = projection::project_view(&f.p, f.d);
-    let parent = Id::new_v4();
-    let source = view.nodes.iter_mut().find(|n| n.id == f.source).unwrap();
-    source.visual_parent = Some(parent);
-    source.position = Position { x: 40., y: 100. };
-    let element = source.element;
-    view.nodes.push(projection::ProjectedNode {
-        id: parent,
-        element,
-        position: Position { x: 0., y: 0. },
-        size: Size {
-            width: 300.,
-            height: 300.,
-        },
-        visual_parent: None,
-        depth: 0,
-        collapsed: false,
-        allocation_summary: false,
-    });
-    let mut route = attachment_route(f.edge);
-    route.source_attachment = Some(EdgeAttachment {
-        side: PortAnchorSide::Right,
-        offset: 0.5,
-    });
-    route.target_attachment = Some(EdgeAttachment {
-        side: PortAnchorSide::Top,
-        offset: 0.5,
-    });
-    f.p.diagrams.get_mut(&f.d).unwrap().routes.push(route);
-    let r = routing::lead_incompatibilities(&f.p, &f.p.diagrams[&f.d], &view);
-    assert_eq!(r.len(), 1);
-    assert!(
-        r[0].source[0].blockers.is_empty(),
-        "Ancestor body must not block source lead"
-    );
-    // Promotion changes actual projected owner: custom attachments no longer apply.
-    view.edges
-        .iter_mut()
-        .find(|e| e.id == f.edge)
-        .unwrap()
-        .source = parent;
-    let with_dormant = routing::lead_incompatibilities(&f.p, &f.p.diagrams[&f.d], &view);
-    f.p.diagrams.get_mut(&f.d).unwrap().routes.clear();
-    assert_eq!(
-        with_dormant,
-        routing::lead_incompatibilities(&f.p, &f.p.diagrams[&f.d], &view)
-    );
-}

crates/oa-core/tests/port_anchors.rs

@@ -441,8 +441,6 @@ fn nested_owner_bounds_group_movement_and_authored_routes_share_the_same_geometr
             diagram: d,
             route: EdgeRoute {
                 edge,
-                source_attachment: None,
-                target_attachment: None,
                 waypoints: vec![pos(500., 420.)],
                 label: None,
             },

crates/oa-core/tests/release_routing.rs

@@ -41,7 +41,6 @@ fn fixture() -> Fixture {
             projection: ProjectionKind::Overview,
             view_options: Default::default(),
             nodes: BTreeMap::new(),
-            layout: None,
             routes: vec![],
         },
     );
@@ -71,8 +70,6 @@ fn fixture() -> Fixture {
 fn route(edge: Id) -> EdgeRoute {
     EdgeRoute {
         edge,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: vec![Position { x: 550., y: 240. }, Position { x: 550., y: 360. }],
         label: Some(EdgeLabel {
             fraction: 0.4,
@@ -692,8 +689,6 @@ fn old_models_get_empty_routes_and_route_json_is_strict() {
         serde_json::from_value::<EdgeRoute>(minimal).unwrap(),
         EdgeRoute {
             edge: f.edge,
-            source_attachment: None,
-            target_attachment: None,
             waypoints: vec![],
             label: None
         }

crates/oa-core/tests/routing_geometry.rs

@@ -27,8 +27,6 @@ fn route(p: &Project, d: Id) -> RoutedView {
 fn set_route(p: &mut Project, d: Id, edge: Id, pins: Vec<Position>, label: Option<EdgeLabel>) {
     p.diagrams.get_mut(&d).unwrap().routes.push(EdgeRoute {
         edge,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: pins,
         label,
     });

crates/oa-core/tests/routing_labels.rs

@@ -117,8 +117,6 @@ fn authored_overlap_is_exact_and_reset_only_repositions_automatic_text() {
         .routes
         .push(EdgeRoute {
             edge: fe,
-            source_attachment: None,
-            target_attachment: None,
             waypoints: vec![],
             label: Some(authored.clone()),
         });

crates/oa-core/tests/source7_contract.rs

@@ -261,7 +261,7 @@ fn source7_context_lifecycle_source_history_and_closed_admission() {
     assert_eq!(session.project(), &after);
     let fresh = Id::new_v4();
     let mut reidentified = after.clone();
-    references::remap_references(&mut reidentified, f.r1, fresh).unwrap();
+    references::remap_references(&mut reidentified, f.r1, fresh);
     let mut e = reidentified.elements.remove(&f.r1).unwrap();
     e.id = fresh;
     reidentified.elements.insert(fresh, e);

crates/oa-core/tests/state_diagrams.rs

@@ -20,7 +20,6 @@ fn view(p: &mut Project, machine: Id, alias: &str) -> Id {
             projection: ProjectionKind::StateMachine { machine },
             view_options: Default::default(),
             nodes: BTreeMap::new(),
-            layout: None,
             routes: vec![],
         },
     );
@@ -302,8 +301,6 @@ fn folding_retains_authored_routes_without_false_self_transitions() {
     let pins = vec![point(690., 480.), point(690., 230.)];
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: out,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: pins.clone(),
         label: None,
     });
@@ -365,15 +362,11 @@ fn grouped_moves_translate_hidden_descendants_and_pins_only_in_one_view() {
     let pins = vec![point(570., 460.)];
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: f.local,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: pins.clone(),
         label: Some(label.clone()),
     });
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: f.external,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: vec![point(690., 230.)],
         label: None,
     });
@@ -429,8 +422,6 @@ fn cross_machine_reparent_requires_atomic_placement_and_route_repair() {
     let placement = f.p.place(f.d, orphan, point(30., 750.));
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: vec![],
         label: None,
     });
@@ -465,8 +456,6 @@ fn cross_machine_reparent_requires_atomic_placement_and_route_repair() {
                 diagram: other,
                 route: EdgeRoute {
                     edge,
-                    source_attachment: None,
-                    target_attachment: None,
                     waypoints: vec![],
                     label: None,
                 },
@@ -594,8 +583,6 @@ fn layout_reserves_internal_rows_and_state_routes_retain_hard_pins() {
     let pins = vec![point(730., 130.), point(1060., 130.)];
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: f.self_edge,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: pins.clone(),
         label: Some(EdgeLabel {
             fraction: 0.25,
@@ -665,8 +652,6 @@ fn moving_a_region_does_not_translate_pins_attached_to_a_stationary_state_bounda
     let pins = vec![point(280., 390.), point(280., 470.)];
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: f.local,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: pins.clone(),
         label: None,
     });
@@ -745,8 +730,6 @@ fn initial_transition_attaches_to_the_compact_symbol_and_preview_keeps_settled_g
     );
     f.p.diagrams.get_mut(&f.d).unwrap().routes.push(EdgeRoute {
         edge: f.self_edge,
-        source_attachment: None,
-        target_attachment: None,
         waypoints: vec![],
         label: Some(EdgeLabel {
             fraction: 0.3,

crates/oa-core/tests/transition_counterpart_compatibility.rs

@@ -1,353 +0,0 @@
-//! Existing counterpart eligibility is a layer/category/kind decision, not
-//! validation or acceptance of an entire transition plan. The catalog fixtures
-//! below intentionally contain partial records (unowned states, etc.). The
-//! final regression separately starts from a structurally valid real project.
-use oa_core::{transitions::*, *};
-use std::collections::{BTreeMap, BTreeSet};
-
-fn element(p: &mut Project, layer: Layer, kind: Kind) -> Id {
-    let id = Id::new_v4();
-    let body = if kind == Kind::Port {
-        // Legacy ports can exist in preserved OA models. This does not offer
-        // new typed SA implementation ports for creation in portless OA.
-        ElementBody::shared_in(
-            layer,
-            SharedBody::Port {
-                contract: PortContract::Legacy,
-                legacy: None,
-            },
-        )
-    } else {
-        ElementBody::new(kind, layer).unwrap()
-    };
-    p.elements.insert(
-        id,
-        Element {
-            id,
-            alias: format!("candidate_{}", id.simple()),
-            name: "Identical candidate label".into(),
-            description: String::new(),
-            parent: None,
-            body,
-        },
-    );
-    id
-}
-
-#[test]
-fn existing_element_candidates_obey_explicit_engineering_families_in_both_directions() {
-    // Contract: language.rst §5 trace families and the explicit capability /
-    // mission alternative. State constructors remain eligible for explicit
-    // review across the state family; selecting a candidate does not accept a
-    // constructor change or make invalid ownership legal.
-    let mut allowed: BTreeSet<(Kind, Kind)> = [
-        (Kind::Activity, Kind::Function),
-        (Kind::Entity, Kind::System),
-        (Kind::Entity, Kind::SystemActor),
-        (Kind::Actor, Kind::System),
-        (Kind::Actor, Kind::SystemActor),
-        (Kind::Capability, Kind::SystemCapability),
-        (Kind::OperationalMission, Kind::Mission),
-        (Kind::Capability, Kind::Mission),
-        (Kind::Process, Kind::FunctionalChain),
-    ]
-    .into_iter()
-    .collect();
-    for kind in [
-        Kind::ExchangeItem,
-        Kind::ExchangeCategory,
-        Kind::DataType,
-        Kind::DataField,
-        Kind::Interface,
-        Kind::Port,
-        Kind::Scenario,
-        Kind::Lifeline,
-        Kind::Occurrence,
-        Kind::StateMachine,
-        Kind::Region,
-        Kind::Event,
-        Kind::Constraint,
-    ] {
-        allowed.insert((kind, kind));
-    }
-    let vertices = [
-        Kind::State,
-        Kind::Mode,
-        Kind::Initial,
-        Kind::Final,
-        Kind::Choice,
-        Kind::Junction,
-        Kind::Fork,
-        Kind::Join,
-        Kind::ShallowHistory,
-        Kind::DeepHistory,
-        Kind::EntryPoint,
-        Kind::ExitPoint,
-        Kind::Terminate,
-    ];
-    for oa in vertices {
-        for sa in vertices {
-            allowed.insert((oa, sa));
-        }
-    }
-    let mut p = Project::empty();
-    let oa: BTreeMap<_, _> = Kind::ALL
-        .into_iter()
-        .filter(|kind| kind.supports(Layer::Oa))
-        .map(|kind| (kind, element(&mut p, Layer::Oa, kind)))
-        .collect();
-    let sa: BTreeMap<_, _> = Kind::ALL
-        .into_iter()
-        .filter(|kind| kind.supports(Layer::Sa))
-        .map(|kind| (kind, element(&mut p, Layer::Sa, kind)))
-        .collect();
-    let original = p.clone();
-    for (&oa_kind, &oa_id) in &oa {
-        for (&sa_kind, &sa_id) in &sa {
-            let expected = allowed.contains(&(oa_kind, sa_kind));
-            assert_eq!(
-                counterpart_compatible(&p, oa_id, sa_id, TransitionDirection::OaToSa),
-                expected,
-                "OA {oa_kind:?} → SA {sa_kind:?}"
-            );
-            assert_eq!(
-                counterpart_compatible(&p, sa_id, oa_id, TransitionDirection::SaToOa),
-                expected,
-                "SA {sa_kind:?} → OA {oa_kind:?}"
-            );
-        }
-    }
-    assert_eq!(
-        p, original,
-        "Eligibility must not establish correspondence or edit records"
-    );
-}
-
-fn relation(p: &mut Project, kind: RelationKind, anchor: Id) -> Id {
-    let id = Id::new_v4();
-    // Only the semantic layer and relation category participate in candidate
-    // eligibility. Endpoint compatibility belongs to full plan validation.
-    p.relations.insert(
-        id,
-        Relation {
-            id,
-            alias: format!("relation_{}", id.simple()),
-            name: "Identical relation label".into(),
-            description: String::new(),
-            body: RelationBody::new(kind, anchor, anchor),
-        },
-    );
-    id
-}
-
-#[test]
-fn existing_relation_candidates_distinguish_work_boundary_and_shared_relations() {
-    // Work and boundary exchanges are different families. The boundary /
-    // boundary pair permits preserved legacy OA boundary records; ordinary
-    // portless OA communication means map to SA boundary exchanges.
-    let mut allowed = vec![
-        (RelationKind::Interaction, RelationKind::FunctionalExchange),
-        (
-            RelationKind::CommunicationMean,
-            RelationKind::BoundaryExchange,
-        ),
-        (
-            RelationKind::BoundaryExchange,
-            RelationKind::BoundaryExchange,
-        ),
-    ];
-    let shared = [
-        RelationKind::Allocation,
-        RelationKind::InterfaceItemAllocation,
-        RelationKind::DataAssociation,
-        RelationKind::ExchangeAllocation,
-        RelationKind::CapabilityInvolvement,
-        RelationKind::CapabilityInclude,
-        RelationKind::CapabilityExtend,
-        RelationKind::CapabilityGeneralization,
-        RelationKind::MissionInvolvement,
-        RelationKind::MissionCapability,
-        RelationKind::SequenceLink,
-        RelationKind::ContextualLink,
-        RelationKind::ChainInvolvement,
-        RelationKind::InterfaceProvision,
-        RelationKind::InterfaceRequirement,
-        RelationKind::StateTransition,
-        RelationKind::Availability,
-        RelationKind::StateAction,
-    ];
-    for kind in shared {
-        allowed.push((kind, kind));
-    }
-    let mut p = Project::empty();
-    let oa_anchor = element(&mut p, Layer::Oa, Kind::Activity);
-    let sa_anchor = element(&mut p, Layer::Sa, Kind::Function);
-    let oa: Vec<_> = shared
-        .into_iter()
-        .chain([
-            RelationKind::Interaction,
-            RelationKind::CommunicationMean,
-            RelationKind::BoundaryExchange,
-            RelationKind::RoleRealization,
-            RelationKind::RoleAssignment,
-        ])
-        .map(|kind| (kind, relation(&mut p, kind, oa_anchor)))
-        .collect();
-    let sa: Vec<_> = shared
-        .into_iter()
-        .chain([
-            RelationKind::FunctionalExchange,
-            RelationKind::BoundaryExchange,
-            RelationKind::PortAllocation,
-        ])
-        .map(|kind| (kind, relation(&mut p, kind, sa_anchor)))
-        .collect();
-    for &(oa_kind, oa_id) in &oa {
-        for &(sa_kind, sa_id) in &sa {
-            let expected = allowed.contains(&(oa_kind, sa_kind));
-            assert_eq!(
-                counterpart_compatible(&p, oa_id, sa_id, TransitionDirection::OaToSa),
-                expected,
-                "OA {oa_kind:?} → SA {sa_kind:?}"
-            );
-            assert_eq!(
-                counterpart_compatible(&p, sa_id, oa_id, TransitionDirection::SaToOa),
-                expected,
-                "SA {sa_kind:?} → OA {oa_kind:?}"
-            );
-        }
-    }
-}
-
-#[test]
-fn candidate_eligibility_rejects_wrong_layers_categories_and_missing_identities() {
-    let mut p = Project::empty();
-    let oa = element(&mut p, Layer::Oa, Kind::Activity);
-    let sa = element(&mut p, Layer::Sa, Kind::Function);
-    let oa_exchange = relation(&mut p, RelationKind::Interaction, oa);
-    let sa_exchange = relation(&mut p, RelationKind::FunctionalExchange, sa);
-    let diagram = p.ensure_diagram(Layer::Sa);
-    let node = p.place(diagram, sa, Position { x: 1., y: 2. });
-    for (direction, source, target, source_relation, target_relation) in [
-        (
-            TransitionDirection::OaToSa,
-            oa,
-            sa,
-            oa_exchange,
-            sa_exchange,
-        ),
-        (
-            TransitionDirection::SaToOa,
-            sa,
-            oa,
-            sa_exchange,
-            oa_exchange,
-        ),
-    ] {
-        assert!(counterpart_compatible(&p, source, target, direction));
-        assert!(counterpart_compatible(
-            &p,
-            source_relation,
-            target_relation,
-            direction
-        ));
-        for (a, b) in [
-            (target, source),
-            (source, source),
-            (target, target),
-            (target_relation, source_relation),
-            (source_relation, source_relation),
-            (source, target_relation),
-            (source_relation, target),
-        ] {
-            assert!(!counterpart_compatible(&p, a, b, direction));
-        }
-        for absent_or_nonsemantic in [Id::nil(), Id::new_v4(), p.id, diagram, node] {
-            assert!(!counterpart_compatible(
-                &p,
-                source,
-                absent_or_nonsemantic,
-                direction
-            ));
-            assert!(!counterpart_compatible(
-                &p,
-                absent_or_nonsemantic,
-                target,
-                direction
-            ));
-        }
-    }
-    p.elements.remove(&sa);
-    assert!(!counterpart_compatible(
-        &p,
-        oa,
-        sa,
-        TransitionDirection::OaToSa
-    ));
-    assert!(!counterpart_compatible(
-        &p,
-        sa,
-        oa,
-        TransitionDirection::SaToOa
-    ));
-    // The retained relation header cannot borrow a layer from a deleted owner.
-    assert!(!counterpart_compatible(
-        &p,
-        oa_exchange,
-        sa_exchange,
-        TransitionDirection::OaToSa
-    ));
-}
-
-#[test]
-fn activity_picker_rejects_real_sa_port_and_agrees_with_explicit_plan_refusal() {
-    let p = Project::demo();
-    let original = p.clone();
-    assert!(validation::validate(&p).is_empty());
-    let source = p
-        .elements
-        .values()
-        .find(|e| e.kind() == Kind::Activity)
-        .unwrap()
-        .id;
-    let port = p
-        .elements
-        .values()
-        .find(|e| e.layer() == Layer::Sa && e.kind() == Kind::Port)
-        .unwrap()
-        .id;
-    let function = p
-        .elements
-        .values()
-        .find(|e| e.kind() == Kind::Function)
-        .unwrap()
-        .id;
-    assert!(counterpart_compatible(
-        &p,
-        source,
-        function,
-        TransitionDirection::OaToSa
-    ));
-    assert!(!counterpart_compatible(
-        &p,
-        source,
-        port,
-        TransitionDirection::OaToSa
-    ));
-    let mut request = TransitionRequest::new(TransitionDirection::OaToSa, vec![source]);
-    request.mappings.push(TransitionMapping {
-        source,
-        target: Some(port),
-        target_kind: None,
-    });
-    let plan = plan_transition(&p, &request).unwrap();
-    assert!(
-        plan.conflicts
-            .iter()
-            .any(|conflict| conflict.source == Some(source)
-                && conflict.target == Some(port)
-                && conflict.field.is_none())
-    );
-    assert!(apply_transition(&p, &plan).is_err());
-    assert_eq!(p, original);
-}

crates/oa-core/tests/transition_lifecycle.rs

@@ -1,638 +0,0 @@
-//! Endpoint lifecycle acceptance for the ordinary, prose-reviewed transition API.
-//! OA is portless; the SA half contains typed ports. Deletion expectations below
-//! are fixture-owned identity lists, never results of the deletion implementation.
-use oa_core::{
-    language, persistence,
-    source_project::{ProjectLimits, SourceBundle, compile_bundle},
-    transitions::*,
-    validation::{self, Severity},
-    *,
-};
-use std::collections::BTreeMap;
-
-struct Side {
-    root: Id,
-    elements: Vec<Id>,
-    exchange: Id,
-    diagram: Id,
-    nodes: Vec<Id>,
-    artifacts: Vec<Id>,
-}
-
-struct Fixture {
-    project: Project,
-    source: Side,
-    target: Side,
-    trace: Id,
-    trace_artifact: Id,
-}
-
-fn artifact(p: &mut Project, owner: Id, label: &str) -> Id {
-    let id = Id::new_v4();
-    p.artifact_links.insert(
-        id,
-        ArtifactLink {
-            id,
-            alias: p.fresh_alias(label, "evidence", id),
-            name: label.into(),
-            description: "Independently authored rationale".into(),
-            owner,
-            relation: ArtifactRelation::References,
-            uri: "git:engineering/design.md".into(),
-            revision: Some("review-17".into()),
-            fragment: Some("retained-decision".into()),
-        },
-    );
-    id
-}
-
-fn side(p: &mut Project, layer: Layer) -> Side {
-    let (kind, prefix, relation) = match layer {
-        Layer::Oa => (Kind::Activity, "Operational", RelationKind::Interaction),
-        Layer::Sa => (
-            Kind::Function,
-            "Technical",
-            RelationKind::FunctionalExchange,
-        ),
-    };
-    let root = p
-        .add_element(kind, layer, &format!("{prefix} design"), None)
-        .unwrap();
-    p.elements.get_mut(&root).unwrap().description =
-        format!("{prefix} independently reviewed intent");
-    let send = p
-        .add_element(kind, layer, &format!("{prefix} send"), Some(root))
-        .unwrap();
-    let receive = p
-        .add_element(kind, layer, &format!("{prefix} receive"), Some(root))
-        .unwrap();
-    p.elements.get_mut(&send).unwrap().description =
-        "Preserve the detailed sending responsibility".into();
-    p.elements.get_mut(&receive).unwrap().description =
-        "Preserve the detailed receiving responsibility".into();
-    // A shared, separately owned definition survives deletion of its users.
-    let item = p
-        .add_element(
-            Kind::ExchangeItem,
-            layer,
-            &format!("{prefix} information"),
-            None,
-        )
-        .unwrap();
-    *p.elements.get_mut(&item).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem {
-        kind: ExchangeItemKind::Information,
-        mechanism: ExchangeMechanism::Flow,
-        supertype: None,
-    };
-    p.add_element(
-        Kind::DataField,
-        layer,
-        &format!("{prefix} payload"),
-        Some(item),
-    )
-    .unwrap();
-    let exchange = p.relate(relation, &format!("{prefix} delivery"), send, receive);
-    let mut elements = vec![root, send, receive];
-    match &mut p.relations.get_mut(&exchange).unwrap().body {
-        RelationBody::Interaction { items, .. } => *items = vec![item],
-        RelationBody::FunctionalExchange {
-            items,
-            source_port,
-            target_port,
-            ..
-        } => {
-            *items = vec![item];
-            let (output, input) = (*source_port, *target_port);
-            *p.elements.get_mut(&output).unwrap().shared_mut().unwrap() = SharedBody::Port {
-                contract: PortContract::FunctionOutput {
-                    outgoing_items: vec![item],
-                },
-                legacy: None,
-            };
-            *p.elements.get_mut(&input).unwrap().shared_mut().unwrap() = SharedBody::Port {
-                contract: PortContract::FunctionInput {
-                    incoming_items: vec![item],
-                },
-                legacy: None,
-            };
-            elements.extend([output, input]);
-        }
-        _ => unreachable!(),
-    }
-    p.relations.get_mut(&exchange).unwrap().description =
-        "Retain direction, item contract and relation identity".into();
-    let diagram = p.ensure_diagram(layer);
-    p.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Decomposition;
-    let nodes = [root, send, receive]
-        .into_iter()
-        .enumerate()
-        .map(|(index, element)| {
-            p.place(
-                diagram,
-                element,
-                Position {
-                    x: 43.25 + index as f32 * 271.,
-                    y: 97.5 + index as f32 * 83.,
-                },
-            )
-        })
-        .collect::<Vec<_>>();
-    let root_node = p
-        .diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .nodes
-        .get_mut(&nodes[0])
-        .unwrap();
-    root_node.size = Size {
-        width: 611.,
-        height: 319.,
-    };
-    root_node.collapsed = true;
-    p.diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .routes
-        .push(EdgeRoute {
-            edge: exchange,
-            // Both directions must preserve authored endpoint preferences,
-            // including dormant preferences on the SA semantic-port edge.
-            source_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Bottom,
-                offset: 0.2,
-            }),
-            target_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Top,
-                offset: 0.8,
-            }),
-            waypoints: vec![Position {
-                x: 337.5,
-                y: 423.25,
-            }],
-            label: Some(EdgeLabel {
-                fraction: 0.7,
-                offset: Position { x: 11., y: -17. },
-            }),
-        });
-    let artifacts = [root, send, exchange, nodes[0]]
-        .into_iter()
-        .enumerate()
-        .map(|(index, owner)| artifact(p, owner, &format!("{prefix} evidence {index}")))
-        .collect();
-    artifact(p, item, &format!("{prefix} shared item evidence"));
-    Side {
-        root,
-        elements,
-        exchange,
-        diagram,
-        nodes,
-        artifacts,
-    }
-}
-
-fn accepted(p: &Project) {
-    let issues = validation::validate(p);
-    // This fixture deliberately isolates decomposition and correspondence from
-    // performer allocation and process/chain/scenario inclusion. Each surviving
-    // leaf (including a newly transitioned root) must have exactly those two
-    // incomplete-work warnings; each surviving local exchange lacks a behavior
-    // context. Check exact record IDs and fields, including duplicate warnings.
-    // The system of interest and item contracts are complete fixture facts.
-    assert!(
-        issues
-            .iter()
-            .all(|issue| issue.severity == Severity::Warning),
-        "{issues:?}"
-    );
-    let mut expected = Vec::new();
-    for element in p.elements.values().filter(|element| {
-        matches!(element.kind(), Kind::Activity | Kind::Function)
-            && !p
-                .elements
-                .values()
-                .any(|child| child.parent == Some(element.id) && child.kind() == element.kind())
-    }) {
-        expected.push(("unallocated_leaf", Some(element.id), Some("allocation")));
-        expected.push(("work_without_behavior_context", Some(element.id), None));
-    }
-    for relation in p.relations.values().filter(|relation| {
-        matches!(
-            relation.kind(),
-            RelationKind::Interaction | RelationKind::FunctionalExchange
-        )
-    }) {
-        expected.push(("exchange_without_behavior_context", Some(relation.id), None));
-    }
-    let mut actual = issues
-        .iter()
-        .map(|issue| (issue.code.as_str(), issue.element, issue.field.as_deref()))
-        .collect::<Vec<_>>();
-    expected.sort();
-    actual.sort();
-    assert_eq!(
-        actual, expected,
-        "Unexpected fixture diagnostics: {issues:?}"
-    );
-}
-
-fn round_trip(p: &Project) -> String {
-    accepted(p);
-    let json = serde_json::to_vec_pretty(p).unwrap();
-    assert_eq!(persistence::decode(&json).unwrap(), *p);
-    let source = language::format(p);
-    let compiled = compile_bundle(
-        &SourceBundle {
-            entry: "project.arcadia".into(),
-            files: BTreeMap::from([("project.arcadia".into(), source.clone())]),
-        },
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    assert_eq!(compiled.decoded.project, *p);
-    assert_eq!(language::format(&compiled.decoded.project), source);
-    source
-}
-
-fn explicit(direction: TransitionDirection, source: Id, target: Id) -> TransitionRequest {
-    let mut request = TransitionRequest::new(direction, vec![source]);
-    request.mappings.push(TransitionMapping {
-        source,
-        target: Some(target),
-        target_kind: None,
-    });
-    request
-}
-
-fn fixture(direction: TransitionDirection) -> Fixture {
-    let mut project = Project::empty();
-    project.name = "Endpoint lifecycle conservation".into();
-    project
-        .add_element(Kind::System, Layer::Sa, "System of interest", None)
-        .unwrap();
-    let oa = side(&mut project, Layer::Oa);
-    let sa = side(&mut project, Layer::Sa);
-    let (source, target) = match direction {
-        TransitionDirection::OaToSa => (oa, sa),
-        TransitionDirection::SaToOa => (sa, oa),
-    };
-    accepted(&project);
-    let before = project.clone();
-    let mut request = explicit(direction, source.root, target.root);
-    for field in [TransitionField::Name, TransitionField::Description] {
-        request.resolutions.push(FieldResolution {
-            source: source.root,
-            field,
-            decision: FieldDecision::KeepTarget,
-        });
-    }
-    let plan = plan_transition(&project, &request).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    project = apply_transition(&project, &plan).unwrap();
-    let trace = assert_only_new_trace(&before, &project, direction, source.root, target.root);
-    let mut without_trace = project.clone();
-    without_trace.traces.remove(&trace);
-    assert_eq!(
-        without_trace, before,
-        "Initial review must only add correspondence"
-    );
-    let trace_artifact = artifact(&mut project, trace, "Correspondence rationale");
-    round_trip(&project);
-    Fixture {
-        project,
-        source,
-        target,
-        trace,
-        trace_artifact,
-    }
-}
-
-fn assert_only_new_trace(
-    before: &Project,
-    after: &Project,
-    direction: TransitionDirection,
-    source: Id,
-    target: Id,
-) -> Id {
-    let added = after
-        .traces
-        .values()
-        .filter(|trace| !before.traces.contains_key(&trace.id))
-        .collect::<Vec<_>>();
-    assert_eq!(added.len(), 1);
-    assert_eq!(after.traces.len(), before.traces.len() + 1);
-    let trace = added[0];
-    let (oa, sa) = match direction {
-        TransitionDirection::OaToSa => (source, target),
-        TransitionDirection::SaToOa => (target, source),
-    };
-    assert_eq!(
-        (trace.oa, trace.sa, trace.kind),
-        (oa, sa, TraceKind::Refinement)
-    );
-    assert_eq!(
-        trace.baseline,
-        Some(TraceBaseline {
-            oa: after.properties(oa).unwrap(),
-            sa: after.properties(sa).unwrap(),
-            semantic: None,
-        })
-    );
-    assert_eq!(trace_drift(after, trace), Drift::Unchanged);
-    trace.id
-}
-
-fn expected_deletion(fixture: &Fixture, side: &Side) -> Project {
-    let mut expected = fixture.project.clone();
-    for id in &side.elements {
-        assert!(expected.elements.remove(id).is_some());
-    }
-    assert!(expected.relations.remove(&side.exchange).is_some());
-    assert!(expected.traces.remove(&fixture.trace).is_some());
-    for id in side.artifacts.iter().chain([&fixture.trace_artifact]) {
-        assert!(expected.artifact_links.remove(id).is_some());
-    }
-    let diagram = expected.diagrams.get_mut(&side.diagram).unwrap();
-    for id in &side.nodes {
-        assert!(diagram.nodes.remove(id).is_some());
-    }
-    // This fixture authored exactly one route, for its removed local exchange.
-    assert_eq!(diagram.routes.len(), 1);
-    assert_eq!(diagram.routes[0].edge, side.exchange);
-    diagram.routes.clear();
-    expected
-}
-
-fn unchanged_retry(p: &Project, direction: TransitionDirection, source: Id, target: Id) {
-    let request = TransitionRequest::new(direction, vec![source]);
-    let plan = plan_transition(p, &request).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    assert_eq!(plan.changes.len(), 1);
-    assert_eq!(
-        (
-            plan.changes[0].source,
-            plan.changes[0].target,
-            plan.changes[0].action
-        ),
-        (source, target, TransitionAction::Reuse)
-    );
-    assert!(plan.changes[0].fields.is_empty());
-    assert!(plan.commands.is_empty(), "{:?}", plan.commands);
-    let mut session = Session::new(p.clone());
-    let revision = session.revision();
-    session
-        .execute(Command::Replace(apply_transition(p, &plan).unwrap()))
-        .unwrap();
-    assert_eq!(session.project(), p);
-    assert_eq!(session.revision(), revision);
-    assert!(!session.can_undo());
-}
-
-fn source_deletion(direction: TransitionDirection) {
-    let fixture = fixture(direction);
-    let original_source = round_trip(&fixture.project);
-    let expected = expected_deletion(&fixture, &fixture.source);
-    let mut session = Session::new(fixture.project.clone());
-    session
-        .execute(Command::Delete(fixture.source.root))
-        .unwrap();
-    // Whole-project equality covers every retained target child, typed SA port,
-    // exchange, placement, route, artifact, shared item and unchanged identity.
-    assert_eq!(session.project(), &expected);
-    let deleted_source = round_trip(session.project());
-    session.undo();
-    assert_eq!(session.project(), &fixture.project);
-    assert_eq!(round_trip(session.project()), original_source);
-    assert!(!session.can_undo(), "Deletion is one history transaction");
-    session.redo();
-    assert_eq!(session.project(), &expected);
-    assert_eq!(round_trip(session.project()), deleted_source);
-}
-
-fn implicit_creation(
-    p: &Project,
-    direction: TransitionDirection,
-    source: Id,
-    forbidden_target: Id,
-) -> (Project, Id) {
-    let request = TransitionRequest::new(direction, vec![source]);
-    let plan = plan_transition(p, &request).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    assert_eq!(plan.changes.len(), 1);
-    let change = &plan.changes[0];
-    assert_eq!(change.source, source);
-    assert_eq!(change.action, TransitionAction::Create);
-    let target = change.target;
-    assert_ne!(target, forbidden_target);
-    assert!(!p.contains(target));
-    let after = apply_transition(p, &plan).unwrap();
-    let trace = assert_only_new_trace(p, &after, direction, source, target);
-    let created = &after.elements[&target];
-    assert_eq!(created.id, target, "Apply preserves the preview identity");
-    assert_eq!(created.name, p.elements[&source].name);
-    assert_eq!(created.description, p.elements[&source].description);
-    assert_eq!(created.parent, None);
-    assert_eq!(
-        created.body,
-        match direction {
-            TransitionDirection::OaToSa => ElementBody::Sa(SaBody::Function),
-            TransitionDirection::SaToOa => ElementBody::Oa(OaBody::Activity),
-        }
-    );
-    assert!(!created.alias.is_empty());
-    assert!(
-        !p.identities()
-            .iter()
-            .any(|(_, alias)| *alias == created.alias)
-    );
-    // Remove only the independently expected two additions. Any incidental
-    // mutation, clone of target children or extra correspondence fails here.
-    let mut retained = after.clone();
-    retained.elements.remove(&target);
-    retained.traces.remove(&trace);
-    assert_eq!(retained, *p);
-    round_trip(&after);
-    // Replaying a creation plan after acceptance violates its snapshot, while
-    // a fresh unchanged request reuses the accepted counterpart.
-    assert!(
-        apply_transition(&after, &plan)
-            .unwrap_err()
-            .0
-            .contains("stale")
-    );
-    unchanged_retry(&after, direction, source, target);
-    (after, target)
-}
-
-fn target_deletion(direction: TransitionDirection) {
-    let fixture = fixture(direction);
-    let request = TransitionRequest::new(direction, vec![fixture.source.root]);
-    let old_plan = plan_transition(&fixture.project, &request).unwrap();
-    assert!(old_plan.conflicts.is_empty());
-    let expected = expected_deletion(&fixture, &fixture.target);
-    let mut session = Session::new(fixture.project.clone());
-    session
-        .execute(Command::Delete(fixture.target.root))
-        .unwrap();
-    assert_eq!(session.project(), &expected);
-    round_trip(session.project());
-    let revision = session.revision();
-    assert!(
-        apply_transition(session.project(), &old_plan)
-            .unwrap_err()
-            .0
-            .contains("stale")
-    );
-    let explicit_plan = plan_transition(
-        session.project(),
-        &explicit(direction, fixture.source.root, fixture.target.root),
-    )
-    .unwrap();
-    assert!(
-        explicit_plan
-            .conflicts
-            .iter()
-            .any(|conflict| conflict.source == Some(fixture.source.root)
-                && conflict.target == Some(fixture.target.root)
-                && conflict.field.is_none())
-    );
-    assert!(apply_transition(session.project(), &explicit_plan).is_err());
-    assert_eq!(session.project(), &expected);
-    assert_eq!(session.revision(), revision);
-    let (created, _) = implicit_creation(
-        session.project(),
-        direction,
-        fixture.source.root,
-        fixture.target.root,
-    );
-    session.execute(Command::Replace(created.clone())).unwrap();
-    session.undo();
-    assert_eq!(session.project(), &expected);
-    session.undo();
-    assert_eq!(session.project(), &fixture.project);
-    assert!(!session.can_undo());
-    session.redo();
-    session.redo();
-    assert_eq!(session.project(), &created);
-    round_trip(session.project());
-}
-
-fn source_recreation(direction: TransitionDirection) {
-    let fixture = fixture(direction);
-    let mut replacement = fixture.project.elements[&fixture.source.root].clone();
-    replacement.id = Id::new_v4();
-    let source = replacement.id;
-    // Same alias, name and prose, different UUID: name matching must never
-    // silently relink the retained engineering design.
-    assert_ne!(source, fixture.source.root);
-    let deleted = execute_batch(&fixture.project, &[Command::Delete(fixture.source.root)]).unwrap();
-    assert_eq!(deleted, expected_deletion(&fixture, &fixture.source));
-    let recreated =
-        execute_batch(&deleted, &[Command::CreateElement(replacement.clone())]).unwrap();
-    let mut expected = deleted.clone();
-    expected.elements.insert(source, replacement);
-    assert_eq!(recreated, expected);
-    round_trip(&recreated);
-    let (implicit, new_target) =
-        implicit_creation(&recreated, direction, source, fixture.target.root);
-    assert!(implicit.elements.contains_key(&fixture.target.root));
-    assert_ne!(new_target, fixture.target.root);
-
-    // The explicit branch starts from exactly the same recreated project.
-    let mut request = explicit(direction, source, fixture.target.root);
-    let unreviewed = plan_transition(&recreated, &request).unwrap();
-    for field in [TransitionField::Name, TransitionField::Description] {
-        assert!(
-            unreviewed
-                .conflicts
-                .iter()
-                .any(|conflict| conflict.source == Some(source)
-                    && conflict.target == Some(fixture.target.root)
-                    && conflict.field == Some(field))
-        );
-    }
-    assert!(apply_transition(&recreated, &unreviewed).is_err());
-    request.resolutions = vec![
-        FieldResolution {
-            source,
-            field: TransitionField::Name,
-            decision: FieldDecision::TakeSource,
-        },
-        FieldResolution {
-            source,
-            field: TransitionField::Description,
-            decision: FieldDecision::KeepTarget,
-        },
-    ];
-    let plan = plan_transition(&recreated, &request).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    assert_eq!(plan.changes.len(), 1);
-    assert_eq!(
-        (plan.changes[0].target, plan.changes[0].action),
-        (fixture.target.root, TransitionAction::Update)
-    );
-    assert_eq!(
-        plan.changes[0].fields,
-        vec![FieldChange {
-            field: TransitionField::Name,
-            before: recreated.elements[&fixture.target.root].name.clone(),
-            after: recreated.elements[&source].name.clone(),
-        }]
-    );
-    let relinked = apply_transition(&recreated, &plan).unwrap();
-    let new_trace = assert_only_new_trace(
-        &recreated,
-        &relinked,
-        direction,
-        source,
-        fixture.target.root,
-    );
-    assert_ne!(
-        new_trace, fixture.trace,
-        "Deleted correspondence is not silently resurrected"
-    );
-    let mut expected = recreated.clone();
-    expected
-        .elements
-        .get_mut(&fixture.target.root)
-        .unwrap()
-        .name = recreated.elements[&source].name.clone();
-    let mut without_trace = relinked.clone();
-    without_trace.traces.remove(&new_trace);
-    assert_eq!(
-        without_trace, expected,
-        "Only the reviewed target name may change; rich target design survives"
-    );
-    round_trip(&relinked);
-    unchanged_retry(&relinked, direction, source, fixture.target.root);
-    let original_source = round_trip(&recreated);
-    let mut session = Session::new(recreated.clone());
-    session.execute(Command::Replace(relinked)).unwrap();
-    session.undo();
-    assert_eq!(session.project(), &recreated);
-    assert_eq!(round_trip(session.project()), original_source);
-}
-
-#[test]
-fn oa_source_deletion_preserves_rich_sa_design_and_exact_undo() {
-    source_deletion(TransitionDirection::OaToSa);
-}
-#[test]
-fn sa_source_deletion_preserves_rich_portless_oa_design_and_exact_undo() {
-    source_deletion(TransitionDirection::SaToOa);
-}
-#[test]
-fn deleted_sa_target_refuses_old_plans_and_implicit_retry_creates_once() {
-    target_deletion(TransitionDirection::OaToSa);
-}
-#[test]
-fn deleted_oa_target_refuses_old_plans_and_implicit_retry_creates_once() {
-    target_deletion(TransitionDirection::SaToOa);
-}
-#[test]
-fn recreated_oa_identity_requires_explicit_relink_to_retained_sa_design() {
-    source_recreation(TransitionDirection::OaToSa);
-}
-#[test]
-fn recreated_sa_identity_requires_explicit_relink_to_retained_oa_design() {
-    source_recreation(TransitionDirection::SaToOa);
-}

crates/oa-desktop/examples/allocation_policy_probe.rs

@@ -1,14 +0,0 @@
-//! Focused test harness for the production Allocation planner and Document.
-//! This does not exercise App input, painting, or native gestures.
-
-#[cfg(test)]
-#[allow(dead_code)] // App-facing entry points are intentionally absent here.
-#[path = "../src/allocation_drag.rs"]
-mod allocation_drag;
-
-#[cfg(test)]
-#[allow(dead_code, unused_imports)] // App-facing API and reexports are absent here.
-#[path = "../src/document.rs"]
-mod document;
-
-fn main() {}

crates/oa-desktop/src/allocation_drag.rs

@@ -1,848 +0,0 @@
-//! Pure, bounded allocation-drag composition. See the v2 interaction contract.
-//!
-//! These values are not input capabilities. The App must independently admit a
-//! clean press and retire its token on every document/input/camera lifetime
-//! change. Cache a SemanticPlan per token and destination; only `place` belongs
-//! on pointer motion. `finish` rechecks the live accepted Project and commands,
-//! but Document::execute still owns source admission and atomic history.
-use oa_core::{
-    projection::{self, ProjectedNode, ProjectedView},
-    validation::{self, Issue, Severity},
-    view_options::ViewIndex,
-    *,
-};
-use std::collections::{BTreeMap, BTreeSet};
-
-// The pure planner is verified before its App gesture adapter is connected.
-#[allow(dead_code)]
-#[path = "allocation_drag/arrange.rs"]
-pub mod arrange;
-
-#[path = "allocation_drag/geometry.rs"]
-mod geometry;
-
-// The combined semantic planner is verified before connecting its App adapter.
-#[allow(dead_code)]
-#[path = "allocation_drag/assignment.rs"]
-pub mod assignment;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Destination {
-    LayoutOnly,
-    Performer(Id),
-    OutsidePerformers,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Uniform {
-    Assigned(Id),
-    Unassigned,
-    MixedOrUnresolved,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Leaf {
-    pub direct: Option<Relation>,
-    pub role_assignments: Vec<Relation>,
-    pub role_realizations: Vec<Relation>,
-    pub effective_performer: Option<Id>,
-}
-
-/// Exact semantic scope S, leaf scope L and active placement scope Q, including
-/// folded/unplaced leaves. Retaining records detects first-child responsibility
-/// transfer. Revision and input-epoch guards remain the caller's responsibility.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Scope {
-    pub project: Id,
-    pub work: Id,
-    pub placement: Id,
-    pub work_records: BTreeMap<Id, Element>,
-    pub leaves: BTreeMap<Id, Leaf>,
-    pub placements: BTreeMap<Id, NodePlacement>,
-    pub diagram: Diagram,
-    pub uniform: Uniform,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ChangedRecord {
-    pub id: Id,
-    pub name: String,
-    pub category: &'static str,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Refusal {
-    Ineligible(String),
-    StaleScope,
-    MixedLayoutRequired,
-    RoleExitRequired {
-        work: Id,
-        roles: Vec<Id>,
-        performers: Vec<Id>,
-        message: String,
-    },
-    MissingAllocationId(Id),
-    InvalidCandidate(String),
-    CollateralChangeRequired(Vec<ChangedRecord>),
-    LayoutRequired(String),
-}
-
-pub fn capture(p: &Project, diagram: Id, work: Id, placement: Id) -> Result<Scope, Refusal> {
-    validate_candidate(p).map_err(|e| Refusal::InvalidCandidate(e.to_string()))?;
-    capture_validated(p, diagram, work, placement)
-}
-
-/// Collect work facts after the caller's single complete Project validation.
-fn capture_validated(p: &Project, diagram: Id, work: Id, placement: Id) -> Result<Scope, Refusal> {
-    let d = p.diagrams.get(&diagram).ok_or(Refusal::StaleScope)?;
-    let root = p.elements.get(&work).ok_or(Refusal::StaleScope)?;
-    if !root.kind().is_work()
-        || d.projection != ProjectionKind::Allocation
-        || d.layer != root.layer()
-    {
-        return Err(Refusal::Ineligible(
-            "Select an activity or function in an Allocation view.".into(),
-        ));
-    }
-    if d.nodes.get(&placement).is_none_or(|n| n.element != work) {
-        return Err(Refusal::StaleScope);
-    }
-    let mut work_records = BTreeMap::new();
-    let mut leaves = BTreeMap::new();
-    let mut pending = vec![work];
-    while let Some(id) = pending.pop() {
-        let element = p.elements.get(&id).ok_or(Refusal::StaleScope)?;
-        if element.kind() != root.kind() || work_records.insert(id, element.clone()).is_some() {
-            return Err(Refusal::StaleScope);
-        }
-        let children: Vec<_> = p
-            .children(id)
-            .filter(|e| e.kind() == root.kind())
-            .map(|e| e.id)
-            .collect();
-        if !children.is_empty() {
-            pending.extend(children);
-            continue;
-        }
-        let direct: Vec<_> = p
-            .relations
-            .values()
-            .filter(|r| r.kind() == RelationKind::Allocation && r.target() == id)
-            .cloned()
-            .collect();
-        if direct.len() > 1 {
-            return Err(Refusal::StaleScope);
-        }
-        let role_assignments: Vec<_> = p
-            .relations
-            .values()
-            .filter(|r| r.kind() == RelationKind::RoleAssignment && r.target() == id)
-            .cloned()
-            .collect();
-        let roles: BTreeSet<_> = role_assignments.iter().map(Relation::source).collect();
-        let role_realizations = p
-            .relations
-            .values()
-            .filter(|r| r.kind() == RelationKind::RoleRealization && roles.contains(&r.target()))
-            .cloned()
-            .collect();
-        leaves.insert(
-            id,
-            Leaf {
-                direct: direct.into_iter().next(),
-                role_assignments,
-                role_realizations,
-                effective_performer: validation::effective_performer(p, id),
-            },
-        );
-    }
-    if leaves.is_empty() {
-        return Err(Refusal::StaleScope);
-    }
-    let uniform = if leaves
-        .values()
-        .all(|l| l.direct.is_none() && l.role_assignments.is_empty())
-    {
-        Uniform::Unassigned
-    } else if let Some(performer) = leaves.values().next().and_then(|l| l.effective_performer)
-        && leaves
-            .values()
-            .all(|l| l.effective_performer == Some(performer))
-    {
-        Uniform::Assigned(performer)
-    } else {
-        Uniform::MixedOrUnresolved
-    };
-    let placements = d
-        .nodes
-        .iter()
-        .filter(|(_, n)| work_records.contains_key(&n.element))
-        .map(|(id, n)| (*id, n.clone()))
-        .collect();
-    Ok(Scope {
-        project: p.id,
-        work,
-        placement,
-        work_records,
-        leaves,
-        placements,
-        diagram: d.clone(),
-        uniform,
-    })
-}
-
-#[derive(Debug)]
-pub struct SemanticPlan {
-    pub scope: Scope,
-    pub destination: Destination,
-    pub label: String,
-    pub warnings: Vec<Issue>,
-    accepted: Project,
-    candidate: Project,
-    index: ViewIndex,
-    commands: Vec<Command>,
-    before_visible: ProjectedView,
-    before_expanded: ProjectedView,
-}
-
-impl SemanticPlan {
-    /// All preview drawing, ports and routing must use this candidate and index.
-    pub fn project(&self) -> &Project {
-        &self.candidate
-    }
-    #[cfg(test)]
-    pub fn index(&self) -> &ViewIndex {
-        &self.index
-    }
-}
-
-/// Allocation identities are allocated once by the gesture owner, keyed by leaf,
-/// and reused on target revisits and release. No random identity generation here.
-pub fn plan_semantics(
-    p: &Project,
-    scope: &Scope,
-    destination: Destination,
-    allocation_ids: &BTreeMap<Id, Id>,
-) -> Result<SemanticPlan, Refusal> {
-    if &capture(p, scope.diagram.id, scope.work, scope.placement)? != scope {
-        return Err(Refusal::StaleScope);
-    }
-    if scope.work_records.len() > 1 && scope.uniform == Uniform::MixedOrUnresolved {
-        return Err(Refusal::MixedLayoutRequired);
-    }
-    if let Destination::Performer(id) = destination {
-        let valid = p
-            .elements
-            .get(&id)
-            .is_some_and(|e| e.kind().is_performer() && e.layer() == scope.diagram.layer);
-        if !valid {
-            return Err(Refusal::Ineligible(
-                "Choose a performer in this layer.".into(),
-            ));
-        }
-    }
-    let before_index = ViewIndex::new(p);
-    let before_visible = projection::project_diagram_with_index(p, &scope.diagram, &before_index);
-    let before_expanded = expanded_view(p, &scope.diagram, scope, &before_index);
-    if scope.work_records.len() > 1 && !coherent(scope, &before_expanded) {
-        return Err(Refusal::MixedLayoutRequired);
-    }
-    let same_performer =
-        matches!(destination, Destination::Performer(id) if scope.uniform == Uniform::Assigned(id));
-    let mut expected = p.clone();
-    let mut edits = IntendedEdits::default();
-    append_semantic_edits(
-        p,
-        scope,
-        destination,
-        allocation_ids,
-        &mut expected,
-        &mut edits,
-    )?;
-    // A route cannot survive the intentional deletion of its own edge, even in
-    // another diagram. No other saved-view cleanup is authorized by this drag.
-    for diagram in expected.diagrams.values_mut() {
-        diagram.routes.retain(|r| !edits.deleted.contains(&r.edge));
-    }
-    let actual = prepare_command(p, &Command::Batch(edits.commands.clone()))
-        .map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
-        .project;
-    exact_project(&expected, &actual)?;
-    let retained_roles = scope
-        .leaves
-        .values()
-        .any(|l| !l.role_assignments.is_empty());
-    let label = match destination {
-        Destination::LayoutOnly => "Arrange only".into(),
-        Destination::Performer(id) if same_performer => format!("Arrange within {}", p.named(id)),
-        Destination::Performer(id) => format!(
-            "Assign {} leaf {} to {}{}",
-            scope.leaves.len(),
-            match (scope.diagram.layer, scope.leaves.len()) {
-                (Layer::Oa, 1) => "activity",
-                (Layer::Oa, _) => "activities",
-                (Layer::Sa, 1) => "function",
-                (Layer::Sa, _) => "functions",
-            },
-            p.named(id),
-            if retained_roles {
-                " — explicit assignment; role responsibility retained"
-            } else {
-                ""
-            }
-        ),
-        Destination::OutsidePerformers if edits.commands.is_empty() => {
-            "Arrange unassigned work — decomposition retained".into()
-        }
-        Destination::OutsidePerformers => "Remove assignment — decomposition retained".into(),
-    };
-    let warnings = validation::validate(&actual)
-        .into_iter()
-        .filter(|i| i.severity == Severity::Warning)
-        .collect();
-    let index = ViewIndex::new(&actual);
-    Ok(SemanticPlan {
-        scope: scope.clone(),
-        destination,
-        label,
-        warnings,
-        accepted: p.clone(),
-        candidate: actual,
-        index,
-        commands: edits.commands,
-        before_visible,
-        before_expanded,
-    })
-}
-
-#[derive(Default)]
-struct IntendedEdits {
-    commands: Vec<Command>,
-    deleted: BTreeSet<Id>,
-    changed: BTreeSet<Id>,
-}
-
-/// Read each root's accepted responsibility while accumulating one intended
-/// Project, reserving relation identities and aliases across every root.
-fn append_semantic_edits(
-    p: &Project,
-    scope: &Scope,
-    destination: Destination,
-    allocation_ids: &BTreeMap<Id, Id>,
-    expected: &mut Project,
-    edits: &mut IntendedEdits,
-) -> Result<(), Refusal> {
-    let same_performer =
-        matches!(destination, Destination::Performer(id) if scope.uniform == Uniform::Assigned(id));
-    let commands = &mut edits.commands;
-    let deleted = &mut edits.deleted;
-    let changed = &mut edits.changed;
-    if destination != Destination::LayoutOnly && !same_performer {
-        for (work, leaf) in &scope.leaves {
-            match destination {
-                Destination::Performer(performer) => {
-                    if let Some(existing) = &leaf.direct {
-                        if existing.source() != performer {
-                            let mut edited = existing.clone();
-                            edited.body = RelationBody::Allocation {
-                                source: performer,
-                                target: *work,
-                            };
-                            expected.relations.insert(edited.id, edited.clone());
-                            changed.insert(*work);
-                            commands.push(Command::EditRelation(edited.id, edited));
-                        }
-                    } else {
-                        let id = *allocation_ids
-                            .get(work)
-                            .ok_or(Refusal::MissingAllocationId(*work))?;
-                        if id.is_nil() || expected.contains(id) {
-                            return Err(Refusal::InvalidCandidate(
-                                "The gesture's allocation identity is already in use.".into(),
-                            ));
-                        }
-                        let name = format!("{} performs {}", p.named(performer), p.named(*work));
-                        let relation = Relation {
-                            id,
-                            alias: expected.fresh_alias(&name, "allocation", id),
-                            name,
-                            description: String::new(),
-                            body: RelationBody::Allocation {
-                                source: performer,
-                                target: *work,
-                            },
-                        };
-                        expected.relations.insert(id, relation.clone());
-                        changed.insert(*work);
-                        commands.push(Command::CreateRelation(relation));
-                    }
-                }
-                Destination::OutsidePerformers => {
-                    if !leaf.role_assignments.is_empty() {
-                        let roles: Vec<_> = leaf
-                            .role_assignments
-                            .iter()
-                            .map(Relation::source)
-                            .collect::<BTreeSet<_>>()
-                            .into_iter()
-                            .collect();
-                        let performers: Vec<_> = leaf
-                            .role_realizations
-                            .iter()
-                            .map(Relation::source)
-                            .collect::<BTreeSet<_>>()
-                            .into_iter()
-                            .collect();
-                        let message = if leaf.direct.is_some() && performers.len() == 1 {
-                            format!(
-                                "Removing direct assignment would place {} in {} through its role.",
-                                p.named(*work),
-                                p.named(performers[0])
-                            )
-                        } else {
-                            format!(
-                                "{} retains role responsibility through {}{}; edit that responsibility before moving outside performers.",
-                                p.named(*work),
-                                roles
-                                    .iter()
-                                    .map(|id| p.named(*id))
-                                    .collect::<Vec<_>>()
-                                    .join(", "),
-                                if performers.is_empty() {
-                                    String::new()
-                                } else {
-                                    format!(
-                                        " ({})",
-                                        performers
-                                            .iter()
-                                            .map(|id| p.named(*id))
-                                            .collect::<Vec<_>>()
-                                            .join(", ")
-                                    )
-                                }
-                            )
-                        };
-                        return Err(Refusal::RoleExitRequired {
-                            work: *work,
-                            roles,
-                            performers,
-                            message,
-                        });
-                    }
-                    if let Some(existing) = &leaf.direct {
-                        expected.relations.remove(&existing.id);
-                        deleted.insert(existing.id);
-                        changed.insert(*work);
-                        commands.push(Command::Delete(existing.id));
-                    }
-                }
-                Destination::LayoutOnly => unreachable!(),
-            }
-        }
-    }
-    Ok(())
-}
-
-/// World-space rectangle in the gesture's frozen transform. The UI resolver
-/// owns half-open pointer hits, semantic target precedence and occlusion.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Rect {
-    pub position: Position,
-    pub size: Size,
-}
-
-impl Rect {
-    fn valid(self) -> bool {
-        [
-            self.position.x,
-            self.position.y,
-            self.size.width,
-            self.size.height,
-        ]
-        .iter()
-        .all(|n| n.is_finite() && n.abs() <= MAX_COORDINATE)
-            && self.size.width > 0.
-            && self.size.height > 0.
-    }
-    fn contains(self, other: Self) -> bool {
-        other.position.x >= self.position.x
-            && other.position.y >= self.position.y
-            && other.position.x + other.size.width <= self.position.x + self.size.width
-            && other.position.y + other.size.height <= self.position.y + self.size.height
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct TargetPresentation {
-    pub placement: Id,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct PresentationContext {
-    /// Visible world rectangle derived from the actual captured pan/zoom/bounds.
-    pub viewport: Rect,
-    pub zoom: f32,
-    pub target: Option<TargetPresentation>,
-}
-
-#[derive(Debug)]
-pub struct PlacementPlan {
-    pub diagram: Diagram,
-    pub view: ProjectedView,
-    pub delta: Position,
-    pub unfolded: Option<Id>,
-    requested: Position,
-    presentation: PresentationContext,
-    commands: Vec<Command>,
-}
-
-/// `requested` is the original selected placement position plus pointer motion
-/// in the frozen transform (therefore preserving the press offset). Snap only
-/// this root; apply the resulting identical delta to captured Q and its routes.
-/// No whole Project clone, validator or semantic ViewIndex rebuild occurs here.
-pub fn place(
-    plan: &SemanticPlan,
-    requested: Position,
-    presentation: PresentationContext,
-) -> Result<PlacementPlan, Refusal> {
-    if !requested.x.is_finite()
-        || !requested.y.is_finite()
-        || !presentation.viewport.valid()
-        || !presentation.zoom.is_finite()
-        || presentation.zoom <= 0.
-    {
-        return Err(Refusal::LayoutRequired(
-            "Make room or adjust the view, then drag again.".into(),
-        ));
-    }
-    let geometry::Translation {
-        mut diagram,
-        mut commands,
-        delta,
-    } = geometry::translate(
-        &plan.accepted,
-        &plan.scope.diagram,
-        &plan.candidate.diagrams[&plan.scope.diagram.id],
-        &plan.scope.placements,
-        plan.scope.placement,
-        requested,
-    )?;
-    let mut unfolded = None;
-    if let Destination::Performer(performer) = plan.destination {
-        let target = presentation.target.ok_or_else(|| {
-            Refusal::LayoutRequired("A visible accepted performer target is required.".into())
-        })?;
-        let node = diagram
-            .nodes
-            .get_mut(&target.placement)
-            .ok_or(Refusal::StaleScope)?;
-        let visible_target = plan
-            .before_visible
-            .nodes
-            .iter()
-            .any(|n| n.id == target.placement && n.element == performer);
-        if node.element != performer || !visible_target {
-            return Err(Refusal::LayoutRequired(
-                "Make room or adjust the view, then drag again.".into(),
-            ));
-        }
-        if node.collapsed && !plan.commands.is_empty() {
-            node.collapsed = false;
-            unfolded = Some(node.id);
-            commands.push(Command::EditNode {
-                diagram: diagram.id,
-                original: node.id,
-                node: node.clone(),
-            });
-        }
-    } else if presentation.target.is_some() {
-        return Err(Refusal::Ineligible(
-            "This layout/outside destination has no performer target.".into(),
-        ));
-    }
-    let view = projection::project_diagram_with_index(&plan.candidate, &diagram, &plan.index);
-    let expanded = expanded_view(&plan.candidate, &diagram, &plan.scope, &plan.index);
-    check_geometry(plan, &view, &expanded, delta)?;
-    let selected = view
-        .nodes
-        .iter()
-        .find(|n| n.id == plan.scope.placement)
-        .ok_or_else(|| {
-            Refusal::LayoutRequired("The selected work header would be hidden.".into())
-        })?;
-    let header = Rect {
-        position: selected.position,
-        size: Size {
-            width: selected.size.width,
-            height: selected.size.height.min(62.),
-        },
-    };
-    if !presentation.viewport.contains(header) {
-        return Err(Refusal::LayoutRequired(
-            "Make room or adjust the view, then drag again.".into(),
-        ));
-    }
-    // Destination identity lives in a fixed toolbar slot. Frozen hit geometry
-    // and its outline never introduce an opaque label over this work header.
-    Ok(PlacementPlan {
-        diagram,
-        view,
-        delta,
-        unfolded,
-        requested,
-        presentation,
-        commands,
-    })
-}
-
-/// Final semantic/presentation equality gate, after the App has checked its
-/// current token, owner, revision, clean drafts, frozen target and transform.
-/// Recompute geometry to avoid accepting a modified/stale placement result.
-/// None means a snapped no-op: the caller must not execute or add history.
-pub fn finish(
-    plan: &SemanticPlan,
-    live: &Project,
-    placement: &PlacementPlan,
-) -> Result<Option<Command>, Refusal> {
-    if live != &plan.accepted {
-        return Err(Refusal::StaleScope);
-    }
-    let checked = place(plan, placement.requested, placement.presentation)?;
-    if checked.diagram != placement.diagram
-        || checked.view != placement.view
-        || checked.delta != placement.delta
-        || checked.unfolded != placement.unfolded
-        || checked.commands != placement.commands
-    {
-        return Err(Refusal::StaleScope);
-    }
-    let mut expected = plan.candidate.clone();
-    expected
-        .diagrams
-        .insert(checked.diagram.id, checked.diagram);
-    let mut commands = plan.commands.clone();
-    commands.extend(checked.commands);
-    let command = Command::Batch(commands);
-    let actual = prepare_command(live, &command)
-        .map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
-        .project;
-    exact_project(&expected, &actual)?;
-    Ok((actual != *live).then_some(command))
-}
-
-fn expanded_view(
-    p: &Project,
-    diagram: &Diagram,
-    scope: &Scope,
-    index: &ViewIndex,
-) -> ProjectedView {
-    let mut expanded = diagram.clone();
-    for id in scope.placements.keys() {
-        if let Some(node) = expanded.nodes.get_mut(id) {
-            node.collapsed = false;
-        }
-    }
-    projection::project_diagram_with_index(p, &expanded, index)
-}
-
-fn ancestors(view: &ProjectedView) -> BTreeMap<Id, BTreeSet<Id>> {
-    let parents: BTreeMap<_, _> = view.nodes.iter().map(|n| (n.id, n.visual_parent)).collect();
-    parents
-        .keys()
-        .map(|node| {
-            let mut current = parents[node];
-            let mut seen = BTreeSet::new();
-            while let Some(id) = current {
-                if !seen.insert(id) {
-                    break;
-                }
-                current = parents.get(&id).copied().flatten();
-            }
-            (*node, seen)
-        })
-        .collect()
-}
-
-fn coherent(scope: &Scope, view: &ProjectedView) -> bool {
-    let ancestors = ancestors(view);
-    scope.placements.keys().all(|id| {
-        ancestors
-            .get(id)
-            .is_some_and(|parents| *id == scope.placement || parents.contains(&scope.placement))
-    })
-}
-
-fn overlap(a: &ProjectedNode, b: &ProjectedNode) -> f32 {
-    let width = (a.position.x + a.size.width).min(b.position.x + b.size.width)
-        - a.position.x.max(b.position.x);
-    let height = (a.position.y + a.size.height).min(b.position.y + b.size.height)
-        - a.position.y.max(b.position.y);
-    width.max(0.) * height.max(0.)
-}
-
-fn overlaps(before: &ProjectedView, after: &ProjectedView) -> bool {
-    // Build geometry ancestry once, avoiding a repeated descendant walk for
-    // every pair during pointer motion. Pairwise collision checking is bounded
-    // to these two projected scenes and does not traverse/clone model semantics.
-    let before_ancestors = ancestors(before);
-    let after_ancestors = ancestors(after);
-    let prior_nodes: BTreeMap<_, _> = before.nodes.iter().map(|n| (n.id, n)).collect();
-    for (i, a) in after.nodes.iter().enumerate() {
-        for b in &after.nodes[i + 1..] {
-            if after_ancestors[&a.id].contains(&b.id) || after_ancestors[&b.id].contains(&a.id) {
-                continue;
-            }
-            let prior = match (prior_nodes.get(&a.id), prior_nodes.get(&b.id)) {
-                (Some(x), Some(y))
-                    if !before_ancestors[&x.id].contains(&y.id)
-                        && !before_ancestors[&y.id].contains(&x.id) =>
-                {
-                    overlap(x, y)
-                }
-                _ => 0.,
-            };
-            if overlap(a, b) > prior + 0.01 {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-fn check_geometry(
-    plan: &SemanticPlan,
-    visible: &ProjectedView,
-    expanded: &ProjectedView,
-    delta: Position,
-) -> Result<(), Refusal> {
-    if visible.nodes.iter().chain(&expanded.nodes).any(|n| {
-        !(Rect {
-            position: n.position,
-            size: n.size,
-        })
-        .valid()
-    }) {
-        return Err(Refusal::InvalidCandidate(
-            "The projected enclosure exceeds the model bounds.".into(),
-        ));
-    }
-    if plan.scope.work_records.len() > 1 {
-        if !coherent(&plan.scope, expanded) {
-            return Err(Refusal::MixedLayoutRequired);
-        }
-        for id in plan.scope.placements.keys() {
-            let old = plan
-                .before_expanded
-                .nodes
-                .iter()
-                .find(|n| n.id == *id)
-                .ok_or(Refusal::MixedLayoutRequired)?;
-            let new = expanded
-                .nodes
-                .iter()
-                .find(|n| n.id == *id)
-                .ok_or(Refusal::MixedLayoutRequired)?;
-            if (new.position.x - old.position.x - delta.x).abs() > 0.01
-                || (new.position.y - old.position.y - delta.y).abs() > 0.01
-                || (new.size.width - old.size.width).abs() > 0.01
-                || (new.size.height - old.size.height).abs() > 0.01
-            {
-                return Err(Refusal::LayoutRequired("This work subtree requires an explicit layout; its footprint cannot be translated unchanged.".into()));
-            }
-        }
-    }
-    if overlaps(&plan.before_visible, visible) || overlaps(&plan.before_expanded, expanded) {
-        return Err(Refusal::LayoutRequired("Make room before moving work: the candidate would introduce or enlarge overlapping cards.".into()));
-    }
-    Ok(())
-}
-
-/// Compare complete records, not just removed IDs. Deleting an Allocation can
-/// rewrite a surviving Constraint, remove artifacts/traces or prune view options.
-fn exact_project(expected: &Project, actual: &Project) -> Result<(), Refusal> {
-    if expected == actual {
-        return Ok(());
-    }
-    let mut records = Vec::new();
-    fn changes<T: PartialEq>(
-        expected: &BTreeMap<Id, T>,
-        actual: &BTreeMap<Id, T>,
-        category: &'static str,
-        project: &Project,
-        other: &Project,
-        records: &mut Vec<ChangedRecord>,
-    ) {
-        let ids: BTreeSet<_> = expected.keys().chain(actual.keys()).copied().collect();
-        for id in ids {
-            if expected.get(&id) != actual.get(&id) {
-                records.push(ChangedRecord {
-                    id,
-                    name: if project.contains(id) {
-                        project.named(id)
-                    } else {
-                        other.named(id)
-                    }
-                    .into(),
-                    category,
-                });
-            }
-        }
-    }
-    changes(
-        &expected.elements,
-        &actual.elements,
-        "element",
-        expected,
-        actual,
-        &mut records,
-    );
-    changes(
-        &expected.relations,
-        &actual.relations,
-        "relation",
-        expected,
-        actual,
-        &mut records,
-    );
-    changes(
-        &expected.diagrams,
-        &actual.diagrams,
-        "diagram",
-        expected,
-        actual,
-        &mut records,
-    );
-    changes(
-        &expected.artifact_links,
-        &actual.artifact_links,
-        "artifact",
-        expected,
-        actual,
-        &mut records,
-    );
-    changes(
-        &expected.traces,
-        &actual.traces,
-        "trace",
-        expected,
-        actual,
-        &mut records,
-    );
-    if expected.schema_version != actual.schema_version
-        || expected.id != actual.id
-        || expected.alias != actual.alias
-        || expected.name != actual.name
-        || expected.description != actual.description
-    {
-        records.push(ChangedRecord {
-            id: expected.id,
-            name: expected.name.clone(),
-            category: "project",
-        });
-    }
-    Err(Refusal::CollateralChangeRequired(records))
-}
-
-#[cfg(test)]
-#[path = "allocation_drag/tests.rs"]
-mod tests;

crates/oa-desktop/src/allocation_drag/arrange.rs

@@ -1,232 +0,0 @@
-//! Explicit, semantics-preserving arrangement of one or more Allocation cards.
-//!
-//! The App must admit the entire original typed selection before converting it
-//! to placement/element identities. These values do not grant input authority.
-use super::*;
-
-#[derive(Debug)]
-pub struct Plan {
-    accepted: Project,
-    diagram: Id,
-    selected: BTreeMap<Id, Id>,
-    anchor: Id,
-    placements: BTreeMap<Id, NodePlacement>,
-    expanded_ids: BTreeSet<Id>,
-    index: ViewIndex,
-    before_visible: ProjectedView,
-    before_expanded: ProjectedView,
-}
-
-impl Plan {
-    pub fn project(&self) -> &Project {
-        &self.accepted
-    }
-
-    pub fn index(&self) -> &ViewIndex {
-        &self.index
-    }
-
-    pub fn affected(&self) -> &BTreeMap<Id, NodePlacement> {
-        &self.placements
-    }
-
-    pub fn selected(&self) -> &BTreeMap<Id, Id> {
-        &self.selected
-    }
-
-    pub fn anchor(&self) -> Id {
-        self.anchor
-    }
-
-    pub fn diagram(&self) -> &Diagram {
-        &self.accepted.diagrams[&self.diagram]
-    }
-}
-
-/// Capture every original placement identity before normalizing semantic roots.
-/// Document/revision/selection-generation and clean-owner guards belong to App.
-pub fn capture(
-    p: &Project,
-    diagram: Id,
-    selected: &BTreeMap<Id, Id>,
-    anchor: Id,
-) -> Result<Plan, Refusal> {
-    validate_candidate(p).map_err(|e| Refusal::InvalidCandidate(e.to_string()))?;
-    let d = p.diagrams.get(&diagram).ok_or(Refusal::StaleScope)?;
-    if d.projection != ProjectionKind::Allocation
-        || selected.is_empty()
-        || !selected.contains_key(&anchor)
-    {
-        return Err(Refusal::Ineligible(
-            "Arrange requires selected placements and a selected anchor in an Allocation view."
-                .into(),
-        ));
-    }
-    let index = ViewIndex::new(p);
-    let before_visible = projection::project_diagram_with_index(p, d, &index);
-    let visible: BTreeMap<_, _> = before_visible
-        .nodes
-        .iter()
-        .map(|n| (n.id, n.element))
-        .collect();
-    let mut work = BTreeMap::new();
-    let mut performers = Vec::new();
-    for (placement, element) in selected {
-        let node = d.nodes.get(placement).ok_or(Refusal::StaleScope)?;
-        let record = p.elements.get(element).ok_or(Refusal::StaleScope)?;
-        if node.element != *element || visible.get(placement) != Some(element) {
-            return Err(Refusal::StaleScope);
-        }
-        if record.layer() != d.layer || !(record.kind().is_work() || record.kind().is_performer()) {
-            return Err(Refusal::Ineligible(
-                "Arrange requires only activities, functions or performers in this layer.".into(),
-            ));
-        }
-        if record.kind().is_work() {
-            work.insert(*element, *placement);
-        } else {
-            performers.push(*placement);
-        }
-    }
-
-    let mut placements = BTreeMap::new();
-    for (element, placement) in &work {
-        let root = &p.elements[element];
-        let mut ancestor = root.parent;
-        let mut covered = false;
-        let mut seen = BTreeSet::new();
-        while let Some(id) = ancestor {
-            if !seen.insert(id) {
-                return Err(Refusal::StaleScope);
-            }
-            let parent = p.elements.get(&id).ok_or(Refusal::StaleScope)?;
-            if parent.kind() != root.kind() {
-                break;
-            }
-            if work.contains_key(&id) {
-                covered = true;
-                break;
-            }
-            ancestor = parent.parent;
-        }
-        if !covered {
-            placements.extend(capture_validated(p, diagram, *element, *placement)?.placements);
-        }
-    }
-    for performer in performers {
-        for id in
-            std::iter::once(performer).chain(projection::descendant_nodes(p, diagram, performer))
-        {
-            placements.insert(id, d.nodes.get(&id).ok_or(Refusal::StaleScope)?.clone());
-        }
-    }
-
-    // Arrange preserves ancestry, so accepted diagnostic identities also apply
-    // to every translated candidate.
-    let expanded_ids = geometry::expansion_ids(p, d, &index, &placements)?;
-    let before_expanded = geometry::expanded_view(p, d, &index, &expanded_ids);
-    Ok(Plan {
-        accepted: p.clone(),
-        diagram,
-        selected: selected.clone(),
-        anchor,
-        placements,
-        expanded_ids,
-        index,
-        before_visible,
-        before_expanded,
-    })
-}
-
-/// Snap the captured anchor once; preview the complete union without cloning or
-/// validating a Project, rebuilding its semantic index, or expanding scope.
-pub fn place(
-    plan: &Plan,
-    requested: Position,
-    presentation: PresentationContext,
-) -> Result<PlacementPlan, Refusal> {
-    if presentation.target.is_some() {
-        return Err(Refusal::Ineligible(
-            "Arrange only has no performer destination.".into(),
-        ));
-    }
-    if !requested.x.is_finite()
-        || !requested.y.is_finite()
-        || !presentation.viewport.valid()
-        || !presentation.zoom.is_finite()
-        || presentation.zoom <= 0.
-    {
-        return Err(Refusal::LayoutRequired(
-            "Make room or adjust the view, then drag again.".into(),
-        ));
-    }
-    let geometry::Translation {
-        diagram,
-        commands,
-        delta,
-    } = geometry::translate(
-        &plan.accepted,
-        plan.diagram(),
-        plan.diagram(),
-        &plan.placements,
-        plan.anchor,
-        requested,
-    )?;
-    let view = projection::project_diagram_with_index(&plan.accepted, &diagram, &plan.index);
-    let expanded =
-        geometry::expanded_view(&plan.accepted, &diagram, &plan.index, &plan.expanded_ids);
-    // Preserve Arrange's refusal precedence: projected bounds, then rigidity,
-    // then overlap growth. The shared scene check combines bounds and overlaps.
-    let scenes = match geometry::check_scenes(
-        &plan.before_visible,
-        &plan.before_expanded,
-        &view,
-        &expanded,
-    ) {
-        Err(error @ Refusal::InvalidCandidate(_)) => return Err(error),
-        result => result,
-    };
-    geometry::check_rigid(&plan.before_expanded, &expanded, &plan.placements, delta)?;
-    scenes?;
-    geometry::check_headers(&view, &plan.selected, presentation.viewport)?;
-    Ok(PlacementPlan {
-        diagram,
-        view,
-        delta,
-        unfolded: None,
-        requested,
-        presentation,
-        commands,
-    })
-}
-
-/// Recompute the candidate and compare the complete expected Project before the
-/// caller performs one source-admitted transaction. None means no history entry.
-pub fn finish(
-    plan: &Plan,
-    live: &Project,
-    placement: &PlacementPlan,
-) -> Result<Option<Command>, Refusal> {
-    if live != &plan.accepted {
-        return Err(Refusal::StaleScope);
-    }
-    let checked = place(plan, placement.requested, placement.presentation)?;
-    if checked.diagram != placement.diagram
-        || checked.view != placement.view
-        || checked.delta != placement.delta
-        || checked.unfolded != placement.unfolded
-        || checked.commands != placement.commands
-    {
-        return Err(Refusal::StaleScope);
-    }
-    let mut expected = plan.accepted.clone();
-    expected
-        .diagrams
-        .insert(checked.diagram.id, checked.diagram);
-    let command = Command::Batch(checked.commands);
-    let actual = prepare_command(live, &command)
-        .map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
-        .project;
-    exact_project(&expected, &actual)?;
-    Ok((actual != *live).then_some(command))
-}

crates/oa-desktop/src/allocation_drag/arrange_tests.rs

@@ -1,443 +0,0 @@
-use super::*;
-
-struct Distributed {
-    f: Fixture,
-    a: Id,
-    b: Id,
-    x: Id,
-    y: Id,
-    internal: Id,
-}
-
-fn distributed(layer: Layer, folded: bool) -> Distributed {
-    let mut f = fixture(layer);
-    let kind = f.p.elements[&f.w].kind();
-    let x = f.p.add_element(kind, layer, "X", Some(f.w)).unwrap();
-    let y = f.p.add_element(kind, layer, "Y", Some(f.w)).unwrap();
-    let outside = f.p.add_element(kind, layer, "Outside", None).unwrap();
-    let xn = f.p.place(f.d, x, xy(140., 200.));
-    let yn = f.p.place(f.d, y, xy(940., 200.));
-    f.p.place(f.d, outside, xy(1800., 800.));
-    f.p.relate(RelationKind::Allocation, "A owns X", f.a, x);
-    f.p.relate(RelationKind::Allocation, "B owns Y", f.b, y);
-    let exchange = match layer {
-        Layer::Oa => RelationKind::Interaction,
-        Layer::Sa => RelationKind::FunctionalExchange,
-    };
-    let internal = f.p.relate(exchange, "X to Y", x, y);
-    let external = f.p.relate(exchange, "Y to Outside", y, outside);
-    let d = f.p.diagrams.get_mut(&f.d).unwrap();
-    let a = d.nodes.values().find(|n| n.element == f.a).unwrap().id;
-    let b = d.nodes.values().find(|n| n.element == f.b).unwrap().id;
-    d.nodes.get_mut(&a).unwrap().collapsed = folded;
-    d.nodes.get_mut(&f.n).unwrap().position = xy(100., 800.);
-    d.routes = vec![route(internal), route(external)];
-    validate_candidate(&f.p).unwrap();
-    Distributed {
-        f,
-        a,
-        b,
-        x: xn,
-        y: yn,
-        internal,
-    }
-}
-
-fn identities(m: &Distributed, ids: &[Id]) -> BTreeMap<Id, Id> {
-    ids.iter()
-        .map(|id| (*id, m.f.p.diagrams[&m.f.d].nodes[id].element))
-        .collect()
-}
-
-fn expected(m: &Distributed, include_a: bool) -> Project {
-    let mut p = m.f.p.clone();
-    let d = p.diagrams.get_mut(&m.f.d).unwrap();
-    for (id, position) in [
-        (m.f.n, xy(500., 800.)),
-        (m.x, xy(540., 200.)),
-        (m.y, xy(1340., 200.)),
-    ] {
-        d.nodes.get_mut(&id).unwrap().position = position;
-    }
-    if include_a {
-        d.nodes.get_mut(&m.a).unwrap().position = xy(500., 100.);
-    }
-    d.routes
-        .iter_mut()
-        .find(|r| r.edge == m.internal)
-        .unwrap()
-        .waypoints = vec![xy(820., 400.), xy(820., 550.)];
-    p
-}
-
-#[test]
-fn explicit_arrange_distributed_oa_sa_exact_scope_routes_source_history_and_anchor() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for folded in [false, true] {
-            for include_a in [false, true] {
-                let m = distributed(layer, folded);
-                let members = if include_a {
-                    vec![m.f.n, m.a]
-                } else {
-                    vec![m.f.n]
-                };
-                let selected = identities(&m, &members);
-                for anchor in selected.keys().copied() {
-                    let plan = arrange::capture(&m.f.p, m.f.d, &selected, anchor).unwrap();
-                    assert_eq!(plan.selected(), &selected);
-                    let mut affected = BTreeSet::from([m.f.n, m.x, m.y]);
-                    if include_a {
-                        affected.insert(m.a);
-                    }
-                    assert_eq!(
-                        plan.affected().keys().copied().collect::<BTreeSet<_>>(),
-                        affected
-                    );
-                    let requested = if anchor == m.a {
-                        xy(503., 102.)
-                    } else {
-                        xy(503., 802.)
-                    };
-                    let placed =
-                        arrange::place(&plan, requested, presentation(&m.f.p, m.f.d, None))
-                            .unwrap();
-                    assert_eq!(placed.delta, xy(400., 0.));
-                    assert_eq!(placed.unfolded, None);
-                    let command = arrange::finish(&plan, &m.f.p, &placed).unwrap().unwrap();
-                    assert_eq!(roundtrip(&m.f.p, command), expected(&m, include_a));
-                    // Explicit Arrange does not widen ordinary distributed assignment.
-                    assert!(matches!(
-                        plan_semantics(
-                            &m.f.p,
-                            &scope(&m.f),
-                            Destination::Performer(m.f.a),
-                            &BTreeMap::new()
-                        ),
-                        Err(Refusal::MixedLayoutRequired)
-                    ));
-                }
-            }
-        }
-    }
-}
-
-#[test]
-fn explicit_arrange_performer_closure_does_not_acquire_incidental_semantic_root() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let m = distributed(layer, true);
-        let selected = identities(&m, &[m.a]);
-        let plan = arrange::capture(&m.f.p, m.f.d, &selected, m.a).unwrap();
-        assert_eq!(
-            plan.affected().keys().copied().collect::<BTreeSet<_>>(),
-            BTreeSet::from([m.a, m.x])
-        );
-        let placed =
-            arrange::place(&plan, xy(500., 100.), presentation(&m.f.p, m.f.d, None)).unwrap();
-        let mut expected = m.f.p.clone();
-        let d = expected.diagrams.get_mut(&m.f.d).unwrap();
-        d.nodes.get_mut(&m.a).unwrap().position = xy(500., 100.);
-        d.nodes.get_mut(&m.x).unwrap().position = xy(540., 200.);
-        // X-to-Y is now one-ended; all saved pins remain byte-for-byte unchanged.
-        assert_eq!(
-            roundtrip(
-                &m.f.p,
-                arrange::finish(&plan, &m.f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}
-
-#[test]
-fn explicit_arrange_validates_all_original_members_before_normalizing() {
-    let mut m = distributed(Layer::Oa, false);
-    let selected = identities(&m, &[m.f.n, m.x]);
-    let plan = arrange::capture(&m.f.p, m.f.d, &selected, m.x).unwrap();
-    assert_eq!(plan.selected(), &selected);
-    assert_eq!(plan.affected().len(), 3);
-    let placed = arrange::place(&plan, xy(540., 200.), presentation(&m.f.p, m.f.d, None)).unwrap();
-    assert_eq!(
-        roundtrip(
-            &m.f.p,
-            arrange::finish(&plan, &m.f.p, &placed).unwrap().unwrap()
-        ),
-        expected(&m, false)
-    );
-    let mut stale = selected.clone();
-    stale.insert(m.x, m.f.w);
-    assert!(arrange::capture(&m.f.p, m.f.d, &stale, m.f.n).is_err());
-    m.f.p
-        .diagrams
-        .get_mut(&m.f.d)
-        .unwrap()
-        .nodes
-        .get_mut(&m.a)
-        .unwrap()
-        .collapsed = true;
-    assert!(
-        arrange::capture(&m.f.p, m.f.d, &selected, m.f.n).is_err(),
-        "covered selected X is hidden and cannot disappear in normalization"
-    );
-    assert!(arrange::capture(&m.f.p, m.f.d, &BTreeMap::new(), m.f.n).is_err());
-    assert!(arrange::capture(&m.f.p, m.f.d, &identities(&m, &[m.f.n]), m.a).is_err());
-    assert!(arrange::capture(&m.f.p, m.f.second, &identities(&m, &[m.f.n]), m.f.n).is_err());
-    let foreign = Id::new_v4();
-    assert!(
-        arrange::capture(
-            &m.f.p,
-            m.f.d,
-            &BTreeMap::from([(m.f.n, m.f.w), (foreign, m.f.w)]),
-            m.f.n
-        )
-        .is_err()
-    );
-    m.f.p.diagrams.get_mut(&m.f.d).unwrap().projection = ProjectionKind::Overview;
-    assert!(arrange::capture(&m.f.p, m.f.d, &identities(&m, &[m.f.n]), m.f.n).is_err());
-}
-
-#[test]
-fn explicit_arrange_simultaneous_roots_may_enter_each_others_vacated_bounds() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut f = fixture(layer);
-        let kind = f.p.elements[&f.w].kind();
-        let y = f.p.add_element(kind, layer, "Second root", None).unwrap();
-        let yn = f.p.place(f.d, y, xy(400., 500.));
-        let relation = f.p.relate(
-            if layer == Layer::Oa {
-                RelationKind::Interaction
-            } else {
-                RelationKind::FunctionalExchange
-            },
-            "Between roots",
-            f.w,
-            y,
-        );
-        f.p.diagrams.get_mut(&f.d).unwrap().routes = vec![route(relation)];
-        let context = presentation(&f.p, f.d, None);
-        let single = arrange::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-        assert!(
-            arrange::place(&single, xy(400., 500.), context).is_err(),
-            "singleton would collide with stationary Y"
-        );
-        let plan =
-            arrange::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w), (yn, y)]), f.n).unwrap();
-        let placed = arrange::place(&plan, xy(400., 500.), context).unwrap();
-        let mut expected = f.p.clone();
-        let d = expected.diagrams.get_mut(&f.d).unwrap();
-        d.nodes.get_mut(&f.n).unwrap().position = xy(400., 500.);
-        d.nodes.get_mut(&yn).unwrap().position = xy(700., 500.);
-        d.routes[0].waypoints = vec![xy(720., 400.), xy(720., 550.)];
-        assert_eq!(
-            roundtrip(
-                &f.p,
-                arrange::finish(&plan, &f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}
-
-#[test]
-fn explicit_arrange_preserves_roles_and_does_not_invent_unplaced_descendants() {
-    let mut f = fixture(Layer::Oa);
-    let a = f.a;
-    role(&mut f, Some(a));
-    f.p.diagrams
-        .get_mut(&f.d)
-        .unwrap()
-        .nodes
-        .get_mut(&f.n)
-        .unwrap()
-        .position = xy(150., 200.);
-    let plan = arrange::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-    let placed = arrange::place(&plan, xy(160., 210.), presentation(&f.p, f.d, None)).unwrap();
-    let mut role_expected = f.p.clone();
-    role_expected
-        .diagrams
-        .get_mut(&f.d)
-        .unwrap()
-        .nodes
-        .get_mut(&f.n)
-        .unwrap()
-        .position = xy(160., 210.);
-    assert_eq!(
-        roundtrip(
-            &f.p,
-            arrange::finish(&plan, &f.p, &placed).unwrap().unwrap()
-        ),
-        role_expected
-    );
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut m = distributed(layer, true);
-        let kind = m.f.p.elements[&m.f.w].kind();
-        m.f.p
-            .add_element(kind, layer, "Unplaced leaf", Some(m.f.w))
-            .unwrap();
-        let plan = arrange::capture(&m.f.p, m.f.d, &identities(&m, &[m.f.n]), m.f.n).unwrap();
-        assert_eq!(plan.affected().len(), 3);
-        let placed =
-            arrange::place(&plan, xy(500., 800.), presentation(&m.f.p, m.f.d, None)).unwrap();
-        assert_eq!(
-            roundtrip(
-                &m.f.p,
-                arrange::finish(&plan, &m.f.p, &placed).unwrap().unwrap()
-            ),
-            expected(&m, false)
-        );
-    }
-}
-
-#[test]
-fn explicit_arrange_detects_hidden_moved_child_and_stationary_enclosure_growth() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for hidden in [false, true] {
-            let mut m = distributed(layer, hidden);
-            let kind = m.f.p.elements[&m.f.w].kind();
-            let z = m.f.p.add_element(kind, layer, "Obstacle", None).unwrap();
-            let zn = m.f.p.place(
-                m.f.d,
-                z,
-                if hidden {
-                    xy(550., 230.)
-                } else {
-                    xy(1200., 100.)
-                },
-            );
-            // The independent candidate differs only by literal admitted edits.
-            // Establish which geometric case the real planner must reject.
-            let candidate = expected(&m, true);
-            let before = projection::project_view(&m.f.p, m.f.d);
-            let after = projection::project_view(&candidate, m.f.d);
-            let find =
-                |view: &ProjectedView, id| view.nodes.iter().find(|n| n.id == id).unwrap().clone();
-            if hidden {
-                assert!(!overlaps(&before, &after));
-                assert!(!after.nodes.iter().any(|n| n.id == m.x));
-                let mut diagnostic = candidate.diagrams[&m.f.d].clone();
-                diagnostic.nodes.get_mut(&m.a).unwrap().collapsed = false;
-                let expanded = projection::project_diagram(&candidate, &diagnostic);
-                assert_eq!(
-                    overlap(&find(&expanded, m.x), &find(&expanded, zn)),
-                    if layer == Layer::Oa { 13696. } else { 20116. }
-                );
-            } else {
-                assert_eq!(overlap(&find(&before, m.b), &find(&before, zn)), 0.);
-                assert_eq!(overlap(&find(&after, m.b), &find(&after, zn)), 21056.);
-                for id in [m.a, m.f.n, m.x, m.y] {
-                    assert_eq!(overlap(&find(&after, id), &find(&after, zn)), 0.);
-                }
-                assert_eq!(
-                    candidate.diagrams[&m.f.d].nodes[&m.b],
-                    m.f.p.diagrams[&m.f.d].nodes[&m.b]
-                );
-            }
-            let plan =
-                arrange::capture(&m.f.p, m.f.d, &identities(&m, &[m.a, m.f.n]), m.f.n).unwrap();
-            assert!(matches!(
-                arrange::place(&plan, xy(500., 800.), presentation(&m.f.p, m.f.d, None)),
-                Err(Refusal::LayoutRequired(_))
-            ));
-        }
-    }
-}
-
-#[test]
-fn explicit_arrange_preserves_existing_overlap_but_refuses_its_growth() {
-    let mut f = fixture(Layer::Oa);
-    let y =
-        f.p.add_element(Kind::Activity, Layer::Oa, "Existing overlap", None)
-            .unwrap();
-    let yn = f.p.place(f.d, y, xy(250., 500.));
-    let context = presentation(&f.p, f.d, None);
-    let single = arrange::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-    assert!(arrange::place(&single, xy(110., 500.), context).is_err());
-    let plan = arrange::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w), (yn, y)]), f.n).unwrap();
-    let placed = arrange::place(&plan, xy(400., 500.), context).unwrap();
-    let mut expected = f.p.clone();
-    let d = expected.diagrams.get_mut(&f.d).unwrap();
-    d.nodes.get_mut(&f.n).unwrap().position = xy(400., 500.);
-    d.nodes.get_mut(&yn).unwrap().position = xy(550., 500.);
-    assert_eq!(
-        roundtrip(
-            &f.p,
-            arrange::finish(&plan, &f.p, &placed).unwrap().unwrap()
-        ),
-        expected
-    );
-}
-
-#[test]
-fn explicit_arrange_preserves_unrelated_folded_interior_diagnostic_boundary() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut m = distributed(layer, true);
-        let performer = if layer == Layer::Oa {
-            Kind::Actor
-        } else {
-            Kind::SystemActor
-        };
-        let d = m.f.p.add_element(performer, layer, "D", None).unwrap();
-        let z =
-            m.f.p
-                .add_element(m.f.p.elements[&m.f.w].kind(), layer, "Hidden Z", None)
-                .unwrap();
-        m.f.p.relate(RelationKind::Allocation, "D owns Z", d, z);
-        let dn = m.f.p.place(m.f.d, d, xy(2500., 100.));
-        m.f.p.place(m.f.d, z, xy(550., 230.));
-        m.f.p
-            .diagrams
-            .get_mut(&m.f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&dn)
-            .unwrap()
-            .collapsed = true;
-        let plan = arrange::capture(&m.f.p, m.f.d, &identities(&m, &[m.a, m.f.n]), m.f.n).unwrap();
-        let placed =
-            arrange::place(&plan, xy(500., 800.), presentation(&m.f.p, m.f.d, None)).unwrap();
-        assert_eq!(
-            roundtrip(
-                &m.f.p,
-                arrange::finish(&plan, &m.f.p, &placed).unwrap().unwrap()
-            ),
-            expected(&m, true)
-        );
-    }
-}
-
-#[test]
-fn explicit_arrange_noop_stale_tamper_target_and_all_selected_headers() {
-    let m = distributed(Layer::Sa, false);
-    let selected = identities(&m, &[m.a, m.f.n]);
-    let plan = arrange::capture(&m.f.p, m.f.d, &selected, m.f.n).unwrap();
-    let context = presentation(&m.f.p, m.f.d, None);
-    let noop = arrange::place(&plan, xy(103., 802.), context).unwrap();
-    assert!(arrange::finish(&plan, &m.f.p, &noop).unwrap().is_none());
-    let mut placed = arrange::place(&plan, xy(500., 800.), context).unwrap();
-    let mut stale = m.f.p.clone();
-    stale.name.push_str(" changed");
-    assert!(matches!(
-        arrange::finish(&plan, &stale, &placed),
-        Err(Refusal::StaleScope)
-    ));
-    placed.diagram.nodes.get_mut(&m.b).unwrap().position.x += 1.;
-    assert!(matches!(
-        arrange::finish(&plan, &m.f.p, &placed),
-        Err(Refusal::StaleScope)
-    ));
-    assert!(
-        arrange::place(
-            &plan,
-            xy(500., 800.),
-            presentation(&m.f.p, m.f.d, Some(m.f.b))
-        )
-        .is_err()
-    );
-    let mut clipped = context;
-    clipped.viewport.position = xy(400., 700.);
-    assert!(
-        arrange::place(&plan, xy(500., 800.), clipped).is_err(),
-        "anchor C visible, other selected A header clipped"
-    );
-    assert!(arrange::place(&plan, xy(f32::NAN, 800.), context).is_err());
-    assert!(arrange::place(&plan, xy(MAX_COORDINATE, 800.), context).is_err());
-}

crates/oa-desktop/src/allocation_drag/assignment.rs

@@ -1,444 +0,0 @@
-//! Ordinary work-only group assignment, with one combined semantic/geometry plan.
-//! App retains authority over the complete typed selection and gesture lifetime.
-use super::*;
-use std::sync::Arc;
-
-#[derive(Debug)]
-struct Captured {
-    accepted: Project,
-    diagram: Id,
-    selected: BTreeMap<Id, Id>,
-    anchor: Id,
-    roots: Vec<super::Scope>,
-    placements: BTreeMap<Id, NodePlacement>,
-    leaves: BTreeMap<Id, Leaf>,
-    index: ViewIndex,
-    before_visible: ProjectedView,
-    before_expanded: ProjectedView,
-}
-
-/// Destination plans share one immutable accepted capture.
-#[derive(Debug, Clone)]
-pub struct Scope(Arc<Captured>);
-
-impl Scope {
-    pub fn project(&self) -> &Project {
-        &self.0.accepted
-    }
-
-    pub fn index(&self) -> &ViewIndex {
-        &self.0.index
-    }
-
-    pub fn diagram(&self) -> &Diagram {
-        &self.0.accepted.diagrams[&self.0.diagram]
-    }
-
-    pub fn selected(&self) -> &BTreeMap<Id, Id> {
-        &self.0.selected
-    }
-
-    pub fn affected(&self) -> &BTreeMap<Id, NodePlacement> {
-        &self.0.placements
-    }
-
-    pub fn anchor(&self) -> Id {
-        self.0.anchor
-    }
-
-    pub fn leaves(&self) -> &BTreeMap<Id, Leaf> {
-        &self.0.leaves
-    }
-}
-
-/// App must reject non-placement members before constructing this complete map.
-/// Every original identity is checked before redundant work roots are removed.
-pub fn capture(
-    p: &Project,
-    diagram: Id,
-    selected: &BTreeMap<Id, Id>,
-    anchor: Id,
-) -> Result<Scope, Refusal> {
-    validate_candidate(p).map_err(|e| Refusal::InvalidCandidate(e.to_string()))?;
-    let d = p.diagrams.get(&diagram).ok_or(Refusal::StaleScope)?;
-    if d.projection != ProjectionKind::Allocation
-        || selected.is_empty()
-        || !selected.contains_key(&anchor)
-    {
-        return Err(Refusal::Ineligible(
-            "Assignment requires selected work placements and a selected anchor in an Allocation view."
-                .into(),
-        ));
-    }
-    let index = ViewIndex::new(p);
-    let before_visible = projection::project_diagram_with_index(p, d, &index);
-    let visible: BTreeMap<_, _> = before_visible
-        .nodes
-        .iter()
-        .map(|node| (node.id, node.element))
-        .collect();
-    let mut work = BTreeMap::new();
-    for (placement, element) in selected {
-        let node = d.nodes.get(placement).ok_or(Refusal::StaleScope)?;
-        let record = p.elements.get(element).ok_or(Refusal::StaleScope)?;
-        if node.element != *element || visible.get(placement) != Some(element) {
-            return Err(Refusal::StaleScope);
-        }
-        if !record.kind().is_work() || record.layer() != d.layer {
-            return Err(Refusal::Ineligible(
-                "Assignment requires only activities or functions in this layer. Use Arrange only for a supported mixed selection."
-                    .into(),
-            ));
-        }
-        work.insert(*element, *placement);
-    }
-
-    let mut roots = Vec::new();
-    let mut placements = BTreeMap::new();
-    let mut leaves = BTreeMap::new();
-    for (element, placement) in &work {
-        let record = &p.elements[element];
-        let mut ancestor = record.parent;
-        let mut seen = BTreeSet::new();
-        let mut covered = false;
-        while let Some(id) = ancestor {
-            if !seen.insert(id) {
-                return Err(Refusal::StaleScope);
-            }
-            let parent = p.elements.get(&id).ok_or(Refusal::StaleScope)?;
-            if parent.kind() != record.kind() {
-                break;
-            }
-            if work.contains_key(&id) {
-                covered = true;
-                break;
-            }
-            ancestor = parent.parent;
-        }
-        if covered {
-            continue;
-        }
-        let root = capture_validated(p, diagram, *element, *placement)?;
-        if root.work_records.len() > 1 && root.uniform == Uniform::MixedOrUnresolved {
-            return Err(Refusal::MixedLayoutRequired);
-        }
-        for (id, leaf) in &root.leaves {
-            if leaves.insert(*id, leaf.clone()).is_some() {
-                return Err(Refusal::StaleScope);
-            }
-        }
-        placements.extend(root.placements.clone());
-        roots.push(root);
-    }
-    let expansion = geometry::expansion_ids(p, d, &index, &placements)?;
-    let before_expanded = geometry::expanded_view(p, d, &index, &expansion);
-    if roots
-        .iter()
-        .any(|root| root.work_records.len() > 1 && !coherent(root, &before_expanded))
-    {
-        return Err(Refusal::MixedLayoutRequired);
-    }
-    Ok(Scope(Arc::new(Captured {
-        accepted: p.clone(),
-        diagram,
-        selected: selected.clone(),
-        anchor,
-        roots,
-        placements,
-        leaves,
-        index,
-        before_visible,
-        before_expanded,
-    })))
-}
-
-#[derive(Debug)]
-pub struct SemanticPlan {
-    scope: Scope,
-    destination: Destination,
-    candidate: Project,
-    index: ViewIndex,
-    commands: Vec<Command>,
-    changed: BTreeSet<Id>,
-    expanded_ids: BTreeSet<Id>,
-    label: String,
-    warnings: Vec<Issue>,
-}
-
-impl SemanticPlan {
-    pub fn scope(&self) -> &Scope {
-        &self.scope
-    }
-
-    pub fn project(&self) -> &Project {
-        &self.candidate
-    }
-
-    pub fn index(&self) -> &ViewIndex {
-        &self.index
-    }
-
-    pub fn destination(&self) -> Destination {
-        self.destination
-    }
-
-    pub fn label(&self) -> &str {
-        &self.label
-    }
-
-    pub fn warnings(&self) -> &[Issue] {
-        &self.warnings
-    }
-
-    pub fn changed_count(&self) -> usize {
-        self.changed.len()
-    }
-
-    /// Already effective at the performer, or already unassigned for Outside.
-    pub fn already_correct_count(&self) -> usize {
-        self.scope.leaves().len() - self.changed.len()
-    }
-}
-
-/// Build one destination candidate. Per-root decisions read accepted facts;
-/// aliases and new identities are reserved in the combined expected Project.
-pub fn plan_semantics(
-    scope: &Scope,
-    destination: Destination,
-    allocation_ids: &BTreeMap<Id, Id>,
-) -> Result<SemanticPlan, Refusal> {
-    let accepted = scope.project();
-    match destination {
-        Destination::LayoutOnly => {
-            return Err(Refusal::Ineligible(
-                "Use the explicit Arrange only planner for presentation-only movement.".into(),
-            ));
-        }
-        Destination::Performer(id) => {
-            if !accepted.elements.get(&id).is_some_and(|element| {
-                element.kind().is_performer() && element.layer() == scope.diagram().layer
-            }) {
-                return Err(Refusal::Ineligible(
-                    "Choose a performer in this layer.".into(),
-                ));
-            }
-        }
-        Destination::OutsidePerformers => {}
-    }
-    let mut expected = accepted.clone();
-    let mut edits = IntendedEdits::default();
-    for root in &scope.0.roots {
-        append_semantic_edits(
-            accepted,
-            root,
-            destination,
-            allocation_ids,
-            &mut expected,
-            &mut edits,
-        )?;
-    }
-    for diagram in expected.diagrams.values_mut() {
-        diagram
-            .routes
-            .retain(|route| !edits.deleted.contains(&route.edge));
-    }
-    let candidate = prepare_command(accepted, &Command::Batch(edits.commands.clone()))
-        .map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
-        .project;
-    exact_project(&expected, &candidate)?;
-    let warnings = validation::validate(&candidate)
-        .into_iter()
-        .filter(|issue| issue.severity == Severity::Warning)
-        .collect();
-    let index = ViewIndex::new(&candidate);
-    // Assignment may change visual ancestry: never reuse accepted expansion IDs.
-    let expanded_ids = geometry::expansion_ids(
-        &candidate,
-        &candidate.diagrams[&scope.0.diagram],
-        &index,
-        scope.affected(),
-    )?;
-    let total = scope.leaves().len();
-    let changed = edits.changed.len();
-    let already_correct = total - changed;
-    let noun = match (scope.diagram().layer, total) {
-        (Layer::Oa, 1) => "activity",
-        (Layer::Oa, _) => "activities",
-        (Layer::Sa, 1) => "function",
-        (Layer::Sa, _) => "functions",
-    };
-    let retained_roles = scope
-        .leaves()
-        .values()
-        .any(|leaf| !leaf.role_assignments.is_empty());
-    let label = match destination {
-        Destination::Performer(id) if changed == 0 => {
-            format!(
-                "Arrange within {} — all {total} leaf {noun} already assigned",
-                accepted.named(id)
-            )
-        }
-        Destination::Performer(id) => format!(
-            "Assign {changed} of {total} leaf {noun} to {}{}{}",
-            accepted.named(id),
-            if already_correct > 0 {
-                format!(" · {already_correct} already assigned")
-            } else {
-                String::new()
-            },
-            if retained_roles {
-                " — role responsibility retained"
-            } else {
-                ""
-            },
-        ),
-        Destination::OutsidePerformers if changed == 0 => {
-            "Arrange unassigned work — decomposition retained".into()
-        }
-        Destination::OutsidePerformers => format!(
-            "Remove assignments from {changed} of {total} leaf {noun} — decomposition retained"
-        ),
-        Destination::LayoutOnly => unreachable!(),
-    };
-    Ok(SemanticPlan {
-        scope: scope.clone(),
-        destination,
-        candidate,
-        index,
-        commands: edits.commands,
-        changed: edits.changed,
-        expanded_ids,
-        label,
-        warnings,
-    })
-}
-
-/// Translate the entire captured Q once, then evaluate the combined candidate.
-/// This path does not clone/validate a Project or rebuild semantic indexes.
-pub fn place(
-    plan: &SemanticPlan,
-    requested: Position,
-    presentation: PresentationContext,
-) -> Result<PlacementPlan, Refusal> {
-    if !requested.x.is_finite()
-        || !requested.y.is_finite()
-        || !presentation.viewport.valid()
-        || !presentation.zoom.is_finite()
-        || presentation.zoom <= 0.
-    {
-        return Err(Refusal::LayoutRequired(
-            "Make room or adjust the view, then drag again.".into(),
-        ));
-    }
-    let scope = &plan.scope;
-    let geometry::Translation {
-        mut diagram,
-        mut commands,
-        delta,
-    } = geometry::translate(
-        scope.project(),
-        scope.diagram(),
-        &plan.candidate.diagrams[&scope.0.diagram],
-        scope.affected(),
-        scope.anchor(),
-        requested,
-    )?;
-    let mut unfolded = None;
-    if let Destination::Performer(performer) = plan.destination {
-        let target = presentation.target.ok_or_else(|| {
-            Refusal::LayoutRequired("A visible accepted performer target is required.".into())
-        })?;
-        if !scope
-            .0
-            .before_visible
-            .nodes
-            .iter()
-            .any(|node| node.id == target.placement && node.element == performer)
-        {
-            return Err(Refusal::LayoutRequired(
-                "Make room or adjust the view, then drag again.".into(),
-            ));
-        }
-        let target_node = diagram
-            .nodes
-            .get_mut(&target.placement)
-            .ok_or(Refusal::StaleScope)?;
-        if target_node.element != performer {
-            return Err(Refusal::StaleScope);
-        }
-        if !plan.changed.is_empty() && target_node.collapsed {
-            target_node.collapsed = false;
-            unfolded = Some(target_node.id);
-            commands.push(Command::EditNode {
-                diagram: diagram.id,
-                original: target_node.id,
-                node: target_node.clone(),
-            });
-        }
-    } else if presentation.target.is_some() {
-        return Err(Refusal::Ineligible(
-            "An outside destination has no performer target.".into(),
-        ));
-    }
-    let view = projection::project_diagram_with_index(&plan.candidate, &diagram, &plan.index);
-    let expanded =
-        geometry::expanded_view(&plan.candidate, &diagram, &plan.index, &plan.expanded_ids);
-    if scope
-        .0
-        .roots
-        .iter()
-        .any(|root| root.work_records.len() > 1 && !coherent(root, &expanded))
-    {
-        return Err(Refusal::MixedLayoutRequired);
-    }
-    geometry::check_scenes(
-        &scope.0.before_visible,
-        &scope.0.before_expanded,
-        &view,
-        &expanded,
-    )?;
-    geometry::check_rigid(&scope.0.before_expanded, &expanded, scope.affected(), delta)?;
-    geometry::check_headers(&view, scope.selected(), presentation.viewport)?;
-    Ok(PlacementPlan {
-        diagram,
-        view,
-        delta,
-        unfolded,
-        requested,
-        presentation,
-        commands,
-    })
-}
-
-/// Recheck immutable facts and recompute geometry before one final source batch.
-/// Zero delta remains a transaction when assignment semantics changed.
-pub fn finish(
-    plan: &SemanticPlan,
-    live: &Project,
-    placement: &PlacementPlan,
-) -> Result<Option<Command>, Refusal> {
-    if live != plan.scope.project() {
-        return Err(Refusal::StaleScope);
-    }
-    let checked = place(plan, placement.requested, placement.presentation)?;
-    if checked.diagram != placement.diagram
-        || checked.view != placement.view
-        || checked.delta != placement.delta
-        || checked.unfolded != placement.unfolded
-        || checked.commands != placement.commands
-    {
-        return Err(Refusal::StaleScope);
-    }
-    let mut expected = plan.candidate.clone();
-    expected
-        .diagrams
-        .insert(checked.diagram.id, checked.diagram);
-    let mut commands = plan.commands.clone();
-    commands.extend(checked.commands);
-    let command = Command::Batch(commands);
-    let actual = prepare_command(live, &command)
-        .map_err(|e| Refusal::InvalidCandidate(e.to_string()))?
-        .project;
-    exact_project(&expected, &actual)?;
-    Ok((actual != *live).then_some(command))
-}

crates/oa-desktop/src/allocation_drag/assignment_boundary_tests.rs

@@ -1,497 +0,0 @@
-use super::*;
-
-struct Composite {
-    f: Fixture,
-    child: Id,
-    child_node: Id,
-    unplaced: Id,
-}
-
-fn composite(layer: Layer) -> Composite {
-    let mut f = fixture(layer);
-    let kind = f.p.elements[&f.w].kind();
-    let child =
-        f.p.add_element(kind, layer, "Placed child", Some(f.w))
-            .unwrap();
-    let unplaced =
-        f.p.add_element(kind, layer, "Unplaced leaf", Some(f.w))
-            .unwrap();
-    let child_node = f.p.place(f.d, child, xy(140., 600.));
-    validate_candidate(&f.p).unwrap();
-    Composite {
-        f,
-        child,
-        child_node,
-        unplaced,
-    }
-}
-
-fn expected_allocation(id: Id, alias: &str, name: &str, performer: Id, work: Id) -> Relation {
-    Relation {
-        id,
-        alias: alias.into(),
-        name: name.into(),
-        description: String::new(),
-        body: RelationBody::Allocation {
-            source: performer,
-            target: work,
-        },
-    }
-}
-
-#[test]
-fn group_assignment_checks_original_identity_and_visibility_before_normalization() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let c = composite(layer);
-        let valid = BTreeMap::from([(c.f.n, c.f.w), (c.child_node, c.child)]);
-        let admitted = assignment::capture(&c.f.p, c.f.d, &valid, c.f.n).unwrap();
-        assert_eq!(admitted.selected(), &valid);
-        let foreign = c.f.p.diagrams[&c.f.second]
-            .nodes
-            .values()
-            .find(|node| node.element == c.f.w)
-            .unwrap()
-            .id;
-        // Each extra member is semantically covered by the valid selected parent.
-        // Normalizing first would incorrectly hide its invalid original identity.
-        for invalid in [
-            BTreeMap::from([(c.f.n, c.f.w), (c.child_node, c.unplaced)]),
-            BTreeMap::from([(c.f.n, c.f.w), (Id::new_v4(), c.child)]),
-            BTreeMap::from([(c.f.n, c.f.w), (foreign, c.f.w)]),
-        ] {
-            assert!(matches!(
-                assignment::capture(&c.f.p, c.f.d, &invalid, c.f.n),
-                Err(Refusal::StaleScope)
-            ));
-        }
-        let mut folded = c.f.p.clone();
-        folded
-            .diagrams
-            .get_mut(&c.f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&c.f.n)
-            .unwrap()
-            .collapsed = true;
-        validate_candidate(&folded).unwrap();
-        assert!(
-            !projection::project_view(&folded, c.f.d)
-                .nodes
-                .iter()
-                .any(|node| node.id == c.child_node)
-        );
-        // Hidden descendants remain in Q when only the visible parent is selected.
-        let parent_only =
-            assignment::capture(&folded, c.f.d, &BTreeMap::from([(c.f.n, c.f.w)]), c.f.n).unwrap();
-        assert!(parent_only.affected().contains_key(&c.child_node));
-        assert!(matches!(
-            assignment::capture(&folded, c.f.d, &valid, c.f.n),
-            Err(Refusal::StaleScope)
-        ));
-    }
-}
-
-#[test]
-fn group_assignment_normalizes_parent_child_and_assigns_unplaced_leaf_once() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let c = composite(layer);
-        let selected = BTreeMap::from([(c.f.n, c.f.w), (c.child_node, c.child)]);
-        let scope = assignment::capture(&c.f.p, c.f.d, &selected, c.f.n).unwrap();
-        assert_eq!(scope.selected(), &selected);
-        assert_eq!(
-            scope.affected().keys().copied().collect::<BTreeSet<_>>(),
-            BTreeSet::from([c.f.n, c.child_node])
-        );
-        assert_eq!(
-            scope.leaves().keys().copied().collect::<BTreeSet<_>>(),
-            BTreeSet::from([c.child, c.unplaced])
-        );
-        let child_allocation = Id::new_v4();
-        let unplaced_allocation = Id::new_v4();
-        let ids = BTreeMap::from([
-            (c.child, child_allocation),
-            (c.unplaced, unplaced_allocation),
-        ]);
-        let plan = assignment::plan_semantics(&scope, Destination::Performer(c.f.a), &ids).unwrap();
-        assert_eq!(plan.changed_count(), 2);
-        let mut expected = c.f.p.clone();
-        expected.relations.insert(
-            child_allocation,
-            expected_allocation(
-                child_allocation,
-                "a_performs_placed_child",
-                "A performs Placed child",
-                c.f.a,
-                c.child,
-            ),
-        );
-        expected.relations.insert(
-            unplaced_allocation,
-            expected_allocation(
-                unplaced_allocation,
-                "a_performs_unplaced_leaf",
-                "A performs Unplaced leaf",
-                c.f.a,
-                c.unplaced,
-            ),
-        );
-        assert_eq!(plan.project(), &expected);
-        let placed = assignment::place(
-            &plan,
-            xy(140., 200.),
-            presentation(&c.f.p, c.f.d, Some(c.f.a)),
-        )
-        .unwrap();
-        let mut clipped = presentation(&c.f.p, c.f.d, Some(c.f.a));
-        clipped.viewport.size.height = 450.; // bottom350: parent header fits; selected child ends362.
-        for (id, should_fit) in [(c.f.n, true), (c.child_node, false)] {
-            let node = placed.view.nodes.iter().find(|node| node.id == id).unwrap();
-            let header = Rect {
-                position: node.position,
-                size: Size {
-                    width: node.size.width,
-                    height: 62.,
-                },
-            };
-            assert_eq!(clipped.viewport.contains(header), should_fit);
-        }
-        assert!(
-            matches!(
-                assignment::place(&plan, xy(140., 200.), clipped),
-                Err(Refusal::LayoutRequired(_))
-            ),
-            "normalized-away selected child still requires its header"
-        );
-        let d = expected.diagrams.get_mut(&c.f.d).unwrap();
-        d.nodes.get_mut(&c.f.n).unwrap().position = xy(140., 200.);
-        d.nodes.get_mut(&c.child_node).unwrap().position = xy(180., 300.);
-        assert_eq!(placed.delta, xy(40., -300.));
-        assert_eq!(
-            roundtrip(
-                &c.f.p,
-                assignment::finish(&plan, &c.f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-        assert_eq!(
-            expected.diagrams[&c.f.d].nodes.len(),
-            c.f.p.diagrams[&c.f.d].nodes.len()
-        );
-        assert!(
-            !expected.diagrams[&c.f.d]
-                .nodes
-                .values()
-                .any(|node| node.element == c.unplaced)
-        );
-        assert!(
-            !expected
-                .relations
-                .values()
-                .any(|relation| relation.kind() == RelationKind::Allocation
-                    && relation.target() == c.f.w)
-        );
-    }
-}
-
-#[test]
-fn group_assignment_distributed_parent_refuses_but_its_independent_leaves_can_reassign() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut c = composite(layer);
-        let second_node = c.f.p.place(c.f.d, c.unplaced, xy(940., 200.));
-        let performer =
-            c.f.p
-                .add_element(
-                    if layer == Layer::Oa {
-                        Kind::Actor
-                    } else {
-                        Kind::SystemActor
-                    },
-                    layer,
-                    "C",
-                    None,
-                )
-                .unwrap();
-        c.f.p.place(c.f.d, performer, xy(1700., 100.));
-        let d = c.f.p.diagrams.get_mut(&c.f.d).unwrap();
-        d.nodes.get_mut(&c.f.n).unwrap().position = xy(1700., 800.);
-        d.nodes.get_mut(&c.child_node).unwrap().position = xy(140., 200.);
-        let ax =
-            c.f.p
-                .relate(RelationKind::Allocation, "A child", c.f.a, c.child);
-        let by =
-            c.f.p
-                .relate(RelationKind::Allocation, "B child", c.f.b, c.unplaced);
-        validate_candidate(&c.f.p).unwrap();
-        let visible = projection::project_view(&c.f.p, c.f.d);
-        for id in [c.f.n, c.child_node, second_node] {
-            assert!(visible.nodes.iter().any(|node| node.id == id));
-        }
-        assert_eq!(scope(&c.f).uniform, Uniform::MixedOrUnresolved);
-        assert!(matches!(
-            assignment::capture(&c.f.p, c.f.d, &BTreeMap::from([(c.f.n, c.f.w)]), c.f.n,),
-            Err(Refusal::MixedLayoutRequired)
-        ));
-        let selected = BTreeMap::from([(c.child_node, c.child), (second_node, c.unplaced)]);
-        let captured = assignment::capture(&c.f.p, c.f.d, &selected, c.child_node).unwrap();
-        let plan = assignment::plan_semantics(
-            &captured,
-            Destination::Performer(performer),
-            &BTreeMap::new(),
-        )
-        .unwrap();
-        let mut expected = c.f.p.clone();
-        expected.relations.get_mut(&ax).unwrap().body = RelationBody::Allocation {
-            source: performer,
-            target: c.child,
-        };
-        expected.relations.get_mut(&by).unwrap().body = RelationBody::Allocation {
-            source: performer,
-            target: c.unplaced,
-        };
-        assert_eq!(plan.project(), &expected);
-        // One delta moves both leaves. The unselected semantic parent remains
-        // authored at (1700,800), while its derived enclosure may change.
-        let placed = assignment::place(
-            &plan,
-            xy(1740., 120.),
-            presentation(&c.f.p, c.f.d, Some(performer)),
-        )
-        .unwrap();
-        let d = expected.diagrams.get_mut(&c.f.d).unwrap();
-        d.nodes.get_mut(&c.child_node).unwrap().position = xy(1740., 120.);
-        d.nodes.get_mut(&second_node).unwrap().position = xy(2540., 120.);
-        assert_eq!(
-            roundtrip(
-                &c.f.p,
-                assignment::finish(&plan, &c.f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}
-
-fn separate_unassigned(layer: Layer) -> (Fixture, Id, Id) {
-    let mut f = fixture(layer);
-    let companion =
-        f.p.add_element(f.p.elements[&f.w].kind(), layer, "Companion", None)
-            .unwrap();
-    let companion_node = f.p.place(f.d, companion, xy(100., 1000.));
-    validate_candidate(&f.p).unwrap();
-    (f, companion, companion_node)
-}
-
-#[test]
-fn group_assignment_finish_rejects_stale_project_and_each_tampered_result() {
-    let (f, companion, companion_node) = separate_unassigned(Layer::Oa);
-    let selected = BTreeMap::from([(f.n, f.w), (companion_node, companion)]);
-    let captured = assignment::capture(&f.p, f.d, &selected, f.n).unwrap();
-    let plan =
-        assignment::plan_semantics(&captured, Destination::OutsidePerformers, &BTreeMap::new())
-            .unwrap();
-    let context = presentation(&f.p, f.d, None);
-    let valid = assignment::place(&plan, xy(500., 500.), context).unwrap();
-    let mut expected = f.p.clone();
-    expected
-        .diagrams
-        .get_mut(&f.d)
-        .unwrap()
-        .nodes
-        .get_mut(&f.n)
-        .unwrap()
-        .position = xy(500., 500.);
-    expected
-        .diagrams
-        .get_mut(&f.d)
-        .unwrap()
-        .nodes
-        .get_mut(&companion_node)
-        .unwrap()
-        .position = xy(500., 1000.);
-    assert_eq!(
-        roundtrip(
-            &f.p,
-            assignment::finish(&plan, &f.p, &valid).unwrap().unwrap()
-        ),
-        expected
-    );
-    let mut stale = f.p.clone();
-    stale.elements.get_mut(&f.b).unwrap().description = "Changed unrelated accepted record".into();
-    validate_candidate(&stale).unwrap();
-    assert!(matches!(
-        assignment::finish(&plan, &stale, &valid),
-        Err(Refusal::StaleScope)
-    ));
-    for field in 0..6 {
-        let mut altered = assignment::place(&plan, xy(500., 500.), context).unwrap();
-        match field {
-            0 => altered.diagram.nodes.get_mut(&f.n).unwrap().position.x += 20.,
-            1 => {
-                altered
-                    .view
-                    .nodes
-                    .iter_mut()
-                    .find(|node| node.id == f.n)
-                    .unwrap()
-                    .position
-                    .x += 20.
-            }
-            2 => altered.delta.x += 20.,
-            3 => altered.unfolded = Some(f.n),
-            4 => altered.commands.clear(),
-            5 => altered.requested.x += 10.,
-            _ => unreachable!(),
-        }
-        assert!(
-            matches!(
-                assignment::finish(&plan, &f.p, &altered),
-                Err(Refusal::StaleScope)
-            ),
-            "tampered result field {field}"
-        );
-    }
-}
-
-#[test]
-fn group_assignment_requires_non_anchor_selected_header_inside_viewport() {
-    let (f, companion, companion_node) = separate_unassigned(Layer::Oa);
-    let captured = assignment::capture(
-        &f.p,
-        f.d,
-        &BTreeMap::from([(f.n, f.w), (companion_node, companion)]),
-        f.n,
-    )
-    .unwrap();
-    let plan =
-        assignment::plan_semantics(&captured, Destination::OutsidePerformers, &BTreeMap::new())
-            .unwrap();
-    let wide = presentation(&f.p, f.d, None);
-    let placed = assignment::place(&plan, xy(500., 500.), wide).unwrap();
-    let mut narrow = wide;
-    narrow.viewport.size.height = 800.; // world bottom700: anchor header fits, companion does not.
-    let header = |id| {
-        let node = placed.view.nodes.iter().find(|node| node.id == id).unwrap();
-        Rect {
-            position: node.position,
-            size: Size {
-                width: node.size.width,
-                height: 62.,
-            },
-        }
-    };
-    assert!(narrow.viewport.contains(header(f.n)));
-    assert!(!narrow.viewport.contains(header(companion_node)));
-    // Only the viewport differs from the already admitted identical geometry.
-    assert!(matches!(
-        assignment::place(&plan, xy(500., 500.), narrow),
-        Err(Refusal::LayoutRequired(_))
-    ));
-}
-
-#[test]
-fn group_assignment_unresolved_oa_role_leaf_accepts_explicit_target_but_not_outside() {
-    for ambiguous in [false, true] {
-        let (mut f, companion, companion_node) = separate_unassigned(Layer::Oa);
-        let (role_id, role_assignment) = role(&mut f, None);
-        if ambiguous {
-            f.p.relate(
-                RelationKind::RoleRealization,
-                "A realizes responsibility",
-                f.a,
-                role_id,
-            );
-            f.p.relate(
-                RelationKind::RoleRealization,
-                "B realizes responsibility",
-                f.b,
-                role_id,
-            );
-        }
-        validate_candidate(&f.p).unwrap();
-        assert_eq!(validation::effective_performer(&f.p, f.w), None);
-        let captured = assignment::capture(
-            &f.p,
-            f.d,
-            &BTreeMap::from([(f.n, f.w), (companion_node, companion)]),
-            f.n,
-        )
-        .unwrap();
-        let Refusal::RoleExitRequired {
-            work,
-            roles,
-            performers,
-            ..
-        } = assignment::plan_semantics(&captured, Destination::OutsidePerformers, &BTreeMap::new())
-            .unwrap_err()
-        else {
-            panic!("unresolved role must produce its specific outward refusal");
-        };
-        assert_eq!(work, f.w);
-        assert_eq!(roles, vec![role_id]);
-        assert_eq!(
-            performers.into_iter().collect::<BTreeSet<_>>(),
-            if ambiguous {
-                BTreeSet::from([f.a, f.b])
-            } else {
-                BTreeSet::new()
-            }
-        );
-        let work_allocation = Id::new_v4();
-        let companion_allocation = Id::new_v4();
-        let ids = BTreeMap::from([(f.w, work_allocation), (companion, companion_allocation)]);
-        let plan =
-            assignment::plan_semantics(&captured, Destination::Performer(f.b), &ids).unwrap();
-        assert_eq!(plan.changed_count(), 2);
-        assert!(plan.label().contains("role responsibility retained"));
-        let mut expected = f.p.clone();
-        expected.relations.insert(
-            work_allocation,
-            expected_allocation(
-                work_allocation,
-                "b_performs_work",
-                "B performs Work",
-                f.b,
-                f.w,
-            ),
-        );
-        expected.relations.insert(
-            companion_allocation,
-            expected_allocation(
-                companion_allocation,
-                "b_performs_companion",
-                "B performs Companion",
-                f.b,
-                companion,
-            ),
-        );
-        assert_eq!(plan.project(), &expected);
-        assert_eq!(
-            plan.project().relations[&role_assignment],
-            f.p.relations[&role_assignment]
-        );
-        let placed =
-            assignment::place(&plan, xy(940., 200.), presentation(&f.p, f.d, Some(f.b))).unwrap();
-        expected
-            .diagrams
-            .get_mut(&f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&f.n)
-            .unwrap()
-            .position = xy(940., 200.);
-        expected
-            .diagrams
-            .get_mut(&f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&companion_node)
-            .unwrap()
-            .position = xy(940., 700.);
-        assert_eq!(
-            roundtrip(
-                &f.p,
-                assignment::finish(&plan, &f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}

crates/oa-desktop/src/allocation_drag/assignment_tests.rs

@@ -1,606 +0,0 @@
-use super::*;
-
-struct Roots {
-    f: Fixture,
-    c: Id,
-    cn: Id,
-    y: Id,
-    yn: Id,
-    z: Id,
-    zn: Id,
-    ax: Id,
-    by: Id,
-}
-
-fn roots(layer: Layer) -> Roots {
-    let mut f = fixture(layer);
-    let kind = f.p.elements[&f.w].kind();
-    let c =
-        f.p.add_element(
-            if layer == Layer::Oa {
-                Kind::Actor
-            } else {
-                Kind::SystemActor
-            },
-            layer,
-            "C",
-            None,
-        )
-        .unwrap();
-    let y = f.p.add_element(kind, layer, "Y", None).unwrap();
-    let z = f.p.add_element(kind, layer, "Z", None).unwrap();
-    let cn = f.p.place(f.d, c, xy(1500., 100.));
-    let yn = f.p.place(f.d, y, xy(140., 800.));
-    let zn = f.p.place(f.d, z, xy(1540., 1400.));
-    let d = f.p.diagrams.get_mut(&f.d).unwrap();
-    d.nodes.get_mut(&f.n).unwrap().position = xy(140., 200.);
-    d.nodes
-        .values_mut()
-        .find(|n| n.element == f.b)
-        .unwrap()
-        .position = xy(100., 700.);
-    let ax = f.p.relate(
-        RelationKind::Allocation,
-        "Original X responsibility",
-        f.a,
-        f.w,
-    );
-    let by = f.p.relate(
-        RelationKind::Allocation,
-        "Original Y responsibility",
-        f.b,
-        y,
-    );
-    f.p.relations.get_mut(&ax).unwrap().description = "Reviewed X identity must survive".into();
-    f.p.relations.get_mut(&by).unwrap().description = "Reviewed Y identity must survive".into();
-    if layer == Layer::Oa {
-        let r =
-            f.p.add_element(Kind::Role, layer, "Responsibility", None)
-                .unwrap();
-        f.p.relate(RelationKind::RoleAssignment, "Z role", r, z);
-        f.p.relate(RelationKind::RoleRealization, "C role", c, r);
-    } else {
-        f.p.relate(RelationKind::Allocation, "Z already assigned", c, z);
-    }
-    validate_candidate(&f.p).unwrap();
-    Roots {
-        f,
-        c,
-        cn,
-        y,
-        yn,
-        z,
-        zn,
-        ax,
-        by,
-    }
-}
-
-fn wide(p: &Project, d: Id, target: Option<Id>) -> PresentationContext {
-    let mut context = presentation(p, d, target);
-    context.viewport.size = Size {
-        width: 5000.,
-        height: 3000.,
-    };
-    context
-}
-
-fn selected(r: &Roots, with_z: bool) -> BTreeMap<Id, Id> {
-    let mut ids = BTreeMap::from([(r.f.n, r.f.w), (r.yn, r.y)]);
-    if with_z {
-        ids.insert(r.zn, r.z);
-    }
-    ids
-}
-
-fn retarget(p: &mut Project, relation: Id, target: Id) {
-    let r = p.relations.get_mut(&relation).unwrap();
-    r.body = RelationBody::Allocation {
-        source: target,
-        target: r.target(),
-    };
-}
-
-#[test]
-fn group_assignment_independent_performers_preserves_already_correct_provenance() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let r = roots(layer);
-        let selected = selected(&r, true);
-        let scope = assignment::capture(&r.f.p, r.f.d, &selected, r.f.n).unwrap();
-        let plan =
-            assignment::plan_semantics(&scope, Destination::Performer(r.c), &BTreeMap::new())
-                .unwrap();
-        assert_eq!(plan.changed_count(), 2);
-        assert_eq!(plan.already_correct_count(), 1);
-        let placed =
-            assignment::place(&plan, xy(1540., 200.), wide(&r.f.p, r.f.d, Some(r.c))).unwrap();
-        let mut expected = r.f.p.clone();
-        retarget(&mut expected, r.ax, r.c);
-        retarget(&mut expected, r.by, r.c);
-        let d = expected.diagrams.get_mut(&r.f.d).unwrap();
-        d.nodes.get_mut(&r.f.n).unwrap().position = xy(1540., 200.);
-        d.nodes.get_mut(&r.yn).unwrap().position = xy(1540., 800.);
-        d.nodes.get_mut(&r.zn).unwrap().position = xy(2940., 1400.);
-        assert_eq!(
-            roundtrip(
-                &r.f.p,
-                assignment::finish(&plan, &r.f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-        if layer == Layer::Oa {
-            assert!(
-                !plan
-                    .project()
-                    .relations
-                    .values()
-                    .any(|relation| relation.kind() == RelationKind::Allocation
-                        && relation.target() == r.z)
-            );
-            assert!(matches!(
-                assignment::plan_semantics(
-                    &scope,
-                    Destination::OutsidePerformers,
-                    &BTreeMap::new()
-                ),
-                Err(Refusal::RoleExitRequired { .. })
-            ));
-        }
-        assert!(
-            assignment::plan_semantics(&scope, Destination::LayoutOnly, &BTreeMap::new()).is_err()
-        );
-    }
-}
-
-#[test]
-fn group_assignment_zero_delta_changes_semantics_once_and_then_is_noop() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut f = fixture(layer);
-        let d = f.p.diagrams.get_mut(&f.d).unwrap();
-        d.nodes
-            .values_mut()
-            .find(|n| n.element == f.a)
-            .unwrap()
-            .size = Size {
-            width: 600.,
-            height: 400.,
-        };
-        d.nodes.get_mut(&f.n).unwrap().position = xy(140., 200.);
-        let scope = assignment::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-        let id = Id::new_v4();
-        let plan = assignment::plan_semantics(
-            &scope,
-            Destination::Performer(f.a),
-            &BTreeMap::from([(f.w, id)]),
-        )
-        .unwrap();
-        let placed = assignment::place(&plan, xy(140., 200.), wide(&f.p, f.d, Some(f.a))).unwrap();
-        assert_eq!(placed.delta, xy(0., 0.));
-        let mut expected = f.p.clone();
-        expected.relations.insert(
-            id,
-            Relation {
-                id,
-                alias: "a_performs_work".into(),
-                name: "A performs Work".into(),
-                description: String::new(),
-                body: RelationBody::Allocation {
-                    source: f.a,
-                    target: f.w,
-                },
-            },
-        );
-        assert_eq!(
-            roundtrip(
-                &f.p,
-                assignment::finish(&plan, &f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-        let scope =
-            assignment::capture(&expected, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-        let noop =
-            assignment::plan_semantics(&scope, Destination::Performer(f.a), &BTreeMap::new())
-                .unwrap();
-        let placed =
-            assignment::place(&noop, xy(140., 200.), wide(&expected, f.d, Some(f.a))).unwrap();
-        assert!(
-            assignment::finish(&noop, &expected, &placed)
-                .unwrap()
-                .is_none()
-        );
-    }
-}
-
-#[test]
-fn group_assignment_unfolds_only_changed_destination_and_refuses_newly_exposed_overlap() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for obstacle in [false, true] {
-            let mut r = roots(layer);
-            let d = r.f.p.diagrams.get_mut(&r.f.d).unwrap();
-            d.nodes
-                .values_mut()
-                .find(|n| n.element == r.f.b)
-                .unwrap()
-                .position = xy(100., 400.);
-            d.nodes.get_mut(&r.yn).unwrap().position = xy(140., 500.);
-            d.nodes.get_mut(&r.zn).unwrap().position = xy(1540., 800.);
-            d.nodes.get_mut(&r.cn).unwrap().collapsed = true;
-            if obstacle {
-                let k =
-                    r.f.p
-                        .add_element(r.f.p.elements[&r.f.w].kind(), layer, "Hidden overlap", None)
-                        .unwrap();
-                r.f.p
-                    .relate(RelationKind::Allocation, "C also owns K", r.c, k);
-                r.f.p.place(r.f.d, k, xy(1540., 800.));
-            }
-            assert!(
-                !projection::project_view(&r.f.p, r.f.d)
-                    .nodes
-                    .iter()
-                    .any(|n| n.id == r.zn)
-            );
-            assert!(
-                assignment::capture(&r.f.p, r.f.d, &selected(&r, true), r.f.n).is_err(),
-                "hidden selected member is not normalized away"
-            );
-            let scope = assignment::capture(&r.f.p, r.f.d, &selected(&r, false), r.f.n).unwrap();
-            let plan =
-                assignment::plan_semantics(&scope, Destination::Performer(r.c), &BTreeMap::new())
-                    .unwrap();
-            let placed = assignment::place(&plan, xy(1540., 120.), wide(&r.f.p, r.f.d, Some(r.c)));
-            if obstacle {
-                assert!(matches!(placed, Err(Refusal::LayoutRequired(_))));
-                continue;
-            }
-            let placed = placed.unwrap();
-            assert_eq!(placed.unfolded, Some(r.cn));
-            let mut expected = r.f.p.clone();
-            retarget(&mut expected, r.ax, r.c);
-            retarget(&mut expected, r.by, r.c);
-            let d = expected.diagrams.get_mut(&r.f.d).unwrap();
-            d.nodes.get_mut(&r.cn).unwrap().collapsed = false;
-            d.nodes.get_mut(&r.f.n).unwrap().position = xy(1540., 120.);
-            d.nodes.get_mut(&r.yn).unwrap().position = xy(1540., 420.);
-            assert_eq!(
-                roundtrip(
-                    &r.f.p,
-                    assignment::finish(&plan, &r.f.p, &placed).unwrap().unwrap()
-                ),
-                expected
-            );
-        }
-    }
-}
-
-#[test]
-fn group_assignment_accumulates_stable_ids_and_aliases_without_partial_reuse() {
-    let mut f = fixture(Layer::Oa);
-    let y =
-        f.p.add_element(Kind::Activity, Layer::Oa, "Work", None)
-            .unwrap();
-    let yn = f.p.place(f.d, y, xy(400., 500.));
-    let selected = BTreeMap::from([(f.n, f.w), (yn, y)]);
-    let scope = assignment::capture(&f.p, f.d, &selected, f.n).unwrap();
-    let ids = BTreeMap::from([(f.w, Id::new_v4()), (y, Id::new_v4())]);
-    let first = assignment::plan_semantics(&scope, Destination::Performer(f.a), &ids).unwrap();
-    let other = assignment::plan_semantics(&scope, Destination::Performer(f.b), &ids).unwrap();
-    let repeated = assignment::plan_semantics(&scope, Destination::Performer(f.a), &ids).unwrap();
-    assert_eq!(first.project(), repeated.project());
-    assert_eq!(first.changed_count(), 2);
-    let mut expected = f.p.clone();
-    let aliases: BTreeSet<_> = ids
-        .values()
-        .map(|id| first.project().relations[id].alias.clone())
-        .collect();
-    assert_eq!(aliases.len(), 2);
-    assert!(aliases.contains("a_performs_work"));
-    for (ordinal, (work, id)) in ids.iter().enumerate() {
-        let relation = &first.project().relations[id];
-        let expected_relation = Relation {
-            id: *id,
-            alias: if ordinal == 0 {
-                "a_performs_work".into()
-            } else {
-                format!("a_performs_work_{}", &id.simple().to_string()[..8])
-            },
-            name: "A performs Work".into(),
-            description: String::new(),
-            body: RelationBody::Allocation {
-                source: f.a,
-                target: *work,
-            },
-        };
-        assert_eq!(relation, &expected_relation);
-        assert_eq!(
-            other.project().relations[id].body,
-            RelationBody::Allocation {
-                source: f.b,
-                target: *work
-            }
-        );
-        expected.relations.insert(*id, expected_relation);
-    }
-    assert_eq!(first.project(), &expected);
-    let duplicate = Id::new_v4();
-    for bad in [
-        BTreeMap::from([(f.w, duplicate), (y, duplicate)]),
-        BTreeMap::from([(f.w, Id::nil()), (y, ids[&y])]),
-        BTreeMap::from([(f.w, f.a), (y, ids[&y])]),
-    ] {
-        assert!(assignment::plan_semantics(&scope, Destination::Performer(f.a), &bad).is_err());
-    }
-}
-
-#[test]
-fn group_assignment_source_failure_preserves_existing_history_and_retry_ids() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut f = fixture(layer);
-        let y =
-            f.p.add_element(f.p.elements[&f.w].kind(), layer, "Y", None)
-                .unwrap();
-        let yn = f.p.place(f.d, y, xy(400., 800.));
-        let mut bundle = format_bundle(&f.p);
-        bundle
-            .files
-            .get_mut(&bundle.entry.clone())
-            .unwrap()
-            .insert_str(
-                0,
-                "// Keep reviewed source through a refused group assignment.\n",
-            );
-        let mut limits = ProjectLimits::default();
-        limits.model.max_source_bytes = bundle.files.values().map(String::len).sum::<usize>() + 128;
-        let mut document = Document::from_bundle(bundle, limits).unwrap();
-        document
-            .execute(Command::Describe(f.w, "Reviewed".into()))
-            .unwrap();
-        document
-            .execute(Command::Rename(y, "Future Y".into()))
-            .unwrap();
-        let redo_project = document.project().clone();
-        let redo_source = document.bundle().clone();
-        assert!(document.undo());
-        assert!(document.can_undo() && document.can_redo());
-        let accepted = document.project().clone();
-        let source = document.bundle().clone();
-        let revision = document.revision();
-        let ids = BTreeMap::from([(f.w, Id::new_v4()), (y, Id::new_v4())]);
-        let scope =
-            assignment::capture(&accepted, f.d, &BTreeMap::from([(f.n, f.w), (yn, y)]), f.n)
-                .unwrap();
-        let plan = assignment::plan_semantics(&scope, Destination::Performer(f.a), &ids).unwrap();
-        let placed =
-            assignment::place(&plan, xy(150., 200.), wide(&accepted, f.d, Some(f.a))).unwrap();
-        let command = assignment::finish(&plan, &accepted, &placed)
-            .unwrap()
-            .unwrap();
-        assert!(matches!(
-            document.execute(command.clone()),
-            Err(crate::document::DocumentError::Source(_))
-        ));
-        assert_eq!(document.project(), &accepted);
-        assert_eq!(document.bundle(), &source);
-        assert_eq!(document.revision(), revision);
-        assert!(document.can_undo() && document.can_redo());
-        assert!(document.redo());
-        assert_eq!(document.project(), &redo_project);
-        assert_eq!(document.bundle(), &redo_source);
-        assert!(document.undo());
-        assert_eq!(document.project(), &accepted);
-        assert_eq!(document.bundle(), &source);
-        let mut expected = accepted.clone();
-        for (work, name, alias) in [
-            (f.w, "A performs Work", "a_performs_work"),
-            (y, "A performs Y", "a_performs_y"),
-        ] {
-            expected.relations.insert(
-                ids[&work],
-                Relation {
-                    id: ids[&work],
-                    alias: alias.into(),
-                    name: name.into(),
-                    description: String::new(),
-                    body: RelationBody::Allocation {
-                        source: f.a,
-                        target: work,
-                    },
-                },
-            );
-        }
-        let d = expected.diagrams.get_mut(&f.d).unwrap();
-        d.nodes.get_mut(&f.n).unwrap().position = xy(150., 200.);
-        d.nodes.get_mut(&yn).unwrap().position = xy(450., 500.);
-        assert_eq!(roundtrip(&accepted, command), expected);
-    }
-}
-
-#[test]
-fn group_assignment_collateral_surviving_constraint_refuses_whole_semantic_candidate() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut r = roots(layer);
-        let k =
-            r.f.p
-                .add_element(Kind::Constraint, layer, "Keep reviewed assignment", None)
-                .unwrap();
-        *r.f.p.elements.get_mut(&k).unwrap().shared_mut().unwrap() = SharedBody::Constraint {
-            expression: "reviewed assignment".into(),
-            constrained: vec![r.ax, r.f.w],
-        };
-        let core = prepare_command(&r.f.p, &Command::Delete(r.ax))
-            .unwrap()
-            .project;
-        validate_candidate(&core).unwrap();
-        assert!(core.elements.contains_key(&k));
-        assert_ne!(core.elements[&k], r.f.p.elements[&k]);
-        let scope = assignment::capture(&r.f.p, r.f.d, &selected(&r, false), r.f.n).unwrap();
-        let Err(Refusal::CollateralChangeRequired(changed)) =
-            assignment::plan_semantics(&scope, Destination::OutsidePerformers, &BTreeMap::new())
-        else {
-            panic!("surviving constraint edit must refuse the entire plan");
-        };
-        assert!(changed.iter().any(|record| record.id == k));
-    }
-}
-
-#[test]
-fn group_assignment_uses_vacated_space_and_one_complete_route_owner_map() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut f = fixture(layer);
-        let kind = f.p.elements[&f.w].kind();
-        let y = f.p.add_element(kind, layer, "Y", None).unwrap();
-        let outside = f.p.add_element(kind, layer, "Outside", None).unwrap();
-        let yn = f.p.place(f.d, y, xy(400., 500.));
-        f.p.place(f.d, outside, xy(1600., 500.));
-        let d = f.p.diagrams.get_mut(&f.d).unwrap();
-        let a = d.nodes.values_mut().find(|n| n.element == f.a).unwrap();
-        a.position = xy(350., 350.);
-        a.size = Size {
-            width: 1000.,
-            height: 600.,
-        };
-        let edge_kind = if layer == Layer::Oa {
-            RelationKind::Interaction
-        } else {
-            RelationKind::FunctionalExchange
-        };
-        let internal = f.p.relate(edge_kind, "Internal", f.w, y);
-        let external = f.p.relate(edge_kind, "External", y, outside);
-        let mut internal_route = route(internal);
-        internal_route.waypoints = vec![xy(370., 550.), xy(370., 650.)];
-        internal_route.source_attachment = Some(EdgeAttachment {
-            side: PortAnchorSide::Bottom,
-            offset: 0.3,
-        });
-        internal_route.target_attachment = Some(EdgeAttachment {
-            side: PortAnchorSide::Top,
-            offset: 0.7,
-        });
-        let mut external_route = internal_route.clone();
-        external_route.edge = external;
-        external_route.waypoints = vec![xy(1200., 550.), xy(1300., 650.)];
-        for diagram in [f.d, f.second] {
-            f.p.diagrams.get_mut(&diagram).unwrap().routes =
-                vec![internal_route.clone(), external_route.clone()];
-        }
-        if let RelationBody::FunctionalExchange { source_port, .. } = f.p.relations[&internal].body
-        {
-            f.p.diagrams
-                .get_mut(&f.d)
-                .unwrap()
-                .nodes
-                .get_mut(&f.n)
-                .unwrap()
-                .port_anchors
-                .push(PortAnchor {
-                    port: source_port,
-                    side: PortAnchorSide::Bottom,
-                    offset: 0.4,
-                });
-        }
-        validate_candidate(&f.p).unwrap();
-        let ids = BTreeMap::from([(f.w, Id::new_v4()), (y, Id::new_v4())]);
-        // The singleton candidate really occupies stationary Y's card. The
-        // combined candidate must not inherit that sequential-planning veto.
-        let mut singleton = f.p.clone();
-        singleton
-            .diagrams
-            .get_mut(&f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&f.n)
-            .unwrap()
-            .position = xy(400., 500.);
-        let projected = projection::project_view(&singleton, f.d);
-        let x_card = projected.nodes.iter().find(|n| n.id == f.n).unwrap();
-        let y_card = projected.nodes.iter().find(|n| n.id == yn).unwrap();
-        assert_eq!(
-            overlap(x_card, y_card),
-            if layer == Layer::Oa { 21056. } else { 29568. }
-        );
-        let single = assignment::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w)]), f.n).unwrap();
-        let single =
-            assignment::plan_semantics(&single, Destination::Performer(f.a), &ids).unwrap();
-        assert!(matches!(
-            assignment::place(&single, xy(400., 500.), wide(&f.p, f.d, Some(f.a))),
-            Err(Refusal::LayoutRequired(_))
-        ));
-        let scope =
-            assignment::capture(&f.p, f.d, &BTreeMap::from([(f.n, f.w), (yn, y)]), f.n).unwrap();
-        let plan = assignment::plan_semantics(&scope, Destination::Performer(f.a), &ids).unwrap();
-        let placed = assignment::place(&plan, xy(400., 500.), wide(&f.p, f.d, Some(f.a))).unwrap();
-        let mut expected = f.p.clone();
-        for (work, name, alias) in [
-            (f.w, "A performs Work", "a_performs_work"),
-            (y, "A performs Y", "a_performs_y"),
-        ] {
-            expected.relations.insert(
-                ids[&work],
-                Relation {
-                    id: ids[&work],
-                    alias: alias.into(),
-                    name: name.into(),
-                    description: String::new(),
-                    body: RelationBody::Allocation {
-                        source: f.a,
-                        target: work,
-                    },
-                },
-            );
-        }
-        let d = expected.diagrams.get_mut(&f.d).unwrap();
-        d.nodes.get_mut(&f.n).unwrap().position = xy(400., 500.);
-        d.nodes.get_mut(&yn).unwrap().position = xy(700., 500.);
-        d.routes[0].waypoints = vec![xy(670., 550.), xy(670., 650.)];
-        assert_eq!(placed.diagram.routes[1], external_route);
-        assert_eq!(
-            roundtrip(
-                &f.p,
-                assignment::finish(&plan, &f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}
-
-#[test]
-fn group_assignment_deletes_only_own_routes_across_views_and_keeps_internal_flow() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut r = roots(layer);
-        let kind = if layer == Layer::Oa {
-            RelationKind::Interaction
-        } else {
-            RelationKind::FunctionalExchange
-        };
-        let internal = r.f.p.relate(kind, "Keep internal flow", r.f.w, r.y);
-        for diagram in [r.f.d, r.f.second] {
-            r.f.p.diagrams.get_mut(&diagram).unwrap().routes =
-                vec![route(r.ax), route(internal), route(r.by)];
-        }
-        validate_candidate(&r.f.p).unwrap();
-        let scope = assignment::capture(&r.f.p, r.f.d, &selected(&r, false), r.f.n).unwrap();
-        let plan =
-            assignment::plan_semantics(&scope, Destination::OutsidePerformers, &BTreeMap::new())
-                .unwrap();
-        assert_eq!(plan.changed_count(), 2);
-        let placed = assignment::place(&plan, xy(640., 200.), wide(&r.f.p, r.f.d, None)).unwrap();
-        let mut expected = r.f.p.clone();
-        expected.relations.remove(&r.ax);
-        expected.relations.remove(&r.by);
-        for diagram in [r.f.d, r.f.second] {
-            expected.diagrams.get_mut(&diagram).unwrap().routes = vec![route(internal)];
-        }
-        let d = expected.diagrams.get_mut(&r.f.d).unwrap();
-        d.nodes.get_mut(&r.f.n).unwrap().position = xy(640., 200.);
-        d.nodes.get_mut(&r.yn).unwrap().position = xy(640., 800.);
-        d.routes[0].waypoints = vec![xy(920., 400.), xy(920., 550.)];
-        assert_eq!(
-            roundtrip(
-                &r.f.p,
-                assignment::finish(&plan, &r.f.p, &placed).unwrap().unwrap()
-            ),
-            expected
-        );
-    }
-}

crates/oa-desktop/src/allocation_drag/geometry.rs

@@ -1,195 +0,0 @@
-//! Geometry operations over an explicitly captured placement set.
-use super::*;
-
-pub(super) struct Translation {
-    pub diagram: Diagram,
-    pub commands: Vec<Command>,
-    pub delta: Position,
-}
-
-/// Translate exactly `placements` using one snapped anchor delta. `base` must
-/// come from an exact, validated semantic candidate; absent routes are permitted
-/// only because that candidate has already admitted their semantic deletion.
-pub(super) fn translate(
-    accepted: &Project,
-    original: &Diagram,
-    base: &Diagram,
-    placements: &BTreeMap<Id, NodePlacement>,
-    anchor: Id,
-    requested: Position,
-) -> Result<Translation, Refusal> {
-    let anchor = placements.get(&anchor).ok_or(Refusal::StaleScope)?;
-    let delta = Position {
-        x: (requested.x / 10.).round() * 10. - anchor.position.x,
-        y: (requested.y / 10.).round() * 10. - anchor.position.y,
-    };
-    let mut diagram = base.clone();
-    let mut commands = Vec::new();
-    let mut deltas = BTreeMap::new();
-    for (id, captured) in placements {
-        let node = diagram.nodes.get_mut(id).ok_or(Refusal::StaleScope)?;
-        node.position = Position {
-            x: captured.position.x + delta.x,
-            y: captured.position.y + delta.y,
-        };
-        if !(Rect {
-            position: node.position,
-            size: node.size,
-        })
-        .valid()
-        {
-            return Err(Refusal::InvalidCandidate(
-                "Moved coordinates exceed the model bounds.".into(),
-            ));
-        }
-        deltas.insert(*id, delta);
-        if node != captured {
-            commands.push(Command::EditNode {
-                diagram: diagram.id,
-                original: *id,
-                node: node.clone(),
-            });
-        }
-    }
-    // Resolve actual endpoint owners once against accepted semantics and the
-    // complete delta map. Never reinsert a semantically deleted saved route.
-    for route in projection::translated_routes(accepted, original, &deltas) {
-        if let Some(stored) = diagram.routes.iter_mut().find(|r| r.edge == route.edge) {
-            if route.waypoints.iter().any(|point| {
-                !point.x.is_finite()
-                    || !point.y.is_finite()
-                    || point.x.abs() > MAX_COORDINATE
-                    || point.y.abs() > MAX_COORDINATE
-            }) {
-                return Err(Refusal::InvalidCandidate(
-                    "Moved route exceeds the model bounds.".into(),
-                ));
-            }
-            *stored = route.clone();
-            commands.push(Command::SetEdgeRoute {
-                diagram: diagram.id,
-                route,
-            });
-        }
-    }
-    Ok(Translation {
-        diagram,
-        commands,
-        delta,
-    })
-}
-
-/// Recover hidden ancestry for identity lookup only. The all-unfolded scene is
-/// never used for collision admission; only affected nodes and their ancestors
-/// enter the required diagnostic expansion.
-pub(super) fn expansion_ids(
-    p: &Project,
-    d: &Diagram,
-    index: &ViewIndex,
-    placements: &BTreeMap<Id, NodePlacement>,
-) -> Result<BTreeSet<Id>, Refusal> {
-    let mut all_unfolded = d.clone();
-    for node in all_unfolded.nodes.values_mut() {
-        node.collapsed = false;
-    }
-    let all_view = projection::project_diagram_with_index(p, &all_unfolded, index);
-    let ancestry = ancestors(&all_view);
-    let mut ids: BTreeSet<_> = placements.keys().copied().collect();
-    for id in placements.keys() {
-        ids.extend(ancestry.get(id).ok_or(Refusal::StaleScope)?.iter().copied());
-    }
-    Ok(ids)
-}
-
-pub(super) fn expanded_view(
-    p: &Project,
-    d: &Diagram,
-    index: &ViewIndex,
-    ids: &BTreeSet<Id>,
-) -> ProjectedView {
-    let mut expanded = d.clone();
-    for id in ids {
-        if let Some(node) = expanded.nodes.get_mut(id) {
-            node.collapsed = false;
-        }
-    }
-    projection::project_diagram_with_index(p, &expanded, index)
-}
-
-pub(super) fn check_scenes(
-    before_visible: &ProjectedView,
-    before_expanded: &ProjectedView,
-    visible: &ProjectedView,
-    expanded: &ProjectedView,
-) -> Result<(), Refusal> {
-    if visible.nodes.iter().chain(&expanded.nodes).any(|node| {
-        !(Rect {
-            position: node.position,
-            size: node.size,
-        })
-        .valid()
-    }) {
-        return Err(Refusal::InvalidCandidate(
-            "The projected enclosure exceeds the model bounds.".into(),
-        ));
-    }
-    if overlaps(before_visible, visible) || overlaps(before_expanded, expanded) {
-        return Err(Refusal::LayoutRequired(
-            "Make room before arranging: the candidate would introduce or enlarge overlapping cards."
-                .into(),
-        ));
-    }
-    Ok(())
-}
-
-pub(super) fn check_rigid(
-    before: &ProjectedView,
-    after: &ProjectedView,
-    placements: &BTreeMap<Id, NodePlacement>,
-    delta: Position,
-) -> Result<(), Refusal> {
-    let before: BTreeMap<_, _> = before.nodes.iter().map(|n| (n.id, n)).collect();
-    let after: BTreeMap<_, _> = after.nodes.iter().map(|n| (n.id, n)).collect();
-    for id in placements.keys() {
-        let old = before.get(id).ok_or(Refusal::StaleScope)?;
-        let new = after.get(id).ok_or(Refusal::StaleScope)?;
-        if (new.position.x - old.position.x - delta.x).abs() > 0.01
-            || (new.position.y - old.position.y - delta.y).abs() > 0.01
-            || (new.size.width - old.size.width).abs() > 0.01
-            || (new.size.height - old.size.height).abs() > 0.01
-        {
-            return Err(Refusal::LayoutRequired(
-                "This selection requires an explicit layout; its footprint cannot be translated unchanged."
-                    .into(),
-            ));
-        }
-    }
-    Ok(())
-}
-
-pub(super) fn check_headers(
-    view: &ProjectedView,
-    selected: &BTreeMap<Id, Id>,
-    viewport: Rect,
-) -> Result<(), Refusal> {
-    for (id, element) in selected {
-        let node = view
-            .nodes
-            .iter()
-            .find(|node| node.id == *id && node.element == *element)
-            .ok_or_else(|| Refusal::LayoutRequired("A selected header would be hidden.".into()))?;
-        let header = Rect {
-            position: node.position,
-            size: Size {
-                width: node.size.width,
-                height: node.size.height.min(62.),
-            },
-        };
-        if !viewport.contains(header) {
-            return Err(Refusal::LayoutRequired(
-                "Make room or adjust the view, then drag again.".into(),
-            ));
-        }
-    }
-    Ok(())
-}

crates/oa-desktop/src/allocation_drag/group_arrange_experiment.rs

@@ -1,450 +0,0 @@
-//! Reviewed policy experiment using the production projection and translator.
-//! No production admission or atomic-refusal behavior is tested here.
-use super::*;
-
-struct Mixed {
-    f: Fixture,
-    an: Id,
-    xn: Id,
-    yn: Id,
-    internal: Id,
-    include_performer: bool,
-}
-
-fn mixed(layer: Layer, collapsed: bool, obstacle: bool, include_performer: bool) -> Mixed {
-    let mut f = fixture(layer);
-    let work = f.p.elements[&f.w].kind();
-    let exchange = match layer {
-        Layer::Oa => RelationKind::Interaction,
-        Layer::Sa => RelationKind::FunctionalExchange,
-    };
-    let x = f.p.add_element(work, layer, "X", Some(f.w)).unwrap();
-    let y = f.p.add_element(work, layer, "Y", Some(f.w)).unwrap();
-    let outside = f.p.add_element(work, layer, "Outside", None).unwrap();
-    let xn = f.p.place(f.d, x, xy(140., 200.));
-    let yn = f.p.place(f.d, y, xy(940., 200.));
-    f.p.place(f.d, outside, xy(1800., 800.));
-    f.p.relate(RelationKind::Allocation, "A owns X", f.a, x);
-    f.p.relate(RelationKind::Allocation, "B owns Y", f.b, y);
-    // FunctionalExchange's actual builder creates valid function input/output
-    // ports; do not manufacture Interaction records between SA Functions.
-    let internal = f.p.relate(exchange, "X to Y", x, y);
-    let external = f.p.relate(exchange, "Y to Outside", y, outside);
-    let an = f.p.diagrams[&f.d]
-        .nodes
-        .values()
-        .find(|n| n.element == f.a)
-        .unwrap()
-        .id;
-    let d = f.p.diagrams.get_mut(&f.d).unwrap();
-    d.nodes.get_mut(&f.n).unwrap().position = xy(100., 800.);
-    d.nodes.get_mut(&an).unwrap().collapsed = collapsed;
-    d.routes = vec![route(internal), route(external)];
-    if obstacle {
-        let id =
-            f.p.add_element(work, layer, "Stationary obstacle", None)
-                .unwrap();
-        f.p.place(f.d, id, xy(550., 230.));
-    }
-    validate_candidate(&f.p).unwrap();
-    let captured = scope(&f);
-    assert_eq!(captured.uniform, Uniform::MixedOrUnresolved);
-    assert_eq!(
-        captured.placements.keys().copied().collect::<BTreeSet<_>>(),
-        BTreeSet::from([f.n, xn, yn])
-    );
-    // Explicit control: the real current API still refuses Arrange for this root.
-    assert!(matches!(
-        plan_semantics(&f.p, &captured, Destination::LayoutOnly, &BTreeMap::new()),
-        Err(Refusal::MixedLayoutRequired)
-    ));
-    assert!(matches!(
-        plan_semantics(
-            &f.p,
-            &captured,
-            Destination::Performer(f.a),
-            &BTreeMap::new()
-        ),
-        Err(Refusal::MixedLayoutRequired)
-    ));
-    Mixed {
-        f,
-        an,
-        xn,
-        yn,
-        internal,
-        include_performer,
-    }
-}
-
-fn affected(m: &Mixed) -> BTreeSet<Id> {
-    let mut ids: BTreeSet<_> = scope(&m.f).placements.keys().copied().collect();
-    let mut expected = BTreeSet::from([m.f.n, m.xn, m.yn]);
-    if m.include_performer {
-        ids.insert(m.an);
-        ids.extend(projection::descendant_nodes(&m.f.p, m.f.d, m.an));
-        expected.insert(m.an);
-    }
-    assert_eq!(ids, expected);
-    ids
-}
-
-// Diagnostic expansion changes only a temporary Diagram. Include affected
-// descendants and ancestors even when the normal projection hides them.
-// Unrelated folded interiors are intentionally OUTSIDE this diagnostic domain.
-fn diagnostic(p: &Project, diagram: Id, ids: &BTreeSet<Id>) -> ProjectedView {
-    let mut d = p.diagrams[&diagram].clone();
-    for (id, node) in &mut d.nodes {
-        if ids.contains(id)
-            || projection::descendant_nodes(p, diagram, *id)
-                .iter()
-                .any(|n| ids.contains(n))
-        {
-            node.collapsed = false;
-        }
-    }
-    projection::project_diagram(p, &d)
-}
-
-fn rigid(before: &ProjectedView, after: &ProjectedView, ids: &BTreeSet<Id>) {
-    for id in ids {
-        let old = before.nodes.iter().find(|n| n.id == *id).unwrap();
-        let new = after.nodes.iter().find(|n| n.id == *id).unwrap();
-        assert_eq!(new.position, xy(old.position.x + 400., old.position.y));
-        assert_eq!(new.size, old.size, "no reflow of an affected footprint");
-    }
-}
-
-// The only experimental bypass: use the pure general geometry command instead
-// of plan_semantics(LayoutOnly), whose mixed-root pre-veto is asserted above.
-// This is not a fabricated Scope or a call to singleton check_geometry with a
-// falsely enlarged Scope. The combined scene uses the real overlap predicate.
-fn candidate(m: &Mixed) -> (Command, Project) {
-    let ids = affected(m);
-    let command =
-        oa_core::diagram_edit::translate_placements(&m.f.p, m.f.d, &ids, xy(400., 0.)).unwrap();
-    let actual = prepare_command(&m.f.p, &command).unwrap().project;
-    validate_candidate(&actual).unwrap();
-    // Independent literal expected Project: no planner or route helper oracle.
-    let mut expected = m.f.p.clone();
-    let d = expected.diagrams.get_mut(&m.f.d).unwrap();
-    for (id, position) in [
-        (m.f.n, xy(500., 800.)),
-        (m.xn, xy(540., 200.)),
-        (m.yn, xy(1340., 200.)),
-    ] {
-        d.nodes.get_mut(&id).unwrap().position = position;
-    }
-    if m.include_performer {
-        d.nodes.get_mut(&m.an).unwrap().position = xy(500., 100.);
-    }
-    let internal = d.routes.iter_mut().find(|r| r.edge == m.internal).unwrap();
-    internal.waypoints = vec![xy(820., 400.), xy(820., 550.)];
-    assert_eq!(
-        actual, expected,
-        "complete records, including folds, routes, other view and relations"
-    );
-    (command, actual)
-}
-
-#[test]
-fn mixed_arrange_experiment_distributed_root_and_performer_can_translate_rigidly() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let enclosure_height = match layer {
-            Layer::Oa => 218.,
-            Layer::Sa => 256.,
-        };
-        for include_performer in [false, true] {
-            for collapsed in [false, true] {
-                let m = mixed(layer, collapsed, false, include_performer);
-                let accepted = m.f.p.clone();
-                let (command, actual) = candidate(&m);
-                let ids = affected(&m);
-                let before = projection::project_view(&accepted, m.f.d);
-                let after = projection::project_view(&actual, m.f.d);
-                let before_expanded = diagnostic(&accepted, m.f.d, &ids);
-                let after_expanded = diagnostic(&actual, m.f.d, &ids);
-                assert!(
-                    !overlaps(&before, &after),
-                    "visible scene must admit the combined move"
-                );
-                assert!(
-                    !overlaps(&before_expanded, &after_expanded),
-                    "expanded scene must admit the combined move"
-                );
-                rigid(&before_expanded, &after_expanded, &ids);
-                for node in after.nodes.iter().chain(&after_expanded.nodes) {
-                    assert!(
-                        (Rect {
-                            position: node.position,
-                            size: node.size
-                        })
-                        .valid()
-                    );
-                }
-                // Explicit selected headers remain visible. Native clipping/readability
-                // and complete group gesture admission are intentionally not claimed.
-                assert!(after.nodes.iter().any(|n| n.id == m.f.n));
-                if include_performer {
-                    assert!(after.nodes.iter().any(|n| n.id == m.an));
-                } else {
-                    assert_eq!(
-                        actual.diagrams[&m.f.d].nodes[&m.an],
-                        accepted.diagrams[&m.f.d].nodes[&m.an]
-                    );
-                    assert_eq!(node(&before_expanded, m.an).position, xy(100., 100.));
-                    assert_eq!(
-                        node(&before_expanded, m.an).size,
-                        Size {
-                            width: 288.,
-                            height: enclosure_height
-                        }
-                    );
-                    assert_eq!(node(&after_expanded, m.an).position, xy(100., 100.));
-                    assert_eq!(
-                        node(&after_expanded, m.an).size,
-                        Size {
-                            width: 688.,
-                            height: enclosure_height
-                        }
-                    );
-                }
-                assert_eq!(roundtrip(&accepted, command), actual);
-                assert_eq!(m.f.p, accepted);
-            }
-        }
-    }
-}
-
-#[test]
-fn mixed_arrange_experiment_detects_moved_folded_child_collision() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let expected_overlap = match layer {
-            Layer::Oa => 13696.,
-            Layer::Sa => 20116.,
-        };
-        let m = mixed(layer, true, true, true);
-        let accepted = m.f.p.clone();
-        let (_, actual) = candidate(&m);
-        let ids = affected(&m);
-        let before = projection::project_view(&accepted, m.f.d);
-        let after = projection::project_view(&actual, m.f.d);
-        assert!(!before.nodes.iter().any(|n| n.id == m.xn));
-        assert!(!after.nodes.iter().any(|n| n.id == m.xn));
-        assert!(
-            !overlaps(&before, &after),
-            "must distinguish hidden collision from ordinary visible refusal"
-        );
-        let before_expanded = diagnostic(&accepted, m.f.d, &ids);
-        let after_expanded = diagnostic(&actual, m.f.d, &ids);
-        rigid(&before_expanded, &after_expanded, &ids);
-        let obstacle = before_expanded
-            .nodes
-            .iter()
-            .find(|n| n.position == xy(550., 230.))
-            .unwrap()
-            .id;
-        assert_eq!(
-            overlap(
-                node(&before_expanded, m.xn),
-                node(&before_expanded, obstacle)
-            ),
-            0.
-        );
-        assert_eq!(
-            overlap(node(&after_expanded, m.xn), node(&after_expanded, obstacle)),
-            expected_overlap
-        );
-        assert!(
-            overlaps(&before_expanded, &after_expanded),
-            "combined diagnostic scene must refuse"
-        );
-        // Detection only: there is no production group admission/commit API here.
-        assert_eq!(m.f.p, accepted);
-    }
-}
-
-fn node(view: &ProjectedView, id: Id) -> &ProjectedNode {
-    view.nodes.iter().find(|n| n.id == id).unwrap()
-}
-
-#[test]
-fn mixed_arrange_experiment_detects_stationary_enclosure_growth_collision() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let enclosure_height = match layer {
-            Layer::Oa => 218.,
-            Layer::Sa => 256.,
-        };
-        let mut m = mixed(layer, false, false, true);
-        let kind = m.f.p.elements[&m.f.w].kind();
-        let z =
-            m.f.p
-                .add_element(kind, layer, "Stationary Z", None)
-                .unwrap();
-        let zn = m.f.p.place(m.f.d, z, xy(1200., 100.));
-        validate_candidate(&m.f.p).unwrap();
-        let accepted = m.f.p.clone();
-        let (_, actual) = candidate(&m);
-        let bn = accepted.diagrams[&m.f.d]
-            .nodes
-            .values()
-            .find(|n| n.element == m.f.b)
-            .unwrap()
-            .id;
-        let before = projection::project_view(&accepted, m.f.d);
-        let after = projection::project_view(&actual, m.f.d);
-        assert_eq!(node(&before, bn).position, xy(900., 100.));
-        assert_eq!(
-            node(&before, bn).size,
-            Size {
-                width: 288.,
-                height: enclosure_height
-            }
-        );
-        assert_eq!(node(&after, bn).position, xy(900., 100.));
-        assert_eq!(
-            node(&after, bn).size,
-            Size {
-                width: 688.,
-                height: enclosure_height
-            }
-        );
-        assert_eq!(node(&after, zn).position, xy(1200., 100.));
-        assert_eq!(
-            node(&after, zn).size,
-            Size {
-                width: 224.,
-                height: 94.
-            }
-        );
-        assert_eq!(overlap(node(&before, bn), node(&before, zn)), 0.);
-        assert_eq!(overlap(node(&after, bn), node(&after, zn)), 21056.);
-        assert_eq!(node(&after, m.yn).position, xy(1340., 200.));
-        assert_eq!(
-            node(&after, m.yn).position.y
-                - (node(&after, zn).position.y + node(&after, zn).size.height),
-            6.
-        );
-        for id in affected(&m) {
-            assert_eq!(overlap(node(&before, id), node(&before, zn)), 0.);
-            assert_eq!(overlap(node(&after, id), node(&after, zn)), 0.);
-        }
-        assert_eq!(
-            actual.diagrams[&m.f.d].nodes[&bn],
-            accepted.diagrams[&m.f.d].nodes[&bn]
-        );
-        assert_eq!(
-            actual.diagrams[&m.f.d].nodes[&zn],
-            accepted.diagrams[&m.f.d].nodes[&zn]
-        );
-        assert!(
-            overlaps(&before, &after),
-            "complete scene must detect stationary enclosure growth"
-        );
-        let ids = affected(&m);
-        assert!(overlaps(
-            &diagnostic(&accepted, m.f.d, &ids),
-            &diagnostic(&actual, m.f.d, &ids)
-        ));
-        assert_eq!(m.f.p, accepted);
-    }
-}
-
-#[test]
-fn mixed_arrange_experiment_unrelated_folded_interiors_are_outside_diagnostic_domain() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        // Independent source-derived literals: SA's auto-created function ports
-        // raise projected X/Y height to 76 + 28 * (1 + 1), while Z is port-free.
-        let (work_height, expected_overlap) = match layer {
-            Layer::Oa => (94., 13696.),
-            Layer::Sa => (132., 20116.),
-        };
-        let mut m = mixed(layer, true, false, true);
-        let performer = match layer {
-            Layer::Oa => Kind::Actor,
-            Layer::Sa => Kind::SystemActor,
-        };
-        let kind = m.f.p.elements[&m.f.w].kind();
-        let d =
-            m.f.p
-                .add_element(performer, layer, "Unrelated D", None)
-                .unwrap();
-        let z =
-            m.f.p
-                .add_element(kind, layer, "Unrelated hidden Z", None)
-                .unwrap();
-        m.f.p.relate(RelationKind::Allocation, "D owns Z", d, z);
-        let dn = m.f.p.place(m.f.d, d, xy(2500., 100.));
-        let zn = m.f.p.place(m.f.d, z, xy(550., 230.));
-        m.f.p
-            .diagrams
-            .get_mut(&m.f.d)
-            .unwrap()
-            .nodes
-            .get_mut(&dn)
-            .unwrap()
-            .collapsed = true;
-        validate_candidate(&m.f.p).unwrap();
-        let accepted = m.f.p.clone();
-        let (_, actual) = candidate(&m);
-        let ids = affected(&m);
-        let before = diagnostic(&accepted, m.f.d, &ids);
-        let after = diagnostic(&actual, m.f.d, &ids);
-        assert!(!before.nodes.iter().any(|n| n.id == zn));
-        assert!(!after.nodes.iter().any(|n| n.id == zn));
-        assert!(
-            !overlaps(&before, &after),
-            "chosen diagnostic domain excludes unrelated folded contents"
-        );
-        assert!(!overlaps(
-            &projection::project_view(&accepted, m.f.d),
-            &projection::project_view(&actual, m.f.d)
-        ));
-        let all_unfolded = |p: &Project| {
-            let mut diagram = p.diagrams[&m.f.d].clone();
-            for n in diagram.nodes.values_mut() {
-                n.collapsed = false;
-            }
-            projection::project_diagram(p, &diagram)
-        };
-        let broad_before = all_unfolded(&accepted);
-        let broad_after = all_unfolded(&actual);
-        assert_eq!(node(&broad_before, m.xn).position, xy(140., 200.));
-        assert_eq!(node(&broad_after, m.xn).position, xy(540., 200.));
-        assert_eq!(
-            node(&broad_after, m.xn).size,
-            Size {
-                width: 224.,
-                height: work_height
-            }
-        );
-        assert_eq!(node(&broad_before, zn).position, xy(550., 230.));
-        assert_eq!(node(&broad_after, zn).position, xy(550., 230.));
-        assert_eq!(
-            node(&broad_after, zn).size,
-            Size {
-                width: 224.,
-                height: 94.
-            }
-        );
-        assert_eq!(
-            overlap(node(&broad_before, m.xn), node(&broad_before, zn)),
-            0.
-        );
-        assert_eq!(
-            overlap(node(&broad_after, m.xn), node(&broad_after, zn)),
-            expected_overlap
-        );
-        // Other newly exposed enclosure pairs may also overlap. X/Z is a
-        // concrete discriminator, not a claim that it is the only cause.
-        assert!(overlaps(&broad_before, &broad_after));
-        for id in [dn, zn] {
-            assert_eq!(
-                actual.diagrams[&m.f.d].nodes[&id],
-                accepted.diagrams[&m.f.d].nodes[&id]
-            );
-        }
-        assert!(actual.diagrams[&m.f.d].nodes[&dn].collapsed);
-        assert_eq!(m.f.p, accepted);
-    }
-}

crates/oa-desktop/src/allocation_input.rs

@@ -1,269 +0,0 @@
-//! A narrow dispatch boundary for Allocation work gestures. Iced rows visit
-//! siblings after capture; refusing inside Canvas alone still blurs an inspector
-//! field. Refuse before dispatching that press to any ordinary child instead.
-use crate::{
-    app::{
-        App, Message,
-        allocation_drag::{self, Event as WorkEvent},
-    },
-    diagram::DiagramCanvas,
-};
-use iced::advanced::{
-    Clipboard, Layout, Shell, Widget, layout, overlay, renderer,
-    widget::{Id, Operation, Tree, tree},
-};
-use iced::{
-    Element, Event, Length, Point, Rectangle, Renderer, Size, Theme, Vector, keyboard, mouse,
-};
-
-pub const CANVAS_ID: &str = "allocation-work-canvas";
-pub const ARRANGE_SHORTCUT: &str = "Alt+A";
-
-struct Root<'a> {
-    app: &'a App,
-    content: Element<'a, Message>,
-}
-#[derive(Default)]
-struct State {
-    pointer: Option<Point>,
-    refused_left: bool,
-}
-#[derive(Default)]
-struct CanvasBounds(Option<Rectangle>);
-impl Operation for CanvasBounds {
-    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
-        visit(self);
-    }
-    fn container(&mut self, id: Option<&Id>, bounds: Rectangle) {
-        if id == Some(&Id::new(CANVAS_ID)) {
-            self.0 = Some(bounds);
-        }
-    }
-}
-pub fn root<'a>(app: &'a App, content: impl Into<Element<'a, Message>>) -> Element<'a, Message> {
-    Element::new(Root {
-        app,
-        content: content.into(),
-    })
-}
-fn arrange_key(event: &Event) -> bool {
-    matches!(event, Event::Keyboard(keyboard::Event::KeyPressed {
-        key: keyboard::Key::Character(key), modifiers, repeat: false, ..
-    }) if key.eq_ignore_ascii_case("a") && *modifiers == keyboard::Modifiers::ALT)
-}
-impl Root<'_> {
-    fn dirty_object(&self, bounds: Rectangle, screen: Point) -> bool {
-        let Some(diagram) = self.app.active_diagram else {
-            return false;
-        };
-        if !allocation_drag::contains(bounds, screen) {
-            return false;
-        }
-        let canvas = DiagramCanvas {
-            selection: self.app.diagram_selection.as_ref(),
-            allocation: Some(self.app.allocation_capability()),
-            project: self.app.project(),
-            view_index: Some(self.app.document.view_index()),
-            diagram,
-            selected: self.app.selected,
-            navigation_focus: None,
-            zoom: self.app.zoom,
-            pan: self.app.pan,
-            context: self.app.route_context().unwrap(),
-            selected_bend: None,
-            selected_attachment: None,
-            editable: false,
-            placing: false,
-            connection: None,
-        };
-        canvas.work_dirty_point(bounds, screen)
-    }
-}
-impl Widget<Message, Theme, Renderer> for Root<'_> {
-    fn tag(&self) -> tree::Tag {
-        tree::Tag::of::<State>()
-    }
-    fn state(&self) -> tree::State {
-        tree::State::new(State::default())
-    }
-    fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(self.content.as_widget())]
-    }
-    fn diff(&self, tree: &mut Tree) {
-        tree.diff_children(std::slice::from_ref(&self.content));
-    }
-    fn size(&self) -> Size<Length> {
-        self.content.as_widget().size()
-    }
-    fn layout(
-        &mut self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        self.content
-            .as_widget_mut()
-            .layout(&mut tree.children[0], renderer, limits)
-    }
-    fn operate(
-        &mut self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn Operation,
-    ) {
-        self.content
-            .as_widget_mut()
-            .operate(&mut tree.children[0], layout, renderer, operation);
-    }
-    fn update(
-        &mut self,
-        tree: &mut Tree,
-        event: &Event,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        viewport: &Rectangle,
-    ) {
-        let state = tree.state.downcast_mut::<State>();
-        match event {
-            Event::Mouse(mouse::Event::CursorMoved { position }) => state.pointer = Some(*position),
-            Event::Mouse(mouse::Event::CursorLeft) => state.pointer = None,
-            Event::Window(iced::window::Event::RedrawRequested(_)) => {
-                state.pointer = cursor.position()
-            }
-            Event::Window(iced::window::Event::Unfocused) => {
-                state.pointer = None;
-                state.refused_left = false;
-            }
-            _ => {}
-        }
-        if state.refused_left {
-            if matches!(
-                event,
-                Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
-            ) {
-                state.refused_left = false;
-                shell.capture_event();
-                return;
-            }
-            if matches!(event, Event::Mouse(mouse::Event::CursorMoved { .. })) {
-                shell.capture_event();
-                return;
-            }
-        }
-        if self.app.allocation_input_owner() && !shell.is_event_captured() {
-            if arrange_key(event) {
-                // App rechecks clean ownership before arming. A dirty field
-                // retains its actual widget focus and selection on refusal.
-                shell.publish(Message::WorkDrag(WorkEvent::ArrangeNext));
-                shell.capture_event();
-                return;
-            }
-            if self.app.allocation_drag.arrange_next
-                && matches!(
-                    event,
-                    Event::Keyboard(keyboard::Event::KeyPressed {
-                        key: keyboard::Key::Named(keyboard::key::Named::Escape),
-                        ..
-                    })
-                )
-            {
-                shell.publish(Message::Escape);
-                shell.capture_event();
-                return;
-            }
-            if !self.app.allocation_drag_clean()
-                && matches!(
-                    event,
-                    Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
-                )
-                && let Some(screen) = state.pointer.or_else(|| cursor.position())
-            {
-                let mut canvas = CanvasBounds::default();
-                self.content.as_widget_mut().operate(
-                    &mut tree.children[0],
-                    layout,
-                    renderer,
-                    &mut canvas,
-                );
-                if canvas
-                    .0
-                    .is_some_and(|bounds| self.dirty_object(bounds, screen))
-                {
-                    state.refused_left = true;
-                    shell.publish(Message::WorkDrag(WorkEvent::Refused(
-                        self.app.allocation_drag.epoch,
-                        allocation_drag::FINISH_EDIT.into(),
-                    )));
-                    shell.capture_event();
-                    return;
-                }
-            }
-        }
-        self.content.as_widget_mut().update(
-            &mut tree.children[0],
-            event,
-            layout,
-            cursor,
-            renderer,
-            clipboard,
-            shell,
-            viewport,
-        );
-    }
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-    ) {
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            style,
-            layout,
-            cursor,
-            viewport,
-        );
-    }
-    fn mouse_interaction(
-        &self,
-        tree: &Tree,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.content.as_widget().mouse_interaction(
-            &tree.children[0],
-            layout,
-            cursor,
-            viewport,
-            renderer,
-        )
-    }
-    fn overlay<'b>(
-        &'b mut self,
-        tree: &'b mut Tree,
-        layout: Layout<'b>,
-        renderer: &Renderer,
-        viewport: &Rectangle,
-        translation: Vector,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.content.as_widget_mut().overlay(
-            &mut tree.children[0],
-            layout,
-            renderer,
-            viewport,
-            translation,
-        )
-    }
-}

crates/oa-desktop/src/app/allocation_drag_full_tree_tests.rs

@@ -1,731 +0,0 @@
-//! Actual App root, retained Iced tree, property widgets and production renderer.
-//! Unlike packet-only tests, these prove the next key still reaches the field.
-use super::*;
-use crate::behavior::canvas_workspace::tests::{Mounted, key};
-use iced::{Event as Input, keyboard};
-
-#[path = "allocation_drag_tests/control_focus.rs"]
-mod control_focus;
-
-fn character(text: &str, modifiers: keyboard::Modifiers) -> Input {
-    Input::Keyboard(keyboard::Event::KeyPressed {
-        key: keyboard::Key::Character(text.into()),
-        modified_key: keyboard::Key::Character(text.into()),
-        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::KeyA),
-        location: keyboard::Location::Standard,
-        modifiers,
-        text: Some(text.into()),
-        repeat: false,
-    })
-}
-async fn mount() -> (Fixture, Mounted) {
-    let mut f = fixture(Layer::Oa);
-    f.app.window_size = iced::Size::new(2000., 1400.);
-    let _ = f.app.update(Message::Select(f.work));
-    let mut mounted = Mounted::new(&mut f.app).await;
-    // First sensor measurement intentionally Fits; now use a fixed known camera.
-    f.app.zoom = 1.;
-    f.app.pan = Vector::ZERO;
-    f.app.fit_to_view = false;
-    mounted.settle(&mut f.app).await;
-    (f, mounted)
-}
-fn canvas_bounds(mounted: &mut Mounted, app: &App) -> Rectangle {
-    mounted
-        .geometry(app)
-        .bounds(crate::allocation_input::CANVAS_ID)
-}
-fn at(mounted: &mut Mounted, f: &Fixture, world: Position) -> Point {
-    let bounds = canvas_bounds(mounted, &f.app);
-    Point::new(
-        bounds.x + world.x * f.app.zoom + f.app.pan.x,
-        bounds.y + world.y * f.app.zoom + f.app.pan.y,
-    )
-}
-fn name_field(mounted: &mut Mounted, app: &App) -> Rectangle {
-    mounted
-        .geometry(app)
-        .text_inputs
-        .into_iter()
-        .filter(|b| b.x > app.window_size.width - 320.)
-        .min_by(|a, b| a.y.total_cmp(&b.y))
-        .expect("actual inspector Name TextInput")
-}
-fn description_field(mounted: &mut Mounted, app: &App) -> Rectangle {
-    mounted
-        .geometry(app)
-        .focused
-        .into_iter()
-        .map(|(_, bounds, _)| bounds)
-        .filter(|b| b.x > app.window_size.width - 320. && b.height >= 90.)
-        .min_by(|a, b| a.y.total_cmp(&b.y))
-        .expect("actual inspector Description TextEditor")
-}
-fn is_focused(mounted: &mut Mounted, app: &App, field: Rectangle) -> bool {
-    mounted
-        .geometry(app)
-        .focused
-        .iter()
-        .any(|(_, bounds, focused)| *bounds == field && *focused)
-}
-async fn type_key(mounted: &mut Mounted, app: &mut App, text: &str) -> Vec<Message> {
-    mounted
-        .batch(
-            app,
-            &[character(text, keyboard::Modifiers::empty())],
-            mouse::Cursor::Unavailable,
-        )
-        .await
-}
-async fn refused_click_keeps_field(mounted: &mut Mounted, f: &mut Fixture, field: Rectangle) {
-    let before = f.app.document.bundle().clone();
-    let selected = (f.app.selected, f.app.selected_node);
-    let point = at(mounted, f, xy(140., 535.));
-    let messages = mounted.click(&mut f.app, point).await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::WorkDrag(Event::Refused(..))))
-    );
-    assert!(!messages.iter().any(|m| matches!(
-        m,
-        Message::Select(_) | Message::SelectNode(_) | Message::MoveNode(..)
-    )));
-    assert_eq!(f.app.document.bundle(), &before);
-    assert_eq!((f.app.selected, f.app.selected_node), selected);
-    assert!(
-        is_focused(mounted, &f.app, field),
-        "refused press must not reach the outside-press unfocus handler"
-    );
-}
-
-#[tokio::test]
-async fn actual_app_tree_dirty_name_retains_focus_and_middle_caret_for_next_key() {
-    let (mut f, mut mounted) = mount().await;
-    let field = name_field(&mut mounted, &f.app);
-    mounted.click(&mut f.app, field.center()).await;
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::Home)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    type_key(&mut mounted, &mut f.app, "X").await;
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::ArrowLeft)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert_eq!(f.app.draft.as_ref().unwrap().inputs["/name"].raw, "XWork");
-    refused_click_keeps_field(&mut mounted, &mut f, field).await;
-    let messages = type_key(&mut mounted, &mut f.app, "Y").await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::Field(path, _) if path == "/name"))
-    );
-    assert_eq!(f.app.draft.as_ref().unwrap().inputs["/name"].raw, "YXWork");
-    assert!(!f.app.document.can_undo());
-}
-
-#[tokio::test]
-async fn actual_app_tree_dirty_description_retains_focus_and_middle_caret_for_next_key() {
-    let (mut f, mut mounted) = mount().await;
-    let field = description_field(&mut mounted, &f.app);
-    mounted
-        .click(&mut f.app, Point::new(field.x + 16., field.y + 16.))
-        .await;
-    type_key(&mut mounted, &mut f.app, "A").await;
-    type_key(&mut mounted, &mut f.app, "B").await;
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::ArrowLeft)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert_eq!(
-        f.app.draft.as_ref().unwrap().inputs["/description"].raw,
-        "AB"
-    );
-    refused_click_keeps_field(&mut mounted, &mut f, field).await;
-    let messages = type_key(&mut mounted, &mut f.app, "X").await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::FieldText(path, _) if path == "/description"))
-    );
-    assert_eq!(
-        f.app.draft.as_ref().unwrap().inputs["/description"].raw,
-        "AXB"
-    );
-    assert!(!f.app.document.can_undo());
-}
-
-#[tokio::test]
-async fn actual_keyboard_arrange_shortcut_consumes_once_escape_cancels_and_dirty_owner_refuses() {
-    let (mut f, mut mounted) = mount().await;
-    let shortcut = character("a", keyboard::Modifiers::ALT);
-    let messages = mounted
-        .batch(
-            &mut f.app,
-            std::slice::from_ref(&shortcut),
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::WorkDrag(Event::ArrangeNext)))
-    );
-    assert!(f.app.allocation_drag.arrange_next);
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::Escape)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(!f.app.allocation_drag.arrange_next);
-    mounted
-        .batch(
-            &mut f.app,
-            std::slice::from_ref(&shortcut),
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    let from = at(&mut mounted, &f, xy(140., 535.));
-    let to = from + Vector::new(30., 0.);
-    let messages = mounted
-        .batch(
-            &mut f.app,
-            &[
-                Input::Mouse(mouse::Event::CursorMoved { position: from }),
-                Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                Input::Mouse(mouse::Event::CursorMoved { position: to }),
-                Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
-            ],
-            mouse::Cursor::Available(to),
-        )
-        .await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::WorkDrag(Event::Press(p)) if p.mode == Mode::Arrange))
-    );
-    assert!(!f.app.allocation_drag.arrange_next);
-    assert_eq!(f.app.document.revision(), 1, "{}", f.app.status);
-    assert!(f.app.project().relations.is_empty());
-    let field = name_field(&mut mounted, &f.app);
-    mounted.click(&mut f.app, field.center()).await;
-    type_key(&mut mounted, &mut f.app, "X").await;
-    let raw = f.app.draft.as_ref().unwrap().inputs["/name"].raw.clone();
-    let before = f.app.document.bundle().clone();
-    mounted
-        .batch(&mut f.app, &[shortcut], mouse::Cursor::Unavailable)
-        .await;
-    assert!(!f.app.allocation_drag.arrange_next);
-    assert_eq!(f.app.status, FINISH_EDIT);
-    assert!(is_focused(&mut mounted, &f.app, field));
-    assert_eq!(f.app.draft.as_ref().unwrap().inputs["/name"].raw, raw);
-    assert_eq!(f.app.document.bundle(), &before);
-}
-
-fn canvas_pixels(pixels: &[u8], width: usize, canvas: Rectangle) -> Vec<u8> {
-    let x = canvas.x.ceil() as usize;
-    let y = canvas.y.ceil() as usize;
-    let right = (canvas.x + canvas.width).floor() as usize;
-    let bottom = (canvas.y + canvas.height).floor() as usize;
-    (y..bottom)
-        .flat_map(|row| {
-            pixels[(row * width + x) * 4..(row * width + right) * 4]
-                .iter()
-                .copied()
-        })
-        .collect()
-}
-
-#[tokio::test]
-async fn actual_rendered_canvas_pixels_do_not_change_when_toolbar_feedback_text_changes() {
-    let (mut f, mut mounted) = mount().await;
-    let mut project = f.app.project().clone();
-    let target = project
-        .diagrams
-        .get_mut(&f.diagram)
-        .unwrap()
-        .nodes
-        .values_mut()
-        .find(|n| n.element == f.a)
-        .unwrap();
-    target.position.y = -41.;
-    target.size.height = 300.;
-    replace(&mut f, project);
-    f.app.zoom = 0.75;
-    f.app.pan = Vector::new(15., 15.);
-    let from = at(&mut mounted, &f, xy(140., 535.));
-    let to = at(&mut mounted, &f, xy(200., 80.));
-    mounted
-        .batch(
-            &mut f.app,
-            &[
-                Input::Mouse(mouse::Event::CursorMoved { position: from }),
-                Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                Input::Mouse(mouse::Event::CursorMoved { position: to }),
-            ],
-            mouse::Cursor::Available(to),
-        )
-        .await;
-    let feedback = f
-        .app
-        .allocation_drag
-        .feedback
-        .as_ref()
-        .expect("active frozen destination");
-    assert!(!feedback.refused, "{}", feedback.text);
-    let target = &feedback.frozen.as_ref().unwrap().targets[feedback.targets[0]];
-    assert!(target.region.y * f.app.zoom + f.app.pan.y < 0.);
-    assert_eq!(feedback.destination_identity(), "A");
-    let canvas = canvas_bounds(&mut mounted, &f.app);
-    let first = mounted.pixels(&f.app);
-    f.app.allocation_drag.feedback.as_mut().unwrap().text =
-        "Very different drag status, retained outside the readable canvas. ".repeat(10);
-    let second = mounted.pixels(&f.app);
-    assert_ne!(first, second, "the actual toolbar status changes");
-    assert_eq!(
-        canvas_pixels(&first, f.app.window_size.width as usize, canvas),
-        canvas_pixels(&second, f.app.window_size.width as usize, canvas),
-        "status must not obscure any candidate header or destination identity"
-    );
-}
-
-fn destination_bounds(mounted: &mut Mounted, app: &App) -> Rectangle {
-    mounted.geometry(app).bounds("allocation-destination")
-}
-fn assert_on_screen(bounds: Rectangle, app: &App) {
-    assert!(
-        bounds.x >= 0. && bounds.y >= 0. && bounds.width >= 400. && bounds.height == 26.,
-        "{bounds:?}"
-    );
-    assert!(
-        bounds.x + bounds.width <= app.window_size.width
-            && bounds.y + bounds.height <= app.window_size.height,
-        "{bounds:?}"
-    );
-}
-
-#[tokio::test]
-async fn actual_app_tree_exact_incoming_drag_keeps_destination_visible_and_canvas_stable() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for (minimum, name, collapsed, zoom, pan) in [
-            (false, "Receiver", false, 1., Vector::ZERO),
-            (false, "Receiver", false, 0.75, Vector::new(37., -15.)),
-            (
-                false,
-                "Receiving subsystem",
-                true,
-                1.25,
-                Vector::new(-30., 23.),
-            ),
-            (
-                false,
-                "Receiving subsystem",
-                true,
-                1.,
-                Vector::new(0., -100.),
-            ),
-            (true, "Receiving subsystem", true, 1., Vector::ZERO),
-            (
-                true,
-                "Receiving subsystem WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW",
-                true,
-                1.,
-                Vector::new(0., -100.),
-            ),
-        ] {
-            let mut f = fixture(layer);
-            let mut project = f.app.project().clone();
-            project.elements.get_mut(&f.a).unwrap().name = name.into();
-            let diagram = project.diagrams.get_mut(&f.diagram).unwrap();
-            let target = diagram
-                .nodes
-                .values_mut()
-                .find(|n| n.element == f.a)
-                .unwrap();
-            target.collapsed = collapsed;
-            let target_id = target.id;
-            // At minimum size, keep the source in the visible canvas; preserve
-            // the same standard (40,35) name grab and original target geometry.
-            let source_y = if minimum { 210. } else { 500. };
-            diagram.nodes.get_mut(&f.node).unwrap().position.y = source_y;
-            replace(&mut f, project);
-            f.app.layer = layer;
-            f.app.window_size = if minimum {
-                iced::Size::new(1100., 700.)
-            } else {
-                iced::Size::new(2000., 1400.)
-            };
-            let _ = f.app.update(Message::Select(f.work));
-            let mut mounted = Mounted::new(&mut f.app).await;
-            f.app.zoom = zoom;
-            f.app.pan = pan;
-            f.app.fit_to_view = false;
-            mounted.settle(&mut f.app).await;
-            let canvas = canvas_bounds(&mut mounted, &f.app);
-            let slot = destination_bounds(&mut mounted, &f.app);
-            assert_on_screen(slot, &f.app);
-            assert!(slot.y + slot.height <= canvas.y);
-            let idle = mounted.pixels(&f.app);
-            let before = f.app.project().clone();
-            let source = f.app.document.bundle().clone();
-            let from = at(&mut mounted, &f, xy(140., source_y + 35.));
-            // Use the middle of the snap cell. Fractional App-layout origins
-            // can perturb an exact half-grid tie by one floating-point ULP.
-            // The packet/planner cases retain the original y140 counterexample.
-            let to = at(&mut mounted, &f, xy(160., 145.));
-            assert!(
-                canvas.contains(from) && canvas.contains(to),
-                "{canvas:?} {from:?} {to:?}"
-            );
-            mounted
-                .batch(
-                    &mut f.app,
-                    &[
-                        Input::Mouse(mouse::Event::CursorMoved { position: from }),
-                        Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                        Input::Mouse(mouse::Event::CursorMoved { position: to }),
-                    ],
-                    mouse::Cursor::Available(to),
-                )
-                .await;
-            let feedback = f
-                .app
-                .allocation_drag
-                .feedback
-                .as_ref()
-                .expect(&f.app.status);
-            assert!(!feedback.refused, "{}", feedback.text);
-            assert_eq!(feedback.destination_identity(), name);
-            let preview = f.app.allocation_drag.preview.as_ref().expect(&f.app.status);
-            assert_eq!(
-                preview.placement.diagram.nodes[&f.node].position,
-                xy(120., 110.),
-                "{layer:?}, minimum={minimum}, zoom={zoom}, pan={pan:?}, canvas={canvas:?}"
-            );
-            assert!(!preview.placement.diagram.nodes[&target_id].collapsed);
-            let selected = preview
-                .placement
-                .view
-                .nodes
-                .iter()
-                .find(|node| node.id == f.node)
-                .unwrap();
-            let selected_header = Rectangle::new(
-                Point::new(
-                    canvas.x + selected.position.x * zoom + pan.x,
-                    canvas.y + selected.position.y * zoom + pan.y,
-                ),
-                iced::Size::new(
-                    selected.size.width * zoom,
-                    selected.size.height.min(62.) * zoom,
-                ),
-            );
-            assert!(canvas.contains(Point::new(selected_header.x, selected_header.y)));
-            assert!(
-                selected_header.x + selected_header.width <= canvas.x + canvas.width
-                    && selected_header.y + selected_header.height <= canvas.y + canvas.height
-            );
-            let mut expected = preview.project().clone();
-            expected
-                .diagrams
-                .insert(f.diagram, preview.placement.diagram.clone());
-            assert_eq!(f.app.project(), &before);
-            assert_eq!(f.app.document.bundle(), &source);
-            assert!(!f.app.document.can_undo());
-            assert_eq!(canvas_bounds(&mut mounted, &f.app), canvas);
-            assert_eq!(destination_bounds(&mut mounted, &f.app), slot);
-            let active = mounted.pixels(&f.app);
-            if minimum {
-                record_render_evidence(
-                    &format!(
-                        "{layer:?}-minimum-{}",
-                        if pan.y < 0. { "top" } else { "normal" }
-                    ),
-                    &active,
-                    &f.app,
-                    slot,
-                    canvas,
-                );
-            }
-            let width = f.app.window_size.width as usize;
-            assert_ne!(
-                canvas_pixels(&idle, width, slot),
-                canvas_pixels(&active, width, slot),
-                "actual destination text is painted in its dedicated visible slot"
-            );
-            f.app.allocation_drag.feedback.as_mut().unwrap().text =
-                "Long refusal/status prose must not obscure work or destination. ".repeat(30);
-            let verbose = mounted.pixels(&f.app);
-            assert_ne!(active, verbose);
-            assert_eq!(
-                canvas_pixels(&active, width, canvas),
-                canvas_pixels(&verbose, width, canvas)
-            );
-            assert_eq!(
-                canvas_pixels(&active, width, slot),
-                canvas_pixels(&verbose, width, slot)
-            );
-            assert_eq!(canvas_bounds(&mut mounted, &f.app), canvas);
-            if pan.y == -100. {
-                // A genuine clipping refusal in the same held gesture, then
-                // recovery at the original exact point: no camera rebasing.
-                let clipped = at(&mut mounted, &f, xy(160., 110.));
-                mounted
-                    .batch(
-                        &mut f.app,
-                        &[Input::Mouse(mouse::Event::CursorMoved {
-                            position: clipped,
-                        })],
-                        mouse::Cursor::Available(clipped),
-                    )
-                    .await;
-                assert!(f.app.allocation_drag.feedback.as_ref().unwrap().refused);
-                assert!(f.app.allocation_drag.preview.is_none());
-                assert_eq!(canvas_bounds(&mut mounted, &f.app), canvas);
-                assert_eq!(destination_bounds(&mut mounted, &f.app), slot);
-                assert_eq!(f.app.project(), &before);
-                assert_eq!(f.app.document.bundle(), &source);
-                mounted
-                    .batch(
-                        &mut f.app,
-                        &[Input::Mouse(mouse::Event::CursorMoved { position: to })],
-                        mouse::Cursor::Available(to),
-                    )
-                    .await;
-                assert!(!f.app.allocation_drag.feedback.as_ref().unwrap().refused);
-            }
-            mounted
-                .batch(
-                    &mut f.app,
-                    &[Input::Mouse(mouse::Event::ButtonReleased(
-                        mouse::Button::Left,
-                    ))],
-                    mouse::Cursor::Available(to),
-                )
-                .await;
-            assert_eq!(f.app.project(), &expected, "{}", f.app.status);
-            assert_eq!(f.app.document.revision(), 1);
-            assert_eq!(canvas_bounds(&mut mounted, &f.app), canvas);
-            assert_eq!(destination_bounds(&mut mounted, &f.app), slot);
-            let after = f.app.document.bundle().clone();
-            let _ = f.app.update(Message::Undo);
-            assert_eq!(f.app.project(), &before);
-            assert_eq!(f.app.document.bundle(), &source);
-            assert!(!f.app.document.can_undo());
-            let _ = f.app.update(Message::Redo);
-            assert_eq!(f.app.project(), &expected);
-            assert_eq!(f.app.document.bundle(), &after);
-            assert!(!f.app.document.can_redo());
-        }
-    }
-}
-
-/// Optional reproducible visual evidence; normal test runs create no artifacts.
-fn record_render_evidence(
-    name: &str,
-    pixels: &[u8],
-    app: &App,
-    slot: Rectangle,
-    canvas: Rectangle,
-) {
-    let Some(path) = std::env::var_os("ARCADIA_RENDER_EVIDENCE_DIR") else {
-        return;
-    };
-    let path = std::path::PathBuf::from(path);
-    std::fs::create_dir_all(&path).unwrap();
-    let mut file = std::fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path.join(format!("{name}.rgba")))
-        .unwrap();
-    std::io::Write::write_all(&mut file, pixels).unwrap();
-    let metadata = serde_json::json!({
-        "width": app.window_size.width as u32, "height": app.window_size.height as u32,
-        "destination": [slot.x, slot.y, slot.width, slot.height],
-        "canvas": [canvas.x, canvas.y, canvas.width, canvas.height],
-        "identity": app.allocation_drag.feedback.as_ref().map(|f| f.destination_identity()),
-    });
-    let mut file = std::fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(path.join(format!("{name}.json")))
-        .unwrap();
-    std::io::Write::write_all(&mut file, &serde_json::to_vec_pretty(&metadata).unwrap()).unwrap();
-}
-
-#[tokio::test]
-async fn actual_toolbar_hover_inspects_last_full_name_without_authorizing_an_outside_drop() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut f = fixture(layer);
-        let name = "Receiving subsystem with a long exact identity beyond the compact label";
-        let mut project = f.app.project().clone();
-        project.elements.get_mut(&f.a).unwrap().name = name.into();
-        project
-            .diagrams
-            .get_mut(&f.diagram)
-            .unwrap()
-            .nodes
-            .get_mut(&f.node)
-            .unwrap()
-            .position
-            .y = 210.;
-        replace(&mut f, project);
-        f.app.layer = layer;
-        f.app.window_size = iced::Size::new(1100., 700.);
-        let _ = f.app.update(Message::Select(f.work));
-        let mut mounted = Mounted::new(&mut f.app).await;
-        f.app.zoom = 1.;
-        f.app.pan = Vector::ZERO;
-        f.app.fit_to_view = false;
-        mounted.settle(&mut f.app).await;
-        let canvas = canvas_bounds(&mut mounted, &f.app);
-        let slot = destination_bounds(&mut mounted, &f.app);
-        let from = at(&mut mounted, &f, xy(140., 245.));
-        let to = at(&mut mounted, &f, xy(160., 145.));
-        let before = f.app.document.bundle().clone();
-        mounted
-            .batch(
-                &mut f.app,
-                &[
-                    Input::Mouse(mouse::Event::CursorMoved { position: from }),
-                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                    Input::Mouse(mouse::Event::CursorMoved { position: to }),
-                ],
-                mouse::Cursor::Available(to),
-            )
-            .await;
-        assert_eq!(
-            f.app
-                .allocation_drag
-                .feedback
-                .as_ref()
-                .unwrap()
-                .destination_identity(),
-            name
-        );
-        assert!(f.app.allocation_drag.preview.is_some());
-        let hover = Point::new(slot.x + 45., slot.y + 8.);
-        mounted
-            .batch(
-                &mut f.app,
-                &[Input::Mouse(mouse::Event::CursorMoved { position: hover })],
-                mouse::Cursor::Available(hover),
-            )
-            .await;
-        let feedback = f.app.allocation_drag.feedback.as_ref().unwrap();
-        assert!(feedback.refused);
-        assert!(feedback.targets.is_empty());
-        assert_eq!(feedback.destination_identity(), "No eligible destination");
-        assert!(
-            feedback
-                .inspection_identity()
-                .contains(&format!("Last target: {name}"))
-        );
-        assert!(f.app.allocation_drag.preview.is_none());
-        assert!(f.app.allocation_drag.active.is_some());
-        assert!(f.app.status.starts_with("Pointer outside canvas"));
-        let inspected = mounted.pixels_at(&f.app, mouse::Cursor::Available(hover));
-        // Iced's Tooltip overlay draws its child but exposes no Operation
-        // traversal. Compare the real rendered overlay instead of inventing
-        // container geometry that the installed widget cannot report.
-        let inspection = std::mem::take(
-            &mut f
-                .app
-                .allocation_drag
-                .feedback
-                .as_mut()
-                .unwrap()
-                .inspection_targets,
-        );
-        let without_name = mounted.pixels_at(&f.app, mouse::Cursor::Available(hover));
-        let width = f.app.window_size.width as usize;
-        assert_ne!(
-            inspected, without_name,
-            "full captured name changes the actual hovered tooltip"
-        );
-        assert_eq!(
-            canvas_pixels(&inspected, width, canvas),
-            canvas_pixels(&without_name, width, canvas)
-        );
-        assert_eq!(
-            canvas_pixels(&inspected, width, slot),
-            canvas_pixels(&without_name, width, slot)
-        );
-        f.app
-            .allocation_drag
-            .feedback
-            .as_mut()
-            .unwrap()
-            .inspection_targets = inspection;
-        assert_eq!(canvas_bounds(&mut mounted, &f.app), canvas);
-        record_render_evidence(
-            &format!("{layer:?}-name-inspection"),
-            &inspected,
-            &f.app,
-            slot,
-            canvas,
-        );
-        assert_eq!(f.app.document.bundle(), &before);
-        assert!(!f.app.document.can_undo());
-
-        // Inspection grants no mutation authority. Releasing over it cancels.
-        mounted
-            .batch(
-                &mut f.app,
-                &[Input::Mouse(mouse::Event::ButtonReleased(
-                    mouse::Button::Left,
-                ))],
-                mouse::Cursor::Available(hover),
-            )
-            .await;
-        assert!(f.app.allocation_drag.active.is_none());
-        assert!(f.app.allocation_drag.feedback.is_none());
-        assert_eq!(f.app.status, "Drag canceled outside the canvas.");
-        assert_eq!(f.app.document.bundle(), &before);
-        assert!(!f.app.document.can_undo());
-        // A fresh gesture cannot inherit the previous inspection name.
-        mounted
-            .batch(
-                &mut f.app,
-                &[
-                    Input::Mouse(mouse::Event::CursorMoved { position: from }),
-                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
-                    Input::Mouse(mouse::Event::CursorMoved { position: hover }),
-                ],
-                mouse::Cursor::Available(hover),
-            )
-            .await;
-        let feedback = f.app.allocation_drag.feedback.as_ref().unwrap();
-        assert!(feedback.inspection_targets.is_empty());
-        assert!(!feedback.inspection_identity().contains(name));
-        mounted
-            .batch(
-                &mut f.app,
-                &[
-                    Input::Mouse(mouse::Event::CursorMoved { position: to }),
-                    Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
-                ],
-                mouse::Cursor::Available(to),
-            )
-            .await;
-        assert_eq!(
-            validation::effective_performer(f.app.project(), f.work),
-            Some(f.a)
-        );
-        assert_eq!(f.app.document.revision(), 1);
-        let _ = f.app.update(Message::Undo);
-        assert_eq!(f.app.document.bundle(), &before);
-    }
-}

crates/oa-desktop/src/app/allocation_drag_tests/control_focus.rs

@@ -1,111 +0,0 @@
-use super::*;
-
-#[tokio::test]
-async fn dirty_selected_pin_outer_ring_keeps_real_name_focus_and_caret() {
-    let mut f = fixture(Layer::Oa);
-    let mut p = f.app.project().clone();
-    let peer = p
-        .add_element(Kind::Activity, Layer::Oa, "Peer", None)
-        .unwrap();
-    p.place(f.diagram, peer, xy(700., 500.));
-    let edge = p.relate(RelationKind::Interaction, "Flow", f.work, peer);
-    let pin = xy(450., 547.);
-    p.diagrams
-        .get_mut(&f.diagram)
-        .unwrap()
-        .routes
-        .push(EdgeRoute {
-            edge,
-            source_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Right,
-                offset: 0.5,
-            }),
-            target_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Left,
-                offset: 0.5,
-            }),
-            waypoints: vec![pin],
-            label: Some(EdgeLabel {
-                fraction: 0.8,
-                offset: xy(0., -60.),
-            }),
-        });
-    validate_candidate(&p).unwrap();
-    let view = projection::project_view(&p, f.diagram);
-    let routed = routing::route_diagram(&p, &p.diagrams[&f.diagram], &view);
-    assert_eq!(routed.edges[&edge].pins, vec![pin]);
-    assert!(!routed.edges[&edge].custom_suspended);
-    assert!(
-        routed.edges[&edge]
-            .points
-            .iter()
-            .all(|point| point.y == 547.)
-    );
-    f.app = App::with_project(p);
-    f.app.active_diagram = Some(f.diagram);
-    f.app.window_size = iced::Size::new(2000., 1400.);
-    let _ = f.app.update(Message::Select(edge));
-    f.app.reconcile_multiselect();
-    let mut mounted = Mounted::new(&mut f.app).await;
-    f.app.zoom = 1.;
-    f.app.pan = Vector::ZERO;
-    f.app.fit_to_view = false;
-    mounted.settle(&mut f.app).await;
-    let field = name_field(&mut mounted, &f.app);
-    mounted.click(&mut f.app, field.center()).await;
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::Home)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    type_key(&mut mounted, &mut f.app, "X").await;
-    mounted
-        .batch(
-            &mut f.app,
-            &[key(keyboard::key::Named::ArrowLeft)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert_eq!(f.app.draft.as_ref().unwrap().inputs["/name"].raw, "XFlow");
-    assert!(f.app.draft_dirty());
-    let accepted = f.app.document.snapshot();
-    let source = f.app.document.bundle().clone();
-    let selection = f.app.multiselect_snapshot().unwrap();
-    let pan = f.app.pan;
-    // Exposed straight-run bend: outside the 7px line hit, within the 8px handle.
-    let point = at(&mut mounted, &f, xy(pin.x, pin.y + 7.5));
-    let messages = mounted.click(&mut f.app, point).await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::WorkDrag(Event::Refused(..))))
-    );
-    assert!(!messages.iter().any(|m| matches!(
-        m,
-        Message::Pan(_)
-            | Message::Select(_)
-            | Message::SelectNode(_)
-            | Message::MoveNode(..)
-            | Message::Route(_)
-            | Message::DiagramSelection(_)
-    )));
-    assert!(Arc::ptr_eq(&accepted, &f.app.document.snapshot()));
-    assert_eq!(f.app.document.bundle(), &source);
-    assert_eq!(f.app.multiselect_snapshot().unwrap(), selection);
-    assert_eq!(f.app.pan, pan);
-    assert!(
-        is_focused(&mut mounted, &f.app, field),
-        "dirty handle press must stop before outside-press unfocus"
-    );
-    let messages = type_key(&mut mounted, &mut f.app, "Y").await;
-    assert!(
-        messages
-            .iter()
-            .any(|m| matches!(m, Message::Field(path, _) if path == "/name"))
-    );
-    assert_eq!(f.app.draft.as_ref().unwrap().inputs["/name"].raw, "YXFlow");
-    assert_eq!(f.app.document.bundle(), &source);
-    assert!(!f.app.document.can_undo());
-}

crates/oa-desktop/src/app/allocation_drag_tests/group.rs

@@ -1,904 +0,0 @@
-use super::*;
-use crate::app::multiselect::{self, Choice};
-use crate::diagram_usage::Target as SelectionTarget;
-use iced::widget::text_editor;
-
-#[path = "group/connection_lifetime.rs"]
-mod connection_lifetime;
-#[path = "group/route_lifetime.rs"]
-mod route_lifetime;
-
-struct Group {
-    f: Fixture,
-    y: Id,
-    yn: Id,
-    c: Id,
-    cn: Id,
-    an: Id,
-    ax: Id,
-    by: Id,
-}
-
-fn group(layer: Layer) -> Group {
-    let mut f = fixture(layer);
-    let mut p = f.app.project().clone();
-    let y = p
-        .add_element(p.elements[&f.work].kind(), layer, "Y", None)
-        .unwrap();
-    let c = p
-        .add_element(
-            if layer == Layer::Oa {
-                Kind::Actor
-            } else {
-                Kind::SystemActor
-            },
-            layer,
-            "C",
-            None,
-        )
-        .unwrap();
-    let yn = p.place(f.diagram, y, xy(140., 600.));
-    let cn = p.place(f.diagram, c, xy(1500., 100.));
-    let d = p.diagrams.get_mut(&f.diagram).unwrap();
-    d.nodes.get_mut(&f.node).unwrap().position = xy(140., 200.);
-    d.nodes
-        .values_mut()
-        .find(|n| n.element == f.b)
-        .unwrap()
-        .position = xy(100., 500.);
-    d.nodes.get_mut(&cn).unwrap().size = Size {
-        width: 600.,
-        height: 900.,
-    };
-    let an = d.nodes.values().find(|n| n.element == f.a).unwrap().id;
-    let ax = p.relate(
-        RelationKind::Allocation,
-        "Reviewed X responsibility",
-        f.a,
-        f.work,
-    );
-    let by = p.relate(
-        RelationKind::Allocation,
-        "Reviewed Y responsibility",
-        f.b,
-        y,
-    );
-    p.relations.get_mut(&ax).unwrap().description = "Keep X provenance".into();
-    p.relations.get_mut(&by).unwrap().description = "Keep Y provenance".into();
-    validate_candidate(&p).unwrap();
-    f.app = App::with_project(p);
-    f.app.active_diagram = Some(f.diagram);
-    f.app.zoom = 1.;
-    f.app.pan = Vector::ZERO;
-    f.app.fit_to_view = false;
-    f.app.reconcile_multiselect();
-    Group {
-        f,
-        y,
-        yn,
-        c,
-        cn,
-        an,
-        ax,
-        by,
-    }
-}
-
-fn choose(app: &mut App, target: SelectionTarget, choice: Choice) {
-    let context = multiselect::context(app.route_context().unwrap());
-    let _ = app.update(Message::DiagramSelection(multiselect::Event::Choose(
-        context, target, choice,
-    )));
-}
-
-fn select(app: &mut App, ids: &[Id]) {
-    for (i, id) in ids.iter().enumerate() {
-        choose(
-            app,
-            SelectionTarget::Placement(*id),
-            if i == 0 { Choice::Replace } else { Choice::Add },
-        );
-    }
-    assert_eq!(
-        app.diagram_selection.as_ref().unwrap().targets(),
-        &ids.iter()
-            .copied()
-            .map(SelectionTarget::Placement)
-            .collect::<Vec<_>>()
-    );
-}
-
-fn selection(
-    app: &App,
-) -> (
-    Vec<SelectionTarget>,
-    Option<SelectionTarget>,
-    Id,
-    Option<Id>,
-) {
-    let s = app.diagram_selection.as_ref().unwrap();
-    (
-        s.targets().to_vec(),
-        s.primary().cloned(),
-        app.selected,
-        app.selected_node,
-    )
-}
-
-fn node_point(app: &App, node: Id) -> Point {
-    let view = projection::project_view(app.project(), app.active_diagram.unwrap());
-    let n = view.nodes.iter().find(|n| n.id == node).unwrap();
-    screen(xy(n.position.x + 40., n.position.y + 35.))
-}
-
-fn input(app: &mut App, state: &mut CanvasState, event: mouse::Event, at: Point) {
-    if let Some(message) = pointer(&canvas(app), state, event, at) {
-        let _ = app.update(message);
-    }
-}
-
-fn begin(app: &mut App, state: &mut CanvasState, from: Point) -> Arc<Press> {
-    input(
-        app,
-        state,
-        mouse::Event::CursorMoved { position: from },
-        from,
-    );
-    let message = pointer(
-        &canvas(app),
-        state,
-        mouse::Event::ButtonPressed(mouse::Button::Left),
-        from,
-    )
-    .unwrap();
-    let Message::WorkDrag(Event::Press(packet)) = &message else {
-        panic!("Allocation placement must enter its captured lifetime: {message:?}");
-    };
-    let packet = packet.clone();
-    let _ = app.update(message);
-    packet
-}
-
-fn move_pointer(app: &mut App, state: &mut CanvasState, to: Point) {
-    input(app, state, mouse::Event::CursorMoved { position: to }, to);
-}
-
-fn release(app: &mut App, state: &mut CanvasState, to: Point) {
-    input(
-        app,
-        state,
-        mouse::Event::ButtonReleased(mouse::Button::Left),
-        to,
-    );
-}
-
-fn exact_history(
-    app: &mut App,
-    before: &Project,
-    source: &oa_core::source_project::SourceBundle,
-    expected: &Project,
-) {
-    assert_eq!(app.project(), expected);
-    let after = app.document.bundle().clone();
-    let reopened =
-        crate::document::Document::from_bundle(after.clone(), Default::default()).unwrap();
-    assert_eq!(reopened.project(), expected);
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.project(), before);
-    assert_eq!(app.document.bundle(), source);
-    assert!(
-        !app.document.can_undo(),
-        "one group drag is one history step"
-    );
-    let _ = app.update(Message::Redo);
-    assert_eq!(app.project(), expected);
-    assert_eq!(app.document.bundle(), &after);
-    assert!(!app.document.can_redo());
-}
-
-#[test]
-fn completed_text_apply_rejects_old_allocation_packets_without_retiring_a_new_drag() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut g = group(layer);
-        select(&mut g.f.app, &[g.f.node, g.yn]);
-        let before = g.f.app.document.snapshot();
-        assert!(!g.f.app.document.can_undo());
-        let from = node_point(&g.f.app, g.f.node);
-        let mut old_canvas = CanvasState::default();
-        let old = begin(&mut g.f.app, &mut old_canvas, from);
-        assert!(g.f.app.allocation_drag.active.is_some());
-        let location = g.f.app.document.compiled().index.declarations[&g.f.work].clone();
-        let original = &before.bundle.files[&location.path];
-        let quoted_name = format!("\"{}\"", g.f.app.project().elements[&g.f.work].name);
-        assert_eq!(original.matches(quoted_name.as_str()).count(), 1);
-        let edited = original.replace(quoted_name.as_str(), "\"Changed through Text\"");
-        let mut expected = before.decoded.project.clone();
-        expected.elements.get_mut(&g.f.work).unwrap().name = "Changed through Text".into();
-        let mut expected_bundle = before.bundle.clone();
-        expected_bundle
-            .files
-            .insert(location.path.clone(), edited.clone());
-
-        let _ = g.f.app.update(Message::Page(Page::Text));
-        assert!(g.f.app.allocation_drag.active.is_none());
-        let _ = g.f.app.update(Message::SourceFile(location.path));
-        let _ =
-            g.f.app
-                .update(Message::SourceEdit(text_editor::Action::SelectAll));
-        let _ =
-            g.f.app
-                .update(Message::SourceEdit(text_editor::Action::Edit(
-                    text_editor::Edit::Paste(Arc::new(edited.clone())),
-                )));
-        assert!(g.f.app.source_dirty());
-        assert_eq!(g.f.app.source_editor.text(), edited);
-        assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-        let _ = g.f.app.update(Message::ApplySource);
-        assert!(!g.f.app.source_dirty(), "{}", g.f.app.status);
-        assert_eq!(g.f.app.project(), &expected);
-        assert_eq!(g.f.app.document.bundle(), &expected_bundle);
-
-        let _ = g.f.app.update(Message::Page(Page::Diagram));
-        assert_eq!(g.f.app.active_diagram, Some(g.f.diagram));
-        select(&mut g.f.app, &[g.f.node, g.yn]);
-        let from = node_point(&g.f.app, g.f.node);
-        let to = from + Vector::new(1400., 0.);
-        let mut current_canvas = CanvasState::default();
-        let current = begin(&mut g.f.app, &mut current_canvas, from);
-        assert_ne!(current.token, old.token);
-        assert_ne!(current.stamp.context, old.stamp.context);
-        move_pointer(&mut g.f.app, &mut current_canvas, to);
-        let preview =
-            g.f.app
-                .allocation_drag
-                .preview
-                .as_ref()
-                .expect(&g.f.app.status)
-                .clone();
-        let Candidate::Assignment(plan) = &preview.candidate else {
-            panic!("the current gesture must be a real group assignment");
-        };
-        assert_eq!(plan.changed_count(), 2);
-        let accepted = g.f.app.document.snapshot();
-        let revision = g.f.app.document.revision();
-        let held = selection(&g.f.app);
-        let selected = g.f.app.multiselect_snapshot().unwrap();
-        let workspace = g.f.app.source_workspace.bundle();
-        let editor = g.f.app.source_editor.text();
-        let camera = (
-            g.f.app.zoom,
-            g.f.app.pan,
-            g.f.app.fit_to_view,
-            g.f.app.canvas_size,
-        );
-        let epochs = (
-            g.f.app.canvas_epoch,
-            g.f.app.camera_epoch,
-            g.f.app.allocation_drag.epoch,
-        );
-        let draft =
-            g.f.app
-                .draft
-                .as_ref()
-                .map(|d| serde_json::to_value(d.recovery_snapshot()).unwrap());
-        let form = g.f.app.behavior.recovery_snapshot();
-        let status = g.f.app.status.clone();
-        let pending_reveal = g.f.app.pending_diagram_reveal.clone();
-        let arrange = g.f.app.allocation_drag.arrange_next;
-        // An idle obsolete press intentionally reports a stale-view explanation.
-        // With a newer real gesture active, both old packets must be fully inert.
-        for event in [
-            Event::Press(old.clone()),
-            Event::Release(old.stamp, old.token, Some(to)),
-        ] {
-            let _ = g.f.app.update(Message::WorkDrag(event));
-            assert!(Arc::ptr_eq(&accepted, &g.f.app.document.snapshot()));
-            assert_eq!(g.f.app.project(), &expected);
-            assert_eq!(g.f.app.document.bundle(), &expected_bundle);
-            assert_eq!(g.f.app.document.revision(), revision);
-            assert_eq!(selection(&g.f.app), held);
-            assert_eq!(g.f.app.multiselect_snapshot(), Some(selected.clone()));
-            assert!(Arc::ptr_eq(
-                &g.f.app.allocation_drag.active.as_ref().unwrap().press,
-                &current
-            ));
-            assert!(Arc::ptr_eq(
-                g.f.app.allocation_drag.preview.as_ref().unwrap(),
-                &preview
-            ));
-            assert_eq!(g.f.app.source_workspace.bundle(), workspace);
-            assert_eq!(g.f.app.source_editor.text(), editor);
-            assert_eq!(
-                (
-                    g.f.app.zoom,
-                    g.f.app.pan,
-                    g.f.app.fit_to_view,
-                    g.f.app.canvas_size
-                ),
-                camera
-            );
-            assert_eq!(
-                (
-                    g.f.app.canvas_epoch,
-                    g.f.app.camera_epoch,
-                    g.f.app.allocation_drag.epoch
-                ),
-                epochs
-            );
-            assert_eq!(
-                g.f.app
-                    .draft
-                    .as_ref()
-                    .map(|d| serde_json::to_value(d.recovery_snapshot()).unwrap()),
-                draft
-            );
-            assert_eq!(g.f.app.behavior.recovery_snapshot(), form);
-            assert_eq!(g.f.app.pending_diagram_reveal, pending_reveal);
-            assert_eq!(g.f.app.allocation_drag.arrange_next, arrange);
-            assert_eq!(g.f.app.status, status);
-            assert!(!g.f.app.source_dirty());
-            assert!(g.f.app.document.can_undo());
-            assert!(!g.f.app.document.can_redo());
-        }
-        // The current gesture remains only a preview. History contains solely
-        // the accepted text rename, never either stale assignment packet.
-        let _ = g.f.app.update(Message::Undo);
-        assert_eq!(g.f.app.project(), &before.decoded.project);
-        assert_eq!(g.f.app.document.bundle(), &before.bundle);
-        assert!(!g.f.app.document.can_undo());
-        assert!(g.f.app.document.can_redo());
-        let _ = g.f.app.update(Message::Redo);
-        assert_eq!(g.f.app.project(), &expected);
-        assert_eq!(g.f.app.document.bundle(), &expected_bundle);
-        assert!(g.f.app.document.can_undo());
-        assert!(!g.f.app.document.can_redo());
-    }
-}
-
-#[test]
-fn group_assignment_split_rebuild_preserves_primary_and_commits_one_complete_candidate() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for anchor_is_primary in [false, true] {
-            let mut g = group(layer);
-            select(&mut g.f.app, &[g.f.node, g.yn]);
-            let held = selection(&g.f.app);
-            let before = g.f.app.project().clone();
-            let source = g.f.app.document.bundle().clone();
-            let anchor = if anchor_is_primary { g.yn } else { g.f.node };
-            let from = node_point(&g.f.app, anchor);
-            let to = from + Vector::new(1400., 0.);
-            let mut state = CanvasState::default();
-            let packet = begin(&mut g.f.app, &mut state, from);
-            assert_eq!(packet.target, SelectionTarget::Placement(anchor));
-            assert_eq!(
-                selection(&g.f.app),
-                held,
-                "member press must not inspect/collapse"
-            );
-            assert_eq!(g.f.app.document.bundle(), &source);
-            move_pointer(&mut g.f.app, &mut state, to);
-            let preview =
-                g.f.app
-                    .allocation_drag
-                    .preview
-                    .as_ref()
-                    .expect(&g.f.app.status);
-            let Candidate::Assignment(plan) = &preview.candidate else {
-                panic!("group must use combined assignment");
-            };
-            assert_eq!(plan.changed_count(), 2);
-            assert_eq!(plan.already_correct_count(), 0);
-            assert_eq!(selection(&g.f.app), held);
-            assert_eq!(g.f.app.project(), &before, "preview is immutable");
-            release(&mut g.f.app, &mut state, to);
-            let mut expected = before.clone();
-            for (relation, work) in [(g.ax, g.f.work), (g.by, g.y)] {
-                expected.relations.get_mut(&relation).unwrap().body = RelationBody::Allocation {
-                    source: g.c,
-                    target: work,
-                };
-            }
-            let d = expected.diagrams.get_mut(&g.f.diagram).unwrap();
-            d.nodes.get_mut(&g.f.node).unwrap().position = xy(1540., 200.);
-            d.nodes.get_mut(&g.yn).unwrap().position = xy(1540., 600.);
-            assert_eq!(selection(&g.f.app), held);
-            exact_history(&mut g.f.app, &before, &source, &expected);
-        }
-    }
-}
-
-#[test]
-fn group_arrange_work_and_performer_anchors_preserve_every_responsibility() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for performer_anchor in [false, true] {
-            let mut g = group(layer);
-            select(&mut g.f.app, &[g.an, g.yn]);
-            let held = selection(&g.f.app);
-            let before = g.f.app.project().clone();
-            let source = g.f.app.document.bundle().clone();
-            let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-            assert!(g.f.app.allocation_drag.arrange_next);
-            let from = node_point(&g.f.app, if performer_anchor { g.an } else { g.yn });
-            let to = from + Vector::new(400., 0.);
-            let mut state = CanvasState::default();
-            let packet = begin(&mut g.f.app, &mut state, from);
-            assert_eq!(packet.mode, Mode::Arrange);
-            assert!(!g.f.app.allocation_drag.arrange_next);
-            assert_eq!(selection(&g.f.app), held);
-            move_pointer(&mut g.f.app, &mut state, to);
-            assert!(
-                matches!(
-                    g.f.app
-                        .allocation_drag
-                        .preview
-                        .as_ref()
-                        .map(|p| &p.candidate),
-                    Some(Candidate::Arrange(_))
-                ),
-                "{}",
-                g.f.app.status
-            );
-            release(&mut g.f.app, &mut state, to);
-            let mut expected = before.clone();
-            let d = expected.diagrams.get_mut(&g.f.diagram).unwrap();
-            d.nodes.get_mut(&g.an).unwrap().position = xy(500., 100.);
-            d.nodes.get_mut(&g.f.node).unwrap().position = xy(540., 200.);
-            d.nodes.get_mut(&g.yn).unwrap().position = xy(540., 600.);
-            assert_eq!(selection(&g.f.app), held);
-            exact_history(&mut g.f.app, &before, &source, &expected);
-        }
-    }
-}
-
-#[test]
-fn unsupported_group_click_collapses_but_threshold_crossing_never_becomes_click() {
-    for performer_anchor in [false, true] {
-        for distance in [0., 3., 3.25] {
-            let mut g = group(Layer::Oa);
-            select(&mut g.f.app, &[g.an, g.f.node]);
-            let held = selection(&g.f.app);
-            let before = g.f.app.document.snapshot();
-            let anchor = if performer_anchor { g.an } else { g.f.node };
-            let from = node_point(&g.f.app, anchor);
-            let mut state = CanvasState::default();
-            begin(&mut g.f.app, &mut state, from);
-            assert_eq!(selection(&g.f.app), held);
-            move_pointer(&mut g.f.app, &mut state, from + Vector::new(distance, 0.));
-            if distance > 3. {
-                assert!(
-                    g.f.app
-                        .allocation_drag
-                        .feedback
-                        .as_ref()
-                        .is_some_and(|f| f.refused)
-                );
-                assert!(g.f.app.allocation_drag.preview.is_none());
-            }
-            move_pointer(&mut g.f.app, &mut state, from);
-            release(&mut g.f.app, &mut state, from);
-            assert!(g.f.app.allocation_drag.active.is_none());
-            assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-            if distance > 3. {
-                assert_eq!(
-                    selection(&g.f.app),
-                    held,
-                    "crossed-and-returned refusal must retain group"
-                );
-            } else {
-                let s = g.f.app.diagram_selection.as_ref().unwrap();
-                assert_eq!(s.targets(), &[SelectionTarget::Placement(anchor)]);
-                assert_eq!(s.primary(), Some(&SelectionTarget::Placement(anchor)));
-            }
-        }
-    }
-}
-
-#[test]
-fn allocation_bare_moves_cannot_bypass_armed_active_or_retired_lifetime() {
-    for (stage, singleton) in (0..3).flat_map(|stage| [(stage, false), (stage, true)]) {
-        let mut g = group(Layer::Oa);
-        let ids = if singleton {
-            vec![g.an]
-        } else {
-            vec![g.an, g.cn]
-        };
-        select(&mut g.f.app, &ids);
-        let snapshot = g.f.app.multiselect_snapshot().unwrap();
-        let held = selection(&g.f.app);
-        let before = g.f.app.document.snapshot();
-        let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-        let mut state = CanvasState::default();
-        let from = node_point(&g.f.app, g.an);
-        if stage > 0 {
-            let press = begin(&mut g.f.app, &mut state, from);
-            if stage == 2 {
-                let _ =
-                    g.f.app
-                        .update(Message::WorkDrag(Event::Cancel(press.token)));
-            }
-        }
-        let epoch = g.f.app.allocation_drag.epoch;
-        let armed = g.f.app.allocation_drag.arrange_next;
-        let token =
-            g.f.app
-                .allocation_drag
-                .active
-                .as_ref()
-                .map(|a| a.press.token);
-        let _ = g.f.app.update(Message::MoveNode(g.an, xy(500., 100.)));
-        let _ =
-            g.f.app
-                .update(Message::DiagramSelection(multiselect::Event::Move(
-                    snapshot,
-                    xy(400., 0.),
-                )));
-        assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-        assert_eq!(selection(&g.f.app), held);
-        assert_eq!(g.f.app.allocation_drag.epoch, epoch);
-        assert_eq!(g.f.app.allocation_drag.arrange_next, armed);
-        assert_eq!(
-            g.f.app
-                .allocation_drag
-                .active
-                .as_ref()
-                .map(|a| a.press.token),
-            token
-        );
-    }
-    // A fresh ordinary performer gesture still uses the existing layout policy.
-    // C's right edge leaves the viewport: explicit Arrange's header gate must not
-    // accidentally become a new restriction on ordinary performer movement.
-    let mut g = group(Layer::Oa);
-    select(&mut g.f.app, &[g.an, g.cn]);
-    let held = selection(&g.f.app);
-    let before = g.f.app.project().clone();
-    let source = g.f.app.document.bundle().clone();
-    let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-    let from = node_point(&g.f.app, g.an);
-    let mut state = CanvasState::default();
-    let old = begin(&mut g.f.app, &mut state, from);
-    let _ = g.f.app.update(Message::WorkDrag(Event::Cancel(old.token)));
-    let mut state = CanvasState::default();
-    let fresh = begin(&mut g.f.app, &mut state, from);
-    assert_eq!(fresh.mode, Mode::Assign);
-    let to = from + Vector::new(300., 0.);
-    move_pointer(&mut g.f.app, &mut state, to);
-    assert!(
-        matches!(
-            g.f.app
-                .allocation_drag
-                .preview
-                .as_ref()
-                .map(|p| &p.candidate),
-            Some(Candidate::Performers(_))
-        ),
-        "{}",
-        g.f.app.status
-    );
-    release(&mut g.f.app, &mut state, to);
-    let mut expected = before.clone();
-    let d = expected.diagrams.get_mut(&g.f.diagram).unwrap();
-    d.nodes.get_mut(&g.an).unwrap().position = xy(400., 100.);
-    d.nodes.get_mut(&g.f.node).unwrap().position = xy(440., 200.);
-    d.nodes.get_mut(&g.cn).unwrap().position = xy(1800., 100.);
-    assert_eq!(selection(&g.f.app), held);
-    exact_history(&mut g.f.app, &before, &source, &expected);
-}
-
-#[test]
-fn idle_group_press_rejects_selection_generation_aba_with_unchanged_other_stamps() {
-    for membership_aba in [false, true] {
-        let mut g = group(Layer::Oa);
-        select(&mut g.f.app, &[g.f.node, g.yn]);
-        let old = press(&g.f);
-        let before = g.f.app.document.snapshot();
-        let held = selection(&g.f.app);
-        let epoch = g.f.app.allocation_drag.epoch;
-        // Deliberately isolate selection generation from App message retirement.
-        // Final selection/primary/context/Document values are unchanged; this
-        // exercises the snapshot boundary, not an ordinary user-input sequence.
-        let s = g.f.app.diagram_selection.as_mut().unwrap();
-        if membership_aba {
-            assert!(s.remove(&SelectionTarget::Placement(g.yn)));
-            assert!(s.add(SelectionTarget::Placement(g.yn), |_| true));
-        } else {
-            assert!(s.set_primary(&SelectionTarget::Placement(g.f.node)));
-            assert!(s.set_primary(&SelectionTarget::Placement(g.yn)));
-        }
-        assert_eq!(selection(&g.f.app), held);
-        assert_eq!(g.f.app.allocation_drag.epoch, epoch);
-        assert_eq!(g.f.app.route_context(), Some(old.stamp.context));
-        let _ = g.f.app.update(Message::WorkDrag(Event::Press(old.clone())));
-        assert!(
-            g.f.app.allocation_drag.active.is_none(),
-            "generation-only stale selection must not acquire input"
-        );
-        let _ = g.f.app.update(Message::WorkDrag(Event::Release(
-            old.stamp,
-            old.token,
-            Some(start(&g.f)),
-        )));
-        assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-        assert_eq!(selection(&g.f.app), held);
-    }
-}
-
-#[test]
-fn group_selection_aba_and_old_press_cannot_retire_a_new_token() {
-    let mut g = group(Layer::Oa);
-    select(&mut g.f.app, &[g.f.node, g.yn]);
-    let old = press(&g.f);
-    choose(
-        &mut g.f.app,
-        SelectionTarget::Placement(g.f.node),
-        Choice::Inspect,
-    );
-    choose(
-        &mut g.f.app,
-        SelectionTarget::Placement(g.yn),
-        Choice::Inspect,
-    );
-    let before = g.f.app.document.snapshot();
-    let from = node_point(&g.f.app, g.f.node);
-    let mut state = CanvasState::default();
-    let fresh = begin(&mut g.f.app, &mut state, from);
-    let held = selection(&g.f.app);
-    let epoch = g.f.app.allocation_drag.epoch;
-    let _ = g.f.app.update(Message::WorkDrag(Event::Press(old.clone())));
-    let _ = g.f.app.update(Message::WorkDrag(Event::Release(
-        old.stamp,
-        old.token,
-        Some(from + Vector::new(1400., 0.)),
-    )));
-    assert_eq!(
-        g.f.app
-            .allocation_drag
-            .active
-            .as_ref()
-            .map(|a| a.press.token),
-        Some(fresh.token)
-    );
-    assert_eq!(g.f.app.allocation_drag.epoch, epoch);
-    assert_eq!(selection(&g.f.app), held);
-    assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-    release(&mut g.f.app, &mut state, from);
-}
-
-fn unassign(g: &mut Group, inside_c: bool) {
-    let mut project = g.f.app.project().clone();
-    project.relations.remove(&g.ax);
-    project.relations.remove(&g.by);
-    if inside_c {
-        let d = project.diagrams.get_mut(&g.f.diagram).unwrap();
-        // These unassigned cards overlap an unrelated empty performer at the
-        // same depth. Paint C first so the intended work press is visible and
-        // independent of random UUID ordering; no semantic containment exists.
-        let mut target = d.nodes.remove(&g.cn).unwrap();
-        g.cn = Id::from_u128(1);
-        target.id = g.cn;
-        assert!(d.nodes.insert(g.cn, target).is_none());
-        d.nodes.get_mut(&g.f.node).unwrap().position = xy(1540., 200.);
-        d.nodes.get_mut(&g.yn).unwrap().position = xy(1540., 600.);
-    }
-    g.f.app = App::with_project(project);
-    g.f.app.active_diagram = Some(g.f.diagram);
-    g.f.app.zoom = 1.;
-    g.f.app.pan = Vector::ZERO;
-    g.f.app.fit_to_view = false;
-    g.f.app.reconcile_multiselect();
-}
-
-fn c_allocations(expected: &mut Project, g: &Group, ids: &BTreeMap<Id, Id>) {
-    for (work, name, alias) in [
-        (g.f.work, "C performs Work", "c_performs_work"),
-        (g.y, "C performs Y", "c_performs_y"),
-    ] {
-        expected.relations.insert(
-            ids[&work],
-            Relation {
-                id: ids[&work],
-                alias: alias.into(),
-                name: name.into(),
-                description: String::new(),
-                body: RelationBody::Allocation {
-                    source: g.c,
-                    target: work,
-                },
-            },
-        );
-    }
-}
-
-#[test]
-fn group_out_and_back_assigns_at_zero_delta_then_true_noop_preserves_redo() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut g = group(layer);
-        unassign(&mut g, true);
-        select(&mut g.f.app, &[g.f.node, g.yn]);
-        let held = selection(&g.f.app);
-        let before = g.f.app.project().clone();
-        let source = g.f.app.document.bundle().clone();
-        let from = node_point(&g.f.app, g.f.node);
-        let mut state = CanvasState::default();
-        let press = begin(&mut g.f.app, &mut state, from);
-        assert_eq!(press.target, SelectionTarget::Placement(g.f.node));
-        assert_eq!(selection(&g.f.app), held);
-        move_pointer(&mut g.f.app, &mut state, from + Vector::new(4., 0.));
-        let preview =
-            g.f.app
-                .allocation_drag
-                .preview
-                .as_ref()
-                .expect(&g.f.app.status);
-        assert_eq!(preview.placement.delta, xy(0., 0.));
-        let Candidate::Assignment(candidate) = &preview.candidate else {
-            panic!("exact work group must preview assignment");
-        };
-        assert_eq!(candidate.destination(), plan::Destination::Performer(g.c));
-        assert_eq!(candidate.changed_count(), 2);
-        let ids: BTreeMap<_, _> = preview
-            .project()
-            .relations
-            .values()
-            .filter(|r| r.kind() == RelationKind::Allocation)
-            .map(|r| (r.target(), r.id))
-            .collect();
-        assert_eq!(ids.len(), 2);
-        move_pointer(&mut g.f.app, &mut state, from);
-        release(&mut g.f.app, &mut state, from);
-        let mut expected = before.clone();
-        c_allocations(&mut expected, &g, &ids);
-        assert_eq!(selection(&g.f.app), held);
-        exact_history(&mut g.f.app, &before, &source, &expected);
-        g.f.app
-            .document
-            .execute(Command::Describe(g.y, "Future rationale".into()))
-            .unwrap();
-        g.f.app.sync();
-        let future = g.f.app.document.bundle().clone();
-        let _ = g.f.app.update(Message::Undo);
-        assert!(g.f.app.document.can_undo() && g.f.app.document.can_redo());
-        let snapshot = g.f.app.document.snapshot();
-        let revision = g.f.app.document.revision();
-        let held = selection(&g.f.app);
-        let from = node_point(&g.f.app, g.f.node);
-        let mut state = CanvasState::default();
-        begin(&mut g.f.app, &mut state, from);
-        move_pointer(&mut g.f.app, &mut state, from + Vector::new(4., 0.));
-        move_pointer(&mut g.f.app, &mut state, from);
-        release(&mut g.f.app, &mut state, from);
-        assert!(
-            Arc::ptr_eq(&snapshot, &g.f.app.document.snapshot()),
-            "{}",
-            g.f.app.status
-        );
-        assert_eq!(g.f.app.document.revision(), revision);
-        assert_eq!(selection(&g.f.app), held);
-        assert!(g.f.app.document.can_undo() && g.f.app.document.can_redo());
-        let _ = g.f.app.update(Message::Redo);
-        assert_eq!(g.f.app.document.bundle(), &future);
-    }
-}
-
-#[test]
-fn group_source_refusal_retains_primary_source_and_both_history_paths() {
-    let mut g = group(Layer::Oa);
-    unassign(&mut g, false);
-    let source = g.f.app.document.bundle().clone();
-    let mut limits = oa_core::source_project::ProjectLimits::default();
-    limits.model.max_source_bytes = source.files.values().map(String::len).sum::<usize>() + 128;
-    g.f.app.document = crate::document::Document::from_bundle(source, limits).unwrap();
-    g.f.app
-        .document
-        .execute(Command::Describe(g.f.work, "Reviewed".into()))
-        .unwrap();
-    g.f.app
-        .document
-        .execute(Command::Rename(g.y, "Future Y".into()))
-        .unwrap();
-    let future = g.f.app.document.bundle().clone();
-    assert!(g.f.app.document.undo());
-    g.f.app.sync();
-    g.f.app.reconcile_multiselect();
-    select(&mut g.f.app, &[g.f.node, g.yn]);
-    let held = selection(&g.f.app);
-    let before = g.f.app.document.snapshot();
-    let source = g.f.app.document.bundle().clone();
-    let revision = g.f.app.document.revision();
-    assert!(g.f.app.document.can_undo() && g.f.app.document.can_redo());
-    let from = node_point(&g.f.app, g.f.node);
-    let to = from + Vector::new(1400., 0.);
-    let mut state = CanvasState::default();
-    begin(&mut g.f.app, &mut state, from);
-    move_pointer(&mut g.f.app, &mut state, to);
-    assert!(
-        g.f.app.allocation_drag.preview.is_some(),
-        "geometry and semantics pass before source refusal: {}",
-        g.f.app.status
-    );
-    release(&mut g.f.app, &mut state, to);
-    assert!(g.f.app.status.contains("retry"), "{}", g.f.app.status);
-    assert!(g.f.app.allocation_drag.active.is_none());
-    assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-    assert_eq!(g.f.app.document.bundle(), &source);
-    assert_eq!(g.f.app.document.revision(), revision);
-    assert_eq!(selection(&g.f.app), held);
-    assert!(g.f.app.document.can_undo() && g.f.app.document.can_redo());
-    let _ = g.f.app.update(Message::Redo);
-    assert_eq!(g.f.app.document.bundle(), &future);
-    let _ = g.f.app.update(Message::Undo);
-    assert_eq!(g.f.app.document.bundle(), &source);
-}
-
-#[test]
-fn ordinary_off_grid_performer_out_and_back_is_noop_with_redo() {
-    for singleton in [false, true] {
-        let mut g = group(Layer::Oa);
-        let mut project = g.f.app.project().clone();
-        project
-            .diagrams
-            .get_mut(&g.f.diagram)
-            .unwrap()
-            .nodes
-            .get_mut(&g.an)
-            .unwrap()
-            .position = xy(103., 107.);
-        g.f.app = App::with_project(project);
-        g.f.app.active_diagram = Some(g.f.diagram);
-        g.f.app.zoom = 1.;
-        g.f.app.pan = Vector::ZERO;
-        g.f.app.fit_to_view = false;
-        g.f.app
-            .document
-            .execute(Command::Describe(g.f.work, "Reviewed".into()))
-            .unwrap();
-        g.f.app
-            .document
-            .execute(Command::Describe(g.y, "Future".into()))
-            .unwrap();
-        let future = g.f.app.document.bundle().clone();
-        assert!(g.f.app.document.undo());
-        g.f.app.sync();
-        g.f.app.reconcile_multiselect();
-        select(
-            &mut g.f.app,
-            &if singleton {
-                vec![g.an]
-            } else {
-                vec![g.an, g.cn]
-            },
-        );
-        let held = selection(&g.f.app);
-        let before = g.f.app.document.snapshot();
-        let source = g.f.app.document.bundle().clone();
-        let revision = g.f.app.document.revision();
-        let from = node_point(&g.f.app, g.an);
-        let mut state = CanvasState::default();
-        begin(&mut g.f.app, &mut state, from);
-        move_pointer(&mut g.f.app, &mut state, from + Vector::new(20., 0.));
-        assert!(
-            g.f.app.allocation_drag.preview.is_some(),
-            "{}",
-            g.f.app.status
-        );
-        move_pointer(&mut g.f.app, &mut state, from);
-        assert_eq!(
-            g.f.app
-                .allocation_drag
-                .preview
-                .as_ref()
-                .unwrap()
-                .placement
-                .delta,
-            xy(0., 0.)
-        );
-        release(&mut g.f.app, &mut state, from);
-        assert!(Arc::ptr_eq(&before, &g.f.app.document.snapshot()));
-        assert_eq!(g.f.app.document.bundle(), &source);
-        assert_eq!(g.f.app.document.revision(), revision);
-        assert_eq!(selection(&g.f.app), held);
-        assert!(g.f.app.document.can_undo() && g.f.app.document.can_redo());
-        let _ = g.f.app.update(Message::Redo);
-        assert_eq!(g.f.app.document.bundle(), &future);
-    }
-}

crates/oa-desktop/src/app/allocation_drag_tests/group/connection_lifetime.rs

@@ -1,292 +0,0 @@
-//! Delayed captured drawing packets must not retire a newer Allocation owner.
-use super::*;
-use crate::connection_edit::Event as ConnectionEvent;
-use crate::connection_tool::Tool;
-
-fn drawing_tool(layer: Layer) -> Tool {
-    match layer {
-        Layer::Oa => Tool::Interaction,
-        Layer::Sa => Tool::FunctionalExchange,
-    }
-}
-
-fn drawing_source(g: &mut Group, layer: Layer) -> crate::route_edit::Context {
-    let _ =
-        g.f.app
-            .update(Message::Connection(ConnectionEvent::Choose(Some(
-                drawing_tool(layer),
-            ))));
-    let context = g.f.app.route_context().unwrap();
-    let _ =
-        g.f.app
-            .update(Message::Connection(ConnectionEvent::Endpoint(
-                context, g.f.work,
-            )));
-    let session = g.f.app.connection.as_ref().unwrap();
-    assert_eq!(session.context, context);
-    assert_eq!(session.source, Some(g.f.work));
-    assert!(session.candidates.contains(&g.y));
-    assert_eq!(g.f.app.route_context(), Some(context));
-    context
-}
-
-fn assert_captured_noop(app: &mut App, captured: crate::route_edit::Context, target: Id) {
-    for event in [
-        ConnectionEvent::Endpoint(captured, target),
-        ConnectionEvent::Restart(captured),
-    ] {
-        assert_connection_noop(app, event);
-    }
-}
-
-fn assert_connection_noop(app: &mut App, event: ConnectionEvent) {
-    let document = app.document.snapshot();
-    let selected = selection(app);
-    let context = app.route_context();
-    let camera = (app.pan, app.zoom, app.canvas_epoch, app.camera_epoch);
-    let ownership = (app.allocation_drag.epoch, app.allocation_drag.arrange_next);
-    let active = app
-        .allocation_drag
-        .active
-        .as_ref()
-        .map(|a| (a.press.clone(), a.crossed, a.cache.len()));
-    let preview = app.allocation_drag.preview.as_ref().map(|p| {
-        (
-            p.token,
-            p.placement.diagram.clone(),
-            p.placement.delta,
-            p.project().clone(),
-            p.routed.clone(),
-        )
-    });
-    let feedback = app.allocation_drag.feedback.as_ref().map(|f| {
-        (
-            f.press.token,
-            f.text.clone(),
-            f.refused,
-            f.targets.clone(),
-            f.inspection_targets.clone(),
-        )
-    });
-    let connection = |app: &App| {
-        app.connection
-            .as_ref()
-            .map(|s| (s.context, s.tool, s.source, s.candidates.clone()))
-    };
-    let session = connection(app);
-    let interaction = app.source_symbols.interaction;
-    let status = app.status.clone();
-    let _ = app.update(Message::Connection(event));
-    assert_eq!(selection(app), selected);
-    assert_eq!(app.route_context(), context);
-    assert_eq!(
-        (app.pan, app.zoom, app.canvas_epoch, app.camera_epoch),
-        camera
-    );
-    assert_eq!(
-        (app.allocation_drag.epoch, app.allocation_drag.arrange_next),
-        ownership,
-        "rejected drawing packet must not retire the newer input owner"
-    );
-    match (active, app.allocation_drag.active.as_ref()) {
-        (Some((press, crossed, cached)), Some(current)) => {
-            assert!(Arc::ptr_eq(&press, &current.press));
-            assert_eq!((current.crossed, current.cache.len()), (crossed, cached));
-        }
-        (None, None) => {}
-        _ => panic!("rejected drawing packet changed the active Allocation token"),
-    }
-    match (preview, app.allocation_drag.preview.as_ref()) {
-        (Some((token, diagram, delta, project, routed)), Some(current)) => {
-            assert_eq!(current.token, token);
-            assert_eq!(current.placement.diagram, diagram);
-            assert_eq!(current.placement.delta, delta);
-            assert_eq!(current.project(), &project);
-            assert!(Arc::ptr_eq(&current.routed, &routed));
-        }
-        (None, None) => {}
-        _ => panic!("rejected drawing packet changed the Allocation preview"),
-    }
-    assert_eq!(
-        app.allocation_drag.feedback.as_ref().map(|f| (
-            f.press.token,
-            f.text.clone(),
-            f.refused,
-            f.targets.clone(),
-            f.inspection_targets.clone(),
-        )),
-        feedback
-    );
-    assert_eq!(connection(app), session);
-    assert_eq!(app.source_symbols.interaction, interaction);
-    assert_eq!(app.status, status);
-    assert!(Arc::ptr_eq(&document, &app.document.snapshot()));
-    assert_eq!(app.source_workspace.bundle(), document.bundle);
-}
-
-#[test]
-fn captured_connection_after_cancel_preserves_arrange_arm_and_live_group() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        let mut g = group(layer);
-        let old = drawing_source(&mut g, layer);
-        let _ = g.f.app.update(Message::Escape);
-        assert!(g.f.app.connection.is_none());
-        select(&mut g.f.app, &[g.an, g.yn]);
-        let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-        assert!(g.f.app.allocation_drag.arrange_next);
-        let current = g.f.app.route_context().unwrap();
-        assert_captured_noop(&mut g.f.app, old, g.y);
-        // Matching context with no session isolates the missing-owner guard.
-        assert_captured_noop(&mut g.f.app, current, g.y);
-
-        let before = g.f.app.project().clone();
-        let source = g.f.app.document.bundle().clone();
-        let held = selection(&g.f.app);
-        let from = node_point(&g.f.app, g.an);
-        let to = from + Vector::new(400., 0.);
-        let mut state = CanvasState::default();
-        let press = begin(&mut g.f.app, &mut state, from);
-        assert_eq!(press.mode, Mode::Arrange);
-        assert!(!g.f.app.allocation_drag.arrange_next);
-        move_pointer(&mut g.f.app, &mut state, to);
-        assert!(matches!(
-            g.f.app
-                .allocation_drag
-                .preview
-                .as_ref()
-                .map(|p| &p.candidate),
-            Some(Candidate::Arrange(_))
-        ));
-        let current = g.f.app.route_context().unwrap();
-        assert_captured_noop(&mut g.f.app, old, g.y);
-        assert_captured_noop(&mut g.f.app, current, g.y);
-        release(&mut g.f.app, &mut state, to);
-        let mut expected = before.clone();
-        let diagram = expected.diagrams.get_mut(&g.f.diagram).unwrap();
-        diagram.nodes.get_mut(&g.an).unwrap().position = xy(500., 100.);
-        diagram.nodes.get_mut(&g.f.node).unwrap().position = xy(540., 200.);
-        diagram.nodes.get_mut(&g.yn).unwrap().position = xy(540., 600.);
-        assert_eq!(selection(&g.f.app), held);
-        exact_history(&mut g.f.app, &before, &source, &expected);
-    }
-}
-
-#[test]
-fn captured_connection_context_mismatches_preserve_the_current_session() {
-    let mut g = group(Layer::Oa);
-    let current = drawing_source(&mut g, Layer::Oa);
-    // Session and current context agree: each old captured field is the sole
-    // invalid relationship, not hidden behind a missing session.
-    for captured in [
-        crate::route_edit::Context {
-            document: Id::new_v4(),
-            ..current
-        },
-        crate::route_edit::Context {
-            diagram: Id::new_v4(),
-            ..current
-        },
-        crate::route_edit::Context {
-            revision: current.revision + 1,
-            ..current
-        },
-        crate::route_edit::Context {
-            epoch: current.epoch + 1,
-            ..current
-        },
-    ] {
-        assert_eq!(g.f.app.connection.as_ref().unwrap().context, current);
-        assert_captured_noop(&mut g.f.app, captured, g.y);
-    }
-    // Captured/session contexts agree, but the rendered view has advanced.
-    // This isolates the live-route predicate from session ownership.
-    g.f.app.canvas_epoch += 1;
-    assert_ne!(g.f.app.route_context(), Some(current));
-    assert_eq!(g.f.app.connection.as_ref().unwrap().context, current);
-    assert_captured_noop(&mut g.f.app, current, g.y);
-    g.f.app.canvas_epoch = current.epoch;
-
-    // Conversely, incoming/current contexts agree. Retain obsolete session
-    // metadata explicitly to isolate the session-context admission branch.
-    g.f.app.connection.as_mut().unwrap().context.epoch += 1;
-    assert_eq!(g.f.app.route_context(), Some(current));
-    assert_captured_noop(&mut g.f.app, current, g.y);
-}
-
-#[test]
-fn captured_connection_current_restart_and_pair_commit_after_tool_boundary() {
-    for begin_tool in [false, true] {
-        let mut g = group(Layer::Oa);
-        select(&mut g.f.app, &[g.an, g.yn]);
-        let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-        let from = node_point(&g.f.app, g.an);
-        let mut state = CanvasState::default();
-        begin(&mut g.f.app, &mut state, from);
-        move_pointer(&mut g.f.app, &mut state, from + Vector::new(400., 0.));
-        assert!(g.f.app.allocation_drag.preview.is_some());
-        let before = g.f.app.project().clone();
-        let source = g.f.app.document.bundle().clone();
-        let epoch = g.f.app.allocation_drag.epoch;
-        let event = if begin_tool {
-            ConnectionEvent::Begin(Tool::Interaction, g.f.work)
-        } else {
-            ConnectionEvent::Choose(Some(Tool::Interaction))
-        };
-        let _ = g.f.app.update(Message::Connection(event));
-        assert!(g.f.app.allocation_drag.epoch > epoch);
-        assert!(g.f.app.allocation_drag.active.is_none());
-        assert!(g.f.app.allocation_drag.preview.is_none());
-        assert!(!g.f.app.allocation_drag.arrange_next);
-        let context = g.f.app.route_context().unwrap();
-        if !begin_tool {
-            let _ =
-                g.f.app
-                    .update(Message::Connection(ConnectionEvent::Endpoint(
-                        context, g.f.work,
-                    )));
-        }
-        assert_eq!(g.f.app.connection.as_ref().unwrap().source, Some(g.f.work));
-        assert!(
-            g.f.app
-                .connection
-                .as_ref()
-                .unwrap()
-                .candidates
-                .contains(&g.y)
-        );
-        let document = g.f.app.document.snapshot();
-        let _ =
-            g.f.app
-                .update(Message::Connection(ConnectionEvent::Restart(context)));
-        let context = g.f.app.route_context().unwrap();
-        let restarted = g.f.app.connection.as_ref().unwrap();
-        assert_eq!(restarted.context, context);
-        assert_eq!(restarted.tool, Tool::Interaction);
-        assert_eq!(restarted.source, None);
-        assert!(restarted.candidates.contains(&g.f.work));
-        assert!(Arc::ptr_eq(&document, &g.f.app.document.snapshot()));
-        let _ =
-            g.f.app
-                .update(Message::Connection(ConnectionEvent::Endpoint(
-                    context, g.f.work,
-                )));
-        assert_eq!(g.f.app.connection.as_ref().unwrap().source, Some(g.f.work));
-        let revision = g.f.app.document.revision();
-        let _ =
-            g.f.app
-                .update(Message::Connection(ConnectionEvent::Endpoint(context, g.y)));
-        assert!(g.f.app.connection.is_none());
-        assert_eq!(g.f.app.document.revision(), revision + 1);
-        let relation = &g.f.app.project().relations[&g.f.app.selected];
-        assert_eq!(relation.kind(), RelationKind::Interaction);
-        assert_eq!((relation.source(), relation.target()), (g.f.work, g.y));
-        let mut expected = before.clone();
-        assert!(
-            expected
-                .relations
-                .insert(relation.id, relation.clone())
-                .is_none()
-        );
-        exact_history(&mut g.f.app, &before, &source, &expected);
-    }
-}

crates/oa-desktop/src/app/allocation_drag_tests/group/route_lifetime.rs

@@ -1,274 +0,0 @@
-//! Captured route commits cannot retire a newer Allocation input owner.
-use super::*;
-use crate::route_edit::{Context, Event as RouteEvent};
-
-fn routed_group() -> (Group, Id) {
-    let mut g = group(Layer::Oa);
-    let mut project = g.f.app.project().clone();
-    let edge = project.relate(
-        RelationKind::Interaction,
-        "Reviewed exchange",
-        g.f.work,
-        g.y,
-    );
-    project
-        .diagrams
-        .get_mut(&g.f.diagram)
-        .unwrap()
-        .routes
-        .push(EdgeRoute {
-            edge,
-            waypoints: vec![xy(700., 400.)],
-            label: Some(EdgeLabel {
-                fraction: 0.4,
-                offset: xy(5., 10.),
-            }),
-            source_attachment: None,
-            target_attachment: Some(EdgeAttachment {
-                side: PortAnchorSide::Left,
-                offset: 0.6,
-            }),
-        });
-    validate_candidate(&project).unwrap();
-    g.f.app = App::with_project(project);
-    g.f.app.active_diagram = Some(g.f.diagram);
-    g.f.app.zoom = 1.;
-    g.f.app.pan = Vector::ZERO;
-    g.f.app.fit_to_view = false;
-    choose(&mut g.f.app, SelectionTarget::Edge(edge), Choice::Replace);
-    assert_eq!(g.f.app.selected, edge);
-    let view = projection::project_view(g.f.app.project(), g.f.diagram);
-    assert!(view.edges.iter().any(|e| e.id == edge));
-    assert_eq!(
-        crate::route_edit::attachment_node(
-            g.f.app.project(),
-            &g.f.app.project().diagrams[&g.f.diagram],
-            &view,
-            edge,
-            EdgeEnd::Source,
-        )
-        .unwrap()
-        .id,
-        g.f.node
-    );
-    (g, edge)
-}
-
-fn packet(g: &Group, edge: Id, captured: Context, attachment: bool) -> RouteEvent {
-    let mut route =
-        crate::route_edit::stored_route(&g.f.app.project().diagrams[&g.f.diagram], edge);
-    if attachment {
-        route.source_attachment = Some(EdgeAttachment {
-            side: PortAnchorSide::Top,
-            offset: 0.25,
-        });
-        RouteEvent::CommitAttachment(captured, route, EdgeEnd::Source, g.f.node)
-    } else {
-        route.waypoints[0] = xy(750., 450.);
-        RouteEvent::Commit(captured, route, Some(0))
-    }
-}
-
-fn assert_route_noop(app: &mut App, event: RouteEvent) {
-    let document = app.document.snapshot();
-    let selected = selection(app);
-    let context = app.route_context();
-    let camera = (app.pan, app.zoom, app.canvas_epoch, app.camera_epoch);
-    let ownership = (app.allocation_drag.epoch, app.allocation_drag.arrange_next);
-    let press = app.allocation_drag.active.as_ref().map(|a| a.press.clone());
-    let preview = app.allocation_drag.preview.clone();
-    let feedback = app.allocation_drag.feedback.as_ref().map(|f| {
-        (
-            f.press.token,
-            f.text.clone(),
-            f.refused,
-            f.targets.clone(),
-            f.inspection_targets.clone(),
-        )
-    });
-    let handles = (app.selected_bend, app.selected_attachment);
-    let interaction = app.source_symbols.interaction;
-    let status = app.status.clone();
-    let _ = app.update(Message::Route(event));
-    assert_eq!(selection(app), selected);
-    assert_eq!(app.route_context(), context);
-    assert_eq!(
-        (app.pan, app.zoom, app.canvas_epoch, app.camera_epoch),
-        camera
-    );
-    assert_eq!(
-        (app.allocation_drag.epoch, app.allocation_drag.arrange_next),
-        ownership
-    );
-    match (press, app.allocation_drag.active.as_ref()) {
-        (Some(before), Some(after)) => assert!(Arc::ptr_eq(&before, &after.press)),
-        (None, None) => {}
-        _ => panic!("stale route packet changed the active Allocation token"),
-    }
-    match (preview, app.allocation_drag.preview.as_ref()) {
-        (Some(before), Some(after)) => assert!(Arc::ptr_eq(&before, after)),
-        (None, None) => {}
-        _ => panic!("stale route packet changed the Allocation preview"),
-    }
-    assert_eq!(
-        app.allocation_drag.feedback.as_ref().map(|f| (
-            f.press.token,
-            f.text.clone(),
-            f.refused,
-            f.targets.clone(),
-            f.inspection_targets.clone(),
-        )),
-        feedback
-    );
-    assert_eq!((app.selected_bend, app.selected_attachment), handles);
-    assert_eq!(app.source_symbols.interaction, interaction);
-    assert_eq!(app.status, status);
-    assert!(Arc::ptr_eq(&document, &app.document.snapshot()));
-    assert_eq!(app.source_workspace.bundle(), document.bundle);
-}
-
-fn stale_route_preserves_new_group(attachment: bool, escape: bool) {
-    let (mut g, edge) = routed_group();
-    let old = g.f.app.route_context().unwrap();
-    let delayed = packet(&g, edge, old, attachment);
-    if escape {
-        let _ = g.f.app.update(Message::Escape);
-        assert_ne!(g.f.app.route_context(), Some(old));
-    }
-    select(&mut g.f.app, &[g.an, g.yn]);
-    let _ = g.f.app.update(Message::WorkDrag(Event::ArrangeNext));
-    assert!(g.f.app.allocation_drag.arrange_next);
-    if !escape {
-        assert_eq!(g.f.app.route_context(), Some(old));
-        assert_ne!(g.f.app.selected, edge);
-    }
-    assert_route_noop(&mut g.f.app, delayed.clone());
-    let before = g.f.app.project().clone();
-    let source = g.f.app.document.bundle().clone();
-    let selected = selection(&g.f.app);
-    let from = node_point(&g.f.app, g.an);
-    let to = from + Vector::new(400., 0.);
-    let mut state = CanvasState::default();
-    let press = begin(&mut g.f.app, &mut state, from);
-    assert_eq!(press.mode, Mode::Arrange);
-    move_pointer(&mut g.f.app, &mut state, to);
-    assert!(g.f.app.allocation_drag.preview.is_some());
-    if !escape {
-        assert_eq!(g.f.app.route_context(), Some(old));
-        assert_ne!(g.f.app.selected, edge);
-    }
-    assert_route_noop(&mut g.f.app, delayed);
-    release(&mut g.f.app, &mut state, to);
-    let mut expected = before.clone();
-    let diagram = expected.diagrams.get_mut(&g.f.diagram).unwrap();
-    diagram.nodes.get_mut(&g.an).unwrap().position = xy(500., 100.);
-    diagram.nodes.get_mut(&g.f.node).unwrap().position = xy(540., 200.);
-    diagram.nodes.get_mut(&g.yn).unwrap().position = xy(540., 600.);
-    // Both endpoint placements move by (400, 0); the saved pin follows once,
-    // while label offset and endpoint attachment settings stay unchanged.
-    diagram
-        .routes
-        .iter_mut()
-        .find(|r| r.edge == edge)
-        .unwrap()
-        .waypoints = vec![xy(1100., 400.)];
-    assert_eq!(selection(&g.f.app), selected);
-    exact_history(&mut g.f.app, &before, &source, &expected);
-}
-
-#[test]
-fn stale_route_commit_preserves_arrange_arm_and_live_group() {
-    stale_route_preserves_new_group(false, true);
-}
-
-#[test]
-fn stale_route_attachment_preserves_arrange_arm_and_live_group() {
-    stale_route_preserves_new_group(true, true);
-}
-
-#[test]
-fn same_context_route_commit_after_selection_preserves_arrange_arm_and_live_group() {
-    stale_route_preserves_new_group(false, false);
-}
-
-#[test]
-fn same_context_route_attachment_after_selection_preserves_arrange_arm_and_live_group() {
-    stale_route_preserves_new_group(true, false);
-}
-
-#[test]
-fn captured_route_context_fields_independently_reject_before_retirement() {
-    for attachment in [false, true] {
-        let (mut g, edge) = routed_group();
-        let current = g.f.app.route_context().unwrap();
-        // The selected edge and route payload are valid. Each capture mismatch
-        // is isolated; no nonexistent route session can mask admission.
-        for captured in [
-            Context {
-                document: Id::new_v4(),
-                ..current
-            },
-            Context {
-                diagram: Id::new_v4(),
-                ..current
-            },
-            Context {
-                revision: current.revision + 1,
-                ..current
-            },
-            Context {
-                epoch: current.epoch + 1,
-                ..current
-            },
-        ] {
-            let event = packet(&g, edge, captured, attachment);
-            assert_route_noop(&mut g.f.app, event);
-        }
-        // Hold the captured packet fixed and advance the live context instead.
-        let event = packet(&g, edge, current, attachment);
-        g.f.app.canvas_epoch += 1;
-        assert_route_noop(&mut g.f.app, event.clone());
-        g.f.app.canvas_epoch = current.epoch;
-        g.f.app.active_diagram = None;
-        assert_route_noop(&mut g.f.app, event);
-    }
-}
-
-#[test]
-fn current_route_commits_without_session_preserve_exact_route_history() {
-    for attachment in [false, true] {
-        let (mut g, edge) = routed_group();
-        let current = g.f.app.route_context().unwrap();
-        let event = packet(&g, edge, current, attachment);
-        let before = g.f.app.project().clone();
-        let source = g.f.app.document.bundle().clone();
-        let revision = g.f.app.document.revision();
-        assert!(g.f.app.connection.is_none());
-        assert!(g.f.app.selected_attachment.is_none());
-        let _ = g.f.app.update(Message::Route(event));
-        assert_eq!(g.f.app.document.revision(), revision + 1);
-        assert_eq!(g.f.app.selected, edge);
-        assert_eq!(
-            g.f.app.selected_bend,
-            if attachment { None } else { Some((edge, 0)) }
-        );
-        let mut expected = before.clone();
-        let route = expected
-            .diagrams
-            .get_mut(&g.f.diagram)
-            .unwrap()
-            .routes
-            .iter_mut()
-            .find(|r| r.edge == edge)
-            .unwrap();
-        if attachment {
-            route.source_attachment = Some(EdgeAttachment {
-                side: PortAnchorSide::Top,
-                offset: 0.25,
-            });
-        } else {
-            route.waypoints = vec![xy(750., 450.)];
-        }
-        exact_history(&mut g.f.app, &before, &source, &expected);
-    }
-}

crates/oa-desktop/src/app/allocation_drag_tests/navigation_union.rs

@@ -1,203 +0,0 @@
-//! Captured real canvas packets against a later navigation or live gesture.
-use super::*;
-use crate::diagram_usage::{self as usage, Target};
-
-fn navigate_work(f: &mut Fixture) -> usage::Usage {
-    let message = f.app.diagram_usage_message(f.work);
-    let _ = f.app.update(message);
-    let panel = f.app.diagram_usages.as_ref().unwrap();
-    let token = panel.token;
-    let context = panel.context;
-    let process = f.app.behavior.topology.usage_snapshot().into_query_state();
-    let completion = usage::Completion {
-        token,
-        context,
-        result: Ok(usage::collect(
-            f.app.project(),
-            f.work,
-            &process,
-            &crate::behavior::scenario::State::default(),
-        )),
-    };
-    let _ = f.app.update(Message::DiagramUsagesReady(completion));
-    let found = f
-        .app
-        .diagram_usages
-        .as_ref()
-        .unwrap()
-        .usages
-        .iter()
-        .find(|usage| usage.target == Target::Placement(f.node))
-        .unwrap()
-        .clone();
-    let _ = f.app.update(Message::DiagramUsage(usage::Event::Choose(
-        token,
-        found.clone(),
-    )));
-    assert!(f.app.pending_diagram_reveal.is_some());
-    assert!(f.app.diagram_focus(found.surface).is_some());
-    found
-}
-
-fn assert_stale_noop(app: &mut App, message: Message) {
-    let before = app.document.snapshot();
-    let selection = (app.selected, app.selected_node, app.active_diagram);
-    let camera = (app.zoom, app.pan, app.canvas_epoch, app.camera_epoch);
-    let pending = app.pending_diagram_reveal.clone();
-    let focus = app
-        .diagram_navigation_focus
-        .as_ref()
-        .map(|focus| (focus.context, focus.usage.clone(), focus.selected));
-    let allocation = (app.allocation_drag.epoch, app.allocation_drag.arrange_next);
-    let active = app
-        .allocation_drag
-        .active
-        .as_ref()
-        .map(|active| (active.press.token, active.cache.len()));
-    let interaction = app.source_symbols.interaction;
-    let status = app.status.clone();
-    let _ = app.update(message);
-    assert_eq!(
-        (app.selected, app.selected_node, app.active_diagram),
-        selection
-    );
-    assert_eq!(
-        (app.zoom, app.pan, app.canvas_epoch, app.camera_epoch),
-        camera
-    );
-    assert_eq!(app.pending_diagram_reveal, pending);
-    assert_eq!(
-        app.diagram_navigation_focus.as_ref().map(|focus| (
-            focus.context,
-            focus.usage.clone(),
-            focus.selected
-        )),
-        focus
-    );
-    assert_eq!(
-        (app.allocation_drag.epoch, app.allocation_drag.arrange_next),
-        allocation
-    );
-    assert_eq!(
-        app.allocation_drag
-            .active
-            .as_ref()
-            .map(|active| (active.press.token, active.cache.len())),
-        active
-    );
-    assert_eq!(app.source_symbols.interaction, interaction);
-    assert_eq!(app.status, status);
-    assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
-    assert_eq!(app.source_workspace.bundle(), before.bundle);
-}
-
-fn stale_packets(press: &Press) -> Vec<Message> {
-    vec![
-        Message::WorkDrag(Event::Cancel(press.token)),
-        Message::WorkDrag(Event::Preview(press.stamp, press.token, Some(press.start))),
-        Message::WorkDrag(Event::Release(press.stamp, press.token, Some(press.start))),
-        Message::WorkDrag(Event::Refused(press.stamp.epoch, "old refusal".into())),
-    ]
-}
-
-#[test]
-fn stale_gesture_packets_preserve_navigation_and_a_new_live_cancel_still_works() {
-    let mut f = fixture(Layer::Oa);
-    let before = f.app.document.snapshot();
-    let old = press(&f);
-    let _ = f.app.update(Message::WorkDrag(Event::Press(old.clone())));
-    assert_eq!(
-        f.app.allocation_drag.active.as_ref().unwrap().press.token,
-        old.token
-    );
-    let found = navigate_work(&mut f);
-    assert!(f.app.allocation_drag.active.is_none());
-    assert_ne!(f.app.allocation_drag.epoch, old.stamp.epoch);
-    for message in stale_packets(&old) {
-        assert_stale_noop(&mut f.app, message);
-    }
-    // A rejected press still explains the invalid view, but cannot consume the
-    // new destination's pending first measurement.
-    let pending = f.app.pending_diagram_reveal.clone();
-    let epoch = f.app.allocation_drag.epoch;
-    let _ = f.app.update(Message::WorkDrag(Event::Press(old.clone())));
-    assert_eq!(f.app.pending_diagram_reveal, pending);
-    assert_eq!(f.app.allocation_drag.epoch, epoch);
-    assert!(f.app.diagram_focus(found.surface).is_some());
-    assert_eq!(f.app.status, "The view changed. Start this drag again.");
-    let (context, _, epoch) = f.app.pending_diagram_reveal.clone().unwrap();
-    let _ = f.app.update(Message::DiagramRevealViewport(
-        context,
-        epoch,
-        bounds().size(),
-    ));
-    assert!(f.app.pending_diagram_reveal.is_none());
-    assert!(f.app.diagram_focus(found.surface).is_some());
-
-    // Restore the fixture's camera through current App actions, then capture a
-    // fresh packet through the actual DiagramCanvas rather than seeding active.
-    let factor = 1. / f.app.zoom;
-    let _ = f.app.update(Message::Zoom(factor));
-    let delta = -f.app.pan;
-    let _ = f.app.update(Message::Pan(delta));
-    let current = press(&f);
-    let _ = f
-        .app
-        .update(Message::WorkDrag(Event::Press(current.clone())));
-    assert_eq!(
-        f.app.allocation_drag.active.as_ref().unwrap().press.token,
-        current.token
-    );
-    assert!(
-        f.app.diagram_navigation_focus.is_none(),
-        "live press retires navigation"
-    );
-    for message in stale_packets(&old) {
-        assert_stale_noop(&mut f.app, message);
-    }
-    let epoch = f.app.allocation_drag.epoch;
-    let _ = f
-        .app
-        .update(Message::WorkDrag(Event::Cancel(current.token)));
-    assert!(f.app.allocation_drag.active.is_none());
-    assert!(f.app.allocation_drag.epoch > epoch);
-    assert_eq!(f.app.status, "Drag canceled");
-    assert!(Arc::ptr_eq(&before, &f.app.document.snapshot()));
-    assert_eq!(f.app.source_workspace.bundle(), before.bundle);
-}
-
-#[test]
-fn old_chooser_envelopes_preserve_a_current_canvas_gesture() {
-    let mut previous = fixture(Layer::Oa);
-    let old_open = previous.app.diagram_usage_message(previous.work);
-    let _ = previous.app.update(old_open.clone());
-    let old_token = previous.app.diagram_usages.as_ref().unwrap().token;
-    let mut f = fixture(Layer::Oa);
-    let current = press(&f);
-    let _ = f
-        .app
-        .update(Message::WorkDrag(Event::Press(current.clone())));
-    assert_stale_noop(&mut f.app, old_open);
-    assert_stale_noop(
-        &mut f.app,
-        Message::DiagramUsage(usage::Event::Close(old_token)),
-    );
-    assert_stale_noop(
-        &mut f.app,
-        Message::DiagramUsage(usage::Event::Search(old_token, "old".into())),
-    );
-    assert_eq!(
-        f.app.allocation_drag.active.as_ref().unwrap().press.token,
-        current.token
-    );
-    let open = f.app.diagram_usage_message(f.work);
-    let _ = f.app.update(open);
-    assert!(
-        f.app.diagram_usages.is_some(),
-        "current chooser remains live"
-    );
-    assert!(
-        f.app.allocation_drag.active.is_none(),
-        "current chooser retires gesture"
-    );
-}

crates/oa-desktop/src/app/architecture_authoring.rs

@@ -27,11 +27,30 @@ pub enum Event {
     Cancel,
 }
 
-pub(super) fn captured_escape_message(app: &App) -> Option<Message> {
-    app.architecture
-        .as_ref()
-        .is_some_and(State::inline)
-        .then_some(Message::Architecture(Event::CapturedEscape))
+pub fn subscription(app: &App) -> Subscription<Message> {
+    if app.architecture.as_ref().is_some_and(State::inline) {
+        iced::event::listen_with(captured_escape)
+    } else {
+        Subscription::none()
+    }
+}
+
+fn captured_escape(
+    event: iced::Event,
+    status: iced::event::Status,
+    _: iced::window::Id,
+) -> Option<Message> {
+    // A focused Iced text input captures Escape while dropping its focus. Only
+    // inline architecture naming opts into also cancelling that same keypress.
+    (status == iced::event::Status::Captured
+        && matches!(
+            event,
+            iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
+                key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
+                ..
+            })
+        ))
+    .then_some(Message::Architecture(Event::CapturedEscape))
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -119,7 +138,7 @@ pub fn validate_saved(p: &Project, s: &Saved) -> Result<(), String> {
         .diagrams
         .get(&s.diagram)
         .ok_or("The creation draft's diagram is missing.")?;
-    if !d.projection.is_architecture()
+    if matches!(d.projection, ProjectionKind::StateMachine { .. })
         || s.query.len() > 16384
         || s.page > 1_000_000
         || s.point
@@ -161,7 +180,7 @@ pub fn validate_saved(p: &Project, s: &Saved) -> Result<(), String> {
 }
 fn context_kinds(p: &Project, d: &Diagram) -> Vec<Kind> {
     let mut values = match (d.layer, d.projection) {
-        (_, ProjectionKind::StateMachine { .. } | ProjectionKind::Scenario { .. }) => vec![],
+        (_, ProjectionKind::StateMachine { .. }) => vec![],
         (Layer::Oa, ProjectionKind::FunctionalDataflow) => vec![Kind::Activity],
         (Layer::Sa, ProjectionKind::FunctionalDataflow) => vec![Kind::Function],
         (Layer::Oa, ProjectionKind::Capabilities) => vec![
@@ -189,12 +208,11 @@ pub fn kinds(app: &App) -> Vec<Kind> {
         .unwrap_or_default()
 }
 fn compatible(p: &Project, d: &Diagram, id: Id) -> bool {
-    d.projection.is_architecture()
-        && p.elements.get(&id).is_some_and(|e| {
-            e.kind() != Kind::Port
-                && d.projection.includes(e.kind())
-                && (e.layer() == d.layer || d.projection == ProjectionKind::Traceability)
-        })
+    p.elements.get(&id).is_some_and(|e| {
+        e.kind() != Kind::Port
+            && d.projection.includes(e.kind())
+            && (e.layer() == d.layer || d.projection == ProjectionKind::Traceability)
+    })
 }
 fn suggested(p: &Project, d: &Diagram, kind: Kind) -> bool {
     // Existing System remains a useful choice even when the singleton exists.
@@ -239,17 +257,6 @@ pub fn candidates(app: &App) -> Vec<(Id, String, bool)> {
 }
 impl App {
     pub(super) fn architecture_event(&mut self, event: Event) -> Task<Message> {
-        if matches!(
-            &event,
-            Event::Start(..) | Event::Allocate(..) | Event::Existing(..)
-        ) && !self
-            .active_diagram
-            .and_then(|id| self.project().diagrams.get(&id))
-            .is_some_and(|d| d.projection.is_architecture())
-        {
-            self.status = "Choose an architecture view before adding architecture content.".into();
-            return Task::none();
-        }
         match event {
             Event::Start(_, point) | Event::Allocate(_, _, point) | Event::Existing(point) => {
                 if self.architecture.is_some() {
@@ -294,17 +301,6 @@ impl App {
                     _ => return Task::none(),
                 };
                 let placing = point.is_none() && matches!(intent, Intent::Create { .. });
-                let filter = if matches!(intent, Intent::Existing { .. })
-                    && self
-                        .project()
-                        .diagrams
-                        .get(&diagram)
-                        .is_some_and(|d| d.projection == ProjectionKind::Traceability)
-                {
-                    Filter::AllCompatible
-                } else {
-                    Filter::Context
-                };
                 let saved = Saved {
                     version: 1,
                     base: oa_core::transitions::project_fingerprint(self.project()),
@@ -313,7 +309,7 @@ impl App {
                     point,
                     placing,
                     query: String::new(),
-                    filter,
+                    filter: Filter::Context,
                     show_placed: false,
                     page: 0,
                 };

crates/oa-desktop/src/app/architecture_authoring/palette.rs

@@ -229,7 +229,13 @@ pub fn view(app: &App) -> Element<'_, Message> {
     content = content.push(group("Connections"));
     for connection in crate::connection_tool::Tool::for_layer(app.layer) {
         let d = &app.project().diagrams[&app.active_diagram.unwrap()];
-        if !connection.available_in(app.layer, d.projection) {
+        let kind = match connection {
+            crate::connection_tool::Tool::Interaction => Kind::Activity,
+            crate::connection_tool::Tool::FunctionalExchange => Kind::Function,
+            crate::connection_tool::Tool::CommunicationMean => Kind::Entity,
+            crate::connection_tool::Tool::BoundaryExchange => Kind::System,
+        };
+        if !d.projection.includes(kind) {
             continue;
         }
         content = content.push(tool(

crates/oa-desktop/src/app/architecture_authoring/tests.rs

@@ -1,5 +1,4 @@
 use super::*;
-mod traceability;
 
 fn setup(layer: Layer) -> App {
     let mut app = App::with_project(Project::empty());
@@ -67,21 +66,17 @@ fn architecture_f2_routes_selected_node_to_inline_rename_and_exact_undo() {
     let camera = (app.zoom, app.pan);
     let bounds = iced::Rectangle::new(iced::Point::ORIGIN, iced::Size::new(600., 380.));
     let canvas = crate::diagram::DiagramCanvas {
-        selection: None,
         project: app.project(),
         view_index: None,
         diagram: app.active_diagram.unwrap(),
         selected: element,
-        navigation_focus: None,
         zoom: app.zoom,
         pan: app.pan,
         context: app.route_context().unwrap(),
         selected_bend: None,
-        selected_attachment: None,
         editable: true,
         placing: false,
         connection: None,
-        allocation: None,
     };
     let mut state = crate::diagram::State::default();
     let key = CanvasEvent::Keyboard(keyboard::Event::KeyPressed {
@@ -93,8 +88,17 @@ fn architecture_f2_routes_selected_node_to_inline_rename_and_exact_undo() {
         text: None,
         repeat: false,
     });
-    // Program receives keys already admitted by diagram::focus::Owner. Real
-    // unfocused/Inspector refusal is covered by app::diagram_focus_tests.
+    assert!(
+        canvas
+            .update(&mut state, &key, bounds, mouse::Cursor::Unavailable)
+            .is_none()
+    );
+    let _ = canvas.update(
+        &mut state,
+        &CanvasEvent::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+        bounds,
+        mouse::Cursor::Available(iced::Point::new(150., 120.)),
+    );
     let action = canvas
         .update(&mut state, &key, bounds, mouse::Cursor::Unavailable)
         .unwrap();
@@ -234,6 +238,65 @@ fn architecture_stale_submit_keeps_create_and_rename_visible_and_exact() {
     }
 }
 
+fn key_event(named: iced::keyboard::key::Named) -> iced::Event {
+    use iced::keyboard;
+    iced::Event::Keyboard(keyboard::Event::KeyPressed {
+        key: keyboard::Key::Named(named),
+        modified_key: keyboard::Key::Named(named),
+        physical_key: keyboard::key::Physical::Code(keyboard::key::Code::Escape),
+        location: keyboard::Location::Standard,
+        modifiers: keyboard::Modifiers::empty(),
+        text: None,
+        repeat: false,
+    })
+}
+
+fn focused_text_input_escape(name: &str) -> Message {
+    use iced::advanced::{Layout, Shell, layout, widget};
+    let mut field: iced::Element<'_, (), iced::Theme, ()> = text_input("Engineering name", name)
+        .id("architecture-name")
+        .on_input(|_| ())
+        .into();
+    let mut tree = widget::Tree::new(field.as_widget());
+    let size = iced::Size::new(300., 40.);
+    let node =
+        field
+            .as_widget_mut()
+            .layout(&mut tree, &(), &layout::Limits::new(iced::Size::ZERO, size));
+    tree.state
+        .downcast_mut::<iced::widget::text_input::State<()>>()
+        .focus();
+    let escape = key_event(iced::keyboard::key::Named::Escape);
+    let mut messages = Vec::new();
+    let mut shell = Shell::new(&mut messages);
+    field.as_widget_mut().update(
+        &mut tree,
+        &escape,
+        Layout::new(&node),
+        iced::mouse::Cursor::Unavailable,
+        &(),
+        &mut iced::advanced::clipboard::Null,
+        &mut shell,
+        &iced::Rectangle::new(iced::Point::ORIGIN, size),
+    );
+    assert!(
+        shell.is_event_captured(),
+        "Iced consumes focused-input Escape"
+    );
+    assert!(
+        !tree
+            .state
+            .downcast_ref::<iced::widget::text_input::State<()>>()
+            .is_focused()
+    );
+    captured_escape(
+        escape,
+        iced::event::Status::Captured,
+        iced::window::Id::unique(),
+    )
+    .unwrap()
+}
+
 #[test]
 fn architecture_first_focused_input_escape_cancels_create_and_rename() {
     for rename in [false, true] {
@@ -253,9 +316,8 @@ fn architecture_first_focused_input_escape_cancels_create_and_rename() {
         let name = "  Unaccepted long engineering name 雨  ";
         send(&mut app, Event::Name(name.into()));
         assert!(app.architecture.as_ref().unwrap().inline());
-        let mut messages = crate::app::escape::tests::focused_input_messages(&app);
-        assert_eq!(messages.len(), 1);
-        let _ = app.update(messages.remove(0));
+        let message = focused_text_input_escape(name);
+        let _ = app.update(message);
         assert!(app.architecture.is_none());
         assert!(inline_editor(&app).is_none());
         assert_eq!(app.status, "Cancelled · Select / move");
@@ -285,8 +347,8 @@ fn architecture_captured_escape_does_not_cancel_other_controls_or_placement() {
         let before = app.document.bundle().clone();
         let status = app.status.clone();
         let epoch = app.canvas_epoch;
-        let messages = crate::app::escape::tests::focused_input_messages(&app);
-        assert!(messages.is_empty());
+        let message = focused_text_input_escape("Other field or existing-element search");
+        let _ = app.update(message);
         assert_eq!(
             app.architecture
                 .as_ref()
@@ -298,7 +360,19 @@ fn architecture_captured_escape_does_not_cancel_other_controls_or_placement() {
         assert_eq!(app.canvas_epoch, epoch);
     }
     assert!(
-        crate::app::escape::tests::focused_input_key(&app, iced::keyboard::key::Named::Enter,)
-            .is_empty()
+        captured_escape(
+            key_event(iced::keyboard::key::Named::Escape),
+            iced::event::Status::Ignored,
+            iced::window::Id::unique(),
+        )
+        .is_none()
+    );
+    assert!(
+        captured_escape(
+            key_event(iced::keyboard::key::Named::Enter),
+            iced::event::Status::Captured,
+            iced::window::Id::unique(),
+        )
+        .is_none()
     );
 }

crates/oa-desktop/src/app/architecture_authoring/tests/traceability.rs

@@ -1,124 +0,0 @@
-use super::*;
-
-#[test]
-fn traceability_existing_defaults_show_opposite_layer_and_place_only_one_node() {
-    let mut project = Project::empty();
-    let sa = project
-        .add_element(Kind::Function, Layer::Sa, "Deliver report", None)
-        .unwrap();
-    let system = project
-        .add_element(Kind::System, Layer::Sa, "System", None)
-        .unwrap();
-    let diagram = project.ensure_diagram(Layer::Oa);
-    project.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Traceability;
-    let mut app = App::with_project(project);
-    app.page = Page::Diagram;
-    app.layer = Layer::Oa;
-    app.active_diagram = Some(diagram);
-    let before = app.document.snapshot();
-    send(&mut app, Event::Existing(None));
-    assert_eq!(
-        app.architecture.as_ref().unwrap().saved.filter,
-        Filter::AllCompatible
-    );
-    let listed = candidates(&app);
-    assert!(listed.iter().any(|(id, _, shown)| *id == sa && !shown));
-    assert!(listed.iter().any(|(id, _, shown)| *id == system && !shown));
-    send(&mut app, Event::Pick(sa));
-    assert!(app.architecture.as_ref().unwrap().saved.placing);
-    assert_eq!(app.project(), &before.decoded.project);
-    let context = app.route_context().unwrap();
-    let point = Position { x: 345., y: 215. };
-    send(&mut app, Event::Click(context, point));
-    assert!(app.architecture.is_none(), "{}", app.status);
-    assert_eq!(app.active_diagram, Some(diagram));
-    let placed = app.project().diagrams[&diagram]
-        .nodes
-        .values()
-        .find(|n| n.element == sa)
-        .unwrap()
-        .clone();
-    assert_eq!(placed.position, point);
-    let mut expected = before.decoded.project.clone();
-    expected
-        .diagrams
-        .get_mut(&diagram)
-        .unwrap()
-        .nodes
-        .insert(placed.id, placed);
-    assert_eq!(app.project(), &expected);
-    let accepted = app.document.bundle().clone();
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-    let _ = app.update(Message::Redo);
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.document.bundle(), &accepted);
-}
-
-#[test]
-fn traceability_default_does_not_change_creation_or_ordinary_picker_guards() {
-    let mut app = setup(Layer::Oa);
-    let diagram = app.active_diagram.unwrap();
-    send(&mut app, Event::Existing(None));
-    assert_eq!(
-        app.architecture.as_ref().unwrap().saved.filter,
-        Filter::Context
-    );
-    send(&mut app, Event::Cancel);
-    let _ = app.update(Message::Projection(ProjectionKind::Traceability));
-    send(&mut app, Event::Start(Kind::Entity, None));
-    assert_eq!(
-        app.architecture.as_ref().unwrap().saved.filter,
-        Filter::Context
-    );
-    send(&mut app, Event::Cancel);
-    assert_eq!(app.active_diagram, Some(diagram));
-
-    let mut project = app.project().clone();
-    let sa = project
-        .add_element(Kind::Function, Layer::Sa, "Other layer", None)
-        .unwrap();
-    let port = Id::new_v4();
-    project.elements.insert(
-        port,
-        oa_core::Element {
-            id: port,
-            alias: "legacy_port".into(),
-            name: "Port".into(),
-            description: String::new(),
-            parent: Some(sa),
-            body: ElementBody::shared_in(
-                Layer::Sa,
-                SharedBody::Port {
-                    contract: PortContract::Legacy,
-                    legacy: Some(LegacyPortContract {
-                        direction: PortDirection::InOut,
-                        interface: None,
-                    }),
-                },
-            ),
-        },
-    );
-    oa_core::validate_candidate(&project).unwrap();
-    for projection in [ProjectionKind::Overview, ProjectionKind::Traceability] {
-        let mut p = project.clone();
-        p.diagrams.get_mut(&diagram).unwrap().projection = projection;
-        let mut trial = App::with_project(p);
-        trial.page = Page::Diagram;
-        trial.active_diagram = Some(diagram);
-        trial.layer = Layer::Oa;
-        let before = trial.document.bundle().clone();
-        send(&mut trial, Event::Existing(None));
-        send(&mut trial, Event::Filter(Filter::AllCompatible));
-        assert_eq!(
-            candidates(&trial).iter().any(|(id, _, _)| *id == sa),
-            projection == ProjectionKind::Traceability
-        );
-        assert!(!candidates(&trial).iter().any(|(id, _, _)| *id == port));
-        send(&mut trial, Event::Pick(port));
-        assert!(!trial.architecture.as_ref().unwrap().saved.placing);
-        send(&mut trial, Event::Cancel);
-        assert_eq!(trial.document.bundle(), &before);
-    }
-}

crates/oa-desktop/src/app/architecture_authoring_tests.rs

@@ -221,21 +221,17 @@ fn architecture_canvas_left_click_uses_world_coordinate_once_at_zoom_and_pan() {
         y: (local.y - app.pan.y) / app.zoom,
     };
     let canvas = crate::diagram::DiagramCanvas {
-        selection: None,
         project: app.project(),
         view_index: None,
         diagram: app.active_diagram.unwrap(),
         selected: app.selected,
-        navigation_focus: None,
         zoom: app.zoom,
         pan: app.pan,
         context: app.route_context().unwrap(),
         selected_bend: None,
-        selected_attachment: None,
         editable: true,
         placing: true,
         connection: None,
-        allocation: None,
     };
     let mut state = crate::diagram::State::default();
     let action = canvas
@@ -299,21 +295,17 @@ fn architecture_f2_rename_preserves_identity_placement_and_atomic_history() {
     let diagrams = app.project().diagrams.clone();
     let camera = (app.zoom, app.pan);
     let canvas = crate::diagram::DiagramCanvas {
-        selection: None,
         project: app.project(),
         view_index: None,
         diagram: app.active_diagram.unwrap(),
         selected: element,
-        navigation_focus: None,
         zoom: app.zoom,
         pan: app.pan,
         context: app.route_context().unwrap(),
         selected_bend: None,
-        selected_attachment: None,
         editable: true,
         placing: false,
         connection: None,
-        allocation: None,
     };
     let bounds = iced::Rectangle::with_size(iced::Size::new(800., 600.));
     let cursor = mouse::Cursor::Available(iced::Point::new(500., 400.));
@@ -327,11 +319,16 @@ fn architecture_f2_rename_preserves_identity_placement_and_atomic_history() {
         text: None,
         repeat: false,
     });
-    // Program receives keys already admitted by diagram::focus::Owner. Real
-    // unfocused/Inspector refusal is covered by app::diagram_focus_tests.
+    assert!(canvas.update(&mut state, &key, bounds, cursor).is_none());
+    let _ = canvas.update(
+        &mut state,
+        &iced::widget::canvas::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
+        bounds,
+        cursor,
+    );
     let message = canvas
         .update(&mut state, &key, bounds, cursor)
-        .expect("admitted F2 opens the selected semantic name")
+        .expect("focused F2 opens the selected semantic name")
         .into_inner()
         .0
         .unwrap();

crates/oa-desktop/src/app/behavior_lifecycle_tests.rs

@@ -291,7 +291,7 @@ fn pending_behavior_blocks_navigation_property_edits_and_model_history() {
         Message::BrowseGroup(crate::explorer::Group::Work),
         Message::Field("/name".into(), "Overwrite properties".into()),
         Message::Command(Command::Rename(fixture.source, "Overwrite model".into())),
-        Message::ConfirmDelete(0),
+        Message::ConfirmDelete,
         Message::Undo,
         Message::Redo,
         Message::ShortcutUndo(false),

crates/oa-desktop/src/app/behavior_removal_tests.rs

@@ -1,627 +0,0 @@
-//! Delete through the actual App widget tree, ordinary focus, and source history.
-use super::*;
-use crate::behavior::{
-    canvas_workspace::tests::{Mounted, focused, key},
-    scenario, topology,
-};
-use iced::{Event as Input, Point, Size, Vector, keyboard, mouse};
-
-fn app(p: Project, owner: Id) -> App {
-    let mut app = App::with_project(p);
-    let _ = app.update(Message::Select(owner));
-    let _ = app.update(Message::Page(Page::Behavior));
-    app.window_size = Size::new(1900., 1200.);
-    app
-}
-fn point(mounted: &mut Mounted, app: &App, id: Id) -> Point {
-    if let Some(context) = app.topology_context() {
-        let bounds = mounted.geometry(app).bounds("process-viewport");
-        let local = app
-            .behavior
-            .topology
-            .removal_test_point(app, context.owner, id, None);
-        bounds.position() + Vector::new(local.x, local.y)
-    } else {
-        let context = app.scenario_context().unwrap();
-        let bounds = mounted.geometry(app).bounds("scenario-viewport");
-        let local = scenario::removal_test_point(app, context.scenario, id);
-        bounds.position() + Vector::new(local.x, local.y)
-    }
-}
-async fn select(mounted: &mut Mounted, app: &mut App, id: Id) {
-    let target = point(mounted, app, id);
-    mounted.click(app, target).await;
-    assert_eq!(app.selected, id, "real pointer selects intended occurrence");
-}
-fn remove_key(shift: bool) -> Input {
-    let mut event = key(keyboard::key::Named::Delete);
-    if shift && let Input::Keyboard(keyboard::Event::KeyPressed { modifiers, .. }) = &mut event {
-        *modifiers = keyboard::Modifiers::SHIFT;
-    }
-    event
-}
-fn removal(message: &Message) -> bool {
-    matches!(
-        message,
-        Message::TopologyCanvas(topology::CanvasEvent::Remove(..))
-            | Message::ScenarioCanvas(scenario::CanvasEvent::Remove(..))
-    )
-}
-async fn delete(mounted: &mut Mounted, app: &mut App, shift: bool) -> u64 {
-    let messages = mounted
-        .batch(app, &[remove_key(shift)], mouse::Cursor::Unavailable)
-        .await;
-    assert!(
-        messages.iter().any(removal),
-        "focused viewport emits removal: {messages:?}"
-    );
-    let target = app.delete_target.as_ref().expect("captured confirmation");
-    assert_eq!(target.snapshot.request.object, app.selected);
-    assert_eq!(target.placement, None);
-    assert_eq!(target.snapshot.request.placement, None);
-    target.snapshot.token
-}
-async fn send(mounted: &mut Mounted, app: &mut App, message: Message) {
-    let task = app.update(message);
-    mounted.perform(app, task).await;
-}
-fn consistent(app: &App) {
-    assert_eq!(
-        source_project::compile_bundle(app.document.bundle(), LIMITS)
-            .unwrap()
-            .decoded
-            .project,
-        *app.project()
-    );
-    assert_eq!(
-        source_workspace::reachable(&app.source_workspace.bundle()).unwrap(),
-        *app.document.bundle()
-    );
-}
-
-#[tokio::test]
-async fn mounted_process_delete_occurrence_or_link_preserves_reusable_work_and_source_history() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for link in [false, true] {
-            let f = topology::direct_tests::fixture(layer);
-            let target = if link { f.link } else { f.nodes[0] };
-            let mut app = app(f.p.clone(), f.owner);
-            let mut mounted = Mounted::new(&mut app).await;
-            let original = app.document.bundle().clone();
-            select(&mut mounted, &mut app, target).await;
-            // No extra redraw between release and first Delete.
-            let token = delete(&mut mounted, &mut app, link).await;
-            assert_eq!(
-                app.delete_target.as_ref().unwrap().behavior_owner,
-                Some(f.owner)
-            );
-            assert_eq!(app.document.bundle(), &original);
-            send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-            assert!(!app.project().contains(target));
-            assert!(f.work.iter().all(|id| app.project().contains(*id)));
-            assert!(app.project().contains(f.exchange));
-            assert!(app.project().contains(f.nodes[1]));
-            assert_eq!(app.project().contains(f.nodes[0]), link);
-            assert!(!app.project().contains(f.link));
-            consistent(&app);
-            let removed = app.document.bundle().clone();
-            send(&mut mounted, &mut app, Message::Undo).await;
-            assert_eq!(app.document.bundle(), &original);
-            consistent(&app);
-            send(&mut mounted, &mut app, Message::Redo).await;
-            assert_eq!(app.document.bundle(), &removed);
-            consistent(&app);
-        }
-    }
-}
-
-#[tokio::test]
-async fn mounted_scenario_delete_message_or_participant_preserves_reusable_targets() {
-    for participant in [false, true] {
-        let f = scenario::direct_tests::fixture();
-        let target = if participant { f.sender } else { f.call };
-        let mut app = app(f.project.clone(), f.owner);
-        let mut mounted = Mounted::new(&mut app).await;
-        let original = app.document.bundle().clone();
-        select(&mut mounted, &mut app, target).await;
-        let token = delete(&mut mounted, &mut app, participant).await;
-        send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-        assert!(!app.project().contains(target));
-        assert!(app.project().contains(f.exchange));
-        assert!(app.project().contains(f.receiver));
-        assert!(app.project().contains(f.reply));
-        for element in f
-            .project
-            .elements
-            .values()
-            .filter(|element| element.parent != Some(f.owner))
-        {
-            assert!(
-                app.project().contains(element.id),
-                "referenced definitions survive"
-            );
-        }
-        if participant {
-            assert!(app.project().contains(f.call));
-            for element in app.project().elements.values() {
-                if let Some(SharedBody::Occurrence {
-                    body:
-                        OccurrenceBody::Exchange {
-                            sender, receiver, ..
-                        },
-                    ..
-                }) = element.shared()
-                {
-                    assert_ne!(*sender, Some(target));
-                    assert_ne!(*receiver, Some(target));
-                }
-            }
-        }
-        consistent(&app);
-        send(&mut mounted, &mut app, Message::Undo).await;
-        assert_eq!(app.document.bundle(), &original);
-        consistent(&app);
-    }
-}
-
-#[tokio::test]
-async fn mounted_scenario_use_delete_keeps_definition_and_second_use_and_rejects_owner_replay() {
-    let (p, owners, uses) = scenario::direct_tests::navigation_fixture();
-    let mut app = app(p, owners[0]);
-    let mut mounted = Mounted::new(&mut app).await;
-    let original = app.document.bundle().clone();
-    select(&mut mounted, &mut app, uses[0]).await;
-    let stale = delete(&mut mounted, &mut app, false).await;
-    send(&mut mounted, &mut app, Message::CancelDelete).await;
-    send(&mut mounted, &mut app, Message::ConfirmDelete(stale)).await;
-    assert_eq!(app.document.bundle(), &original);
-    select(&mut mounted, &mut app, uses[0]).await;
-    let token = delete(&mut mounted, &mut app, true).await;
-    send(&mut mounted, &mut app, Message::ConfirmDelete(stale)).await;
-    assert!(app.delete_pending, "old token does not cancel new dialog");
-    // Keep selection and epoch deliberately unchanged: owner is an independent witness.
-    let captured = app.scenario_context().unwrap();
-    assert_eq!(captured.scenario, owners[0]);
-    assert_eq!(
-        app.delete_target.as_ref().unwrap().behavior_owner,
-        Some(owners[0])
-    );
-    app.behavior.active_owner = Some(owners[1]);
-    app.reconcile_scenario_workspace();
-    let other = app.scenario_context().unwrap();
-    assert_eq!(other.scenario, owners[1]);
-    assert_eq!(
-        other.representation,
-        crate::behavior::scenario_layout::Representation::Derived { owner: owners[1] }
-    );
-    assert_eq!(other.epoch, captured.epoch);
-    assert_eq!(app.selected, uses[0]);
-    assert!(
-        app.delete_target.as_ref().unwrap().snapshot.valid(&app),
-        "the independent owner guard must reject an otherwise current token"
-    );
-    send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-    assert_eq!(app.document.bundle(), &original);
-    assert!(!app.delete_pending && app.delete_target.is_none());
-    assert!(!app.document.can_undo() && !app.document.can_redo());
-    app.behavior.active_owner = Some(owners[0]);
-    // Restore both owner and qualified presentation before mounting pointer input.
-    // Passive reports from the previous owner cannot repair an inconsistent fixture.
-    app.reconcile_scenario_workspace();
-    assert_eq!(app.scenario_context().unwrap().scenario, owners[0]);
-    assert_eq!(app.selected, uses[0]);
-    mounted.settle(&mut app).await;
-    select(&mut mounted, &mut app, uses[0]).await;
-    let token = delete(&mut mounted, &mut app, false).await;
-    send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-    assert!(!app.project().contains(uses[0]));
-    assert!(app.project().contains(uses[1]));
-    assert!(owners.iter().all(|id| app.project().contains(*id)));
-    consistent(&app);
-    send(&mut mounted, &mut app, Message::Undo).await;
-    assert_eq!(app.document.bundle(), &original);
-}
-
-#[tokio::test]
-async fn mounted_behavior_tab_and_f6_retire_same_batch_delete_and_window_focus() {
-    for process in [false, true] {
-        let (mut app, target) = if process {
-            let f = topology::direct_tests::fixture(Layer::Oa);
-            (app(f.p, f.owner), f.nodes[0])
-        } else {
-            let f = scenario::direct_tests::fixture();
-            (app(f.project, f.owner), f.call)
-        };
-        let mut mounted = Mounted::new(&mut app).await;
-        let original = app.document.bundle().clone();
-        for boundary in [
-            keyboard::key::Named::Tab,
-            keyboard::key::Named::F6,
-            keyboard::key::Named::Escape,
-        ] {
-            select(&mut mounted, &mut app, target).await;
-            let messages = mounted
-                .batch(
-                    &mut app,
-                    &[key(boundary), remove_key(false)],
-                    mouse::Cursor::Unavailable,
-                )
-                .await;
-            assert!(
-                !messages.iter().any(removal),
-                "{boundary:?} retires keyboard admission within the batch"
-            );
-            assert!(!app.delete_pending);
-            assert_eq!(app.document.bundle(), &original);
-            assert!(!focused(&mut mounted, &app, "viewport"));
-            if boundary == keyboard::key::Named::Tab {
-                assert_eq!(
-                    mounted
-                        .geometry(&app)
-                        .focused
-                        .iter()
-                        .filter(|(_, _, value)| *value)
-                        .count(),
-                    1,
-                    "Tab completes traversal to one real control"
-                );
-                let mut backwards = key(keyboard::key::Named::Tab);
-                if let Input::Keyboard(keyboard::Event::KeyPressed { modifiers, .. }) =
-                    &mut backwards
-                {
-                    *modifiers = keyboard::Modifiers::SHIFT;
-                }
-                mounted
-                    .batch(&mut app, &[backwards], mouse::Cursor::Unavailable)
-                    .await;
-            } else {
-                let messages = mounted
-                    .batch(
-                        &mut app,
-                        &[key(keyboard::key::Named::F6), remove_key(false)],
-                        mouse::Cursor::Unavailable,
-                    )
-                    .await;
-                assert!(
-                    !messages.iter().any(removal),
-                    "F6 entry completes after the batch, before a later Delete"
-                );
-            }
-            assert!(
-                focused(&mut mounted, &app, "viewport"),
-                "{boundary:?} supports keyboard-only return to the viewport"
-            );
-            delete(&mut mounted, &mut app, false).await;
-            send(&mut mounted, &mut app, Message::CancelDelete).await;
-            assert_eq!(app.document.bundle(), &original);
-        }
-        select(&mut mounted, &mut app, target).await;
-        let messages = mounted
-            .batch(
-                &mut app,
-                &[
-                    Input::Window(iced::window::Event::Unfocused),
-                    remove_key(false),
-                ],
-                mouse::Cursor::Unavailable,
-            )
-            .await;
-        assert!(!messages.iter().any(removal));
-        assert!(!app.delete_pending);
-        // A new actual click reacquires ownership after each boundary.
-        select(&mut mounted, &mut app, target).await;
-        delete(&mut mounted, &mut app, false).await;
-        send(&mut mounted, &mut app, Message::CancelDelete).await;
-        assert_eq!(app.document.bundle(), &original);
-    }
-}
-
-#[tokio::test]
-async fn mounted_behavior_clean_inspector_click_and_tab_own_delete_then_f6_returns_to_canvas() {
-    for process in [false, true] {
-        for tab_entry in [false, true] {
-            let (mut app, target) = if process {
-                let f = topology::direct_tests::fixture(Layer::Oa);
-                (app(f.p, f.owner), f.nodes[0])
-            } else {
-                let f = scenario::direct_tests::fixture();
-                (app(f.project, f.owner), f.call)
-            };
-            let mut mounted = Mounted::new(&mut app).await;
-            select(&mut mounted, &mut app, target).await;
-            let original = app.document.bundle().clone();
-            let original_name = app.draft.as_ref().unwrap().inputs["/name"].raw.clone();
-            // The first text input in the right-hand Inspector is the name.
-            // Verify its actual binding below, rather than seeding focus state.
-            let field = mounted
-                .geometry(&app)
-                .text_inputs
-                .into_iter()
-                .filter(|bounds| bounds.x > app.window_size.width - 320.)
-                .min_by(|a, b| a.y.total_cmp(&b.y))
-                .expect("visible Inspector name input");
-            if tab_entry {
-                // Canvas Tab stays within canvas controls. Escape then ordinary
-                // Tab follows the existing Inspector entry policy.
-                mounted
-                    .batch(
-                        &mut app,
-                        &[key(keyboard::key::Named::Escape)],
-                        mouse::Cursor::Unavailable,
-                    )
-                    .await;
-                mounted
-                    .batch(
-                        &mut app,
-                        &[key(keyboard::key::Named::Tab)],
-                        mouse::Cursor::Unavailable,
-                    )
-                    .await;
-            } else {
-                mounted.click(&mut app, field.center()).await;
-            }
-            assert!(
-                mounted
-                    .geometry(&app)
-                    .focused
-                    .iter()
-                    .any(|(_, bounds, value)| *bounds == field && *value),
-                "actual {} focuses the Inspector name",
-                if tab_entry { "Tab" } else { "click" }
-            );
-            assert!(!focused(&mut mounted, &app, "viewport"));
-            assert!(!app.draft_dirty());
-            let messages = mounted
-                .batch(
-                    &mut app,
-                    &[key(keyboard::key::Named::End), remove_key(true)],
-                    mouse::Cursor::Unavailable,
-                )
-                .await;
-            assert!(messages.iter().any(|message| matches!(
-                message,
-                Message::Field(path, value) if path == "/name" && *value == original_name
-            )));
-            assert!(!messages.iter().any(removal));
-            assert!(!app.delete_pending);
-            assert!(!app.draft_dirty(), "Delete at end keeps the field clean");
-            assert_eq!(app.document.bundle(), &original);
-            mounted
-                .batch(
-                    &mut app,
-                    &[key(keyboard::key::Named::F6)],
-                    mouse::Cursor::Unavailable,
-                )
-                .await;
-            assert!(focused(&mut mounted, &app, "viewport"));
-            assert_eq!(
-                mounted
-                    .geometry(&app)
-                    .focused
-                    .iter()
-                    .filter(|(_, _, value)| *value)
-                    .count(),
-                1,
-                "F6 releases actual Inspector focus"
-            );
-            delete(&mut mounted, &mut app, false).await;
-            send(&mut mounted, &mut app, Message::CancelDelete).await;
-            assert_eq!(app.document.bundle(), &original);
-        }
-    }
-}
-
-#[tokio::test]
-async fn mounted_behavior_clean_text_focus_and_modifiers_cannot_delete_selected_occurrence() {
-    use iced::advanced::widget::{Operation, operation};
-    struct FocusText(iced::Rectangle);
-    impl Operation for FocusText {
-        fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
-            visit(self);
-        }
-        fn focusable(
-            &mut self,
-            _: Option<&iced::advanced::widget::Id>,
-            bounds: iced::Rectangle,
-            state: &mut dyn operation::Focusable,
-        ) {
-            if bounds == self.0 {
-                state.focus();
-            } else {
-                state.unfocus();
-            }
-        }
-    }
-    for process in [false, true] {
-        let (mut app, target) = if process {
-            let f = topology::direct_tests::fixture(Layer::Oa);
-            (app(f.p, f.owner), f.nodes[0])
-        } else {
-            let f = scenario::direct_tests::fixture();
-            (app(f.project, f.owner), f.call)
-        };
-        let mut mounted = Mounted::new(&mut app).await;
-        select(&mut mounted, &mut app, target).await;
-        let original = app.document.bundle().clone();
-        for modifiers in [
-            keyboard::Modifiers::CTRL,
-            keyboard::Modifiers::ALT,
-            keyboard::Modifiers::LOGO,
-        ] {
-            let mut event = remove_key(false);
-            if let Input::Keyboard(keyboard::Event::KeyPressed {
-                modifiers: value, ..
-            }) = &mut event
-            {
-                *value = modifiers;
-            }
-            let messages = mounted
-                .batch(&mut app, &[event], mouse::Cursor::Unavailable)
-                .await;
-            assert!(!messages.iter().any(removal));
-        }
-        let field = mounted
-            .geometry(&app)
-            .text_inputs
-            .into_iter()
-            .find(|bounds| bounds.width > 40.)
-            .expect("real text field");
-        mounted.operate(&app, &mut FocusText(field));
-        assert!(!app.draft_dirty());
-        let messages = mounted
-            .batch(&mut app, &[remove_key(true)], mouse::Cursor::Unavailable)
-            .await;
-        assert!(!messages.iter().any(removal));
-        assert!(!app.delete_pending);
-        assert_eq!(app.document.bundle(), &original);
-    }
-}
-
-#[tokio::test]
-async fn mounted_scenario_fragment_and_branch_delete_only_owned_occurrences() {
-    for whole_fragment in [false, true] {
-        let (f, branch, anchor, state, reused, remote) =
-            scenario::direct_tests::placement_fixture();
-        let fragment = f.project.elements[&branch].parent.unwrap();
-        let target = if whole_fragment { fragment } else { branch };
-        let mut app = app(f.project.clone(), f.owner);
-        let mut mounted = Mounted::new(&mut app).await;
-        let original = app.document.bundle().clone();
-        select(&mut mounted, &mut app, target).await;
-        let token = delete(&mut mounted, &mut app, false).await;
-        send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-        assert!(!app.project().contains(target));
-        assert!(!app.project().contains(anchor));
-        assert!(!app.project().contains(branch));
-        assert_eq!(app.project().contains(fragment), !whole_fragment);
-        for id in [
-            f.call, f.reply, f.sender, f.receiver, f.exchange, state, reused, remote,
-        ] {
-            assert!(app.project().contains(id));
-        }
-        consistent(&app);
-        send(&mut mounted, &mut app, Message::Undo).await;
-        assert_eq!(app.document.bundle(), &original);
-    }
-}
-
-#[tokio::test]
-async fn mounted_qualified_process_child_delete_refuses_outer_reference_and_shared_definition() {
-    let f = topology::direct_tests::fixture(Layer::Oa);
-    let mut p = f.p;
-    let caller = p
-        .add_element(Kind::Process, Layer::Oa, "Caller", None)
-        .unwrap();
-    let references = ["First use", "Second use"].map(|name| {
-        let mut element = p
-            .make_element(Kind::Occurrence, Layer::Oa, name, Some(caller))
-            .unwrap();
-        *element.shared_mut().unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::SequenceReference {
-                sequence: Some(f.owner),
-            },
-            precondition: String::new(),
-            postcondition: String::new(),
-        };
-        let id = element.id;
-        p = execute_batch(&p, &[Command::CreateElement(element)]).unwrap();
-        id
-    });
-    let mut app = app(p, caller);
-    let mut mounted = Mounted::new(&mut app).await;
-    let original = app.document.bundle().clone();
-    let endpoint = OccurrenceEndpoint {
-        references: vec![references[0]],
-        occurrence: f.nodes[0],
-    };
-    let bounds = mounted.geometry(&app).bounds("process-viewport");
-    let local =
-        app.behavior
-            .topology
-            .removal_test_point(&app, caller, references[0], Some(&endpoint));
-    let messages = mounted
-        .click(&mut app, bounds.position() + Vector::new(local.x, local.y))
-        .await;
-    assert!(messages.iter().any(|message| matches!(
-        message,
-        Message::DiagramSelection(multiselect::Event::Choose(
-            _, crate::diagram_usage::Target::ProcessOccurrence(actual), multiselect::Choice::Replace
-        )) if actual == &endpoint
-    )));
-    assert_eq!(app.selected, f.nodes[0]);
-    assert!(app.draft.is_none(), "Qualified inspection stays read-only");
-    assert_eq!(
-        app.behavior.topology.selection_address().unwrap().endpoint,
-        endpoint
-    );
-    assert!(
-        app.behavior
-            .topology
-            .has_qualified_selection(app.project(), caller)
-    );
-    mounted
-        .batch(&mut app, &[remove_key(false)], mouse::Cursor::Unavailable)
-        .await;
-    assert!(!app.delete_pending);
-    assert_eq!(app.document.bundle(), &original);
-    assert!(app.status.contains("Open the referenced definition"));
-    select(&mut mounted, &mut app, references[0]).await;
-    assert!(
-        !app.behavior
-            .topology
-            .has_qualified_selection(app.project(), caller)
-    );
-    let token = delete(&mut mounted, &mut app, true).await;
-    send(&mut mounted, &mut app, Message::ConfirmDelete(token)).await;
-    assert!(!app.project().contains(references[0]));
-    assert!(app.project().contains(references[1]));
-    assert!(app.project().contains(f.owner));
-    assert!(f.nodes.iter().all(|id| app.project().contains(*id)));
-    consistent(&app);
-    send(&mut mounted, &mut app, Message::Undo).await;
-    assert_eq!(app.document.bundle(), &original);
-}
-
-#[tokio::test]
-async fn mounted_behavior_pan_and_stale_removal_intent_do_not_delete() {
-    for process in [false, true] {
-        let (mut app, target) = if process {
-            let f = topology::direct_tests::fixture(Layer::Oa);
-            (app(f.p, f.owner), f.nodes[0])
-        } else {
-            let f = scenario::direct_tests::fixture();
-            (app(f.project, f.owner), f.call)
-        };
-        let mut mounted = Mounted::new(&mut app).await;
-        select(&mut mounted, &mut app, target).await;
-        let original = app.document.bundle().clone();
-        let cursor = point(&mut mounted, &app, target);
-        let messages = mounted
-            .batch(
-                &mut app,
-                &[
-                    Input::Mouse(mouse::Event::CursorMoved { position: cursor }),
-                    Input::Mouse(mouse::Event::ButtonPressed(mouse::Button::Middle)),
-                    remove_key(false),
-                    Input::Mouse(mouse::Event::ButtonReleased(mouse::Button::Middle)),
-                ],
-                mouse::Cursor::Available(cursor),
-            )
-            .await;
-        assert!(
-            !messages.iter().any(removal),
-            "held pan never becomes an occurrence deletion"
-        );
-        assert!(!app.delete_pending);
-        select(&mut mounted, &mut app, target).await;
-        let messages = mounted.input(&app, &[remove_key(false)], mouse::Cursor::Unavailable);
-        let stale = messages
-            .into_iter()
-            .find(removal)
-            .expect("captured live removal");
-        app.canvas_epoch = app.canvas_epoch.wrapping_add(1);
-        send(&mut mounted, &mut app, stale).await;
-        assert!(!app.delete_pending);
-        assert_eq!(app.document.bundle(), &original);
-    }
-}

crates/oa-desktop/src/app/diagram_focus_tests.rs

@@ -1,593 +0,0 @@
-//! Keyboard ownership is exercised on the mounted App, not raw Canvas Program.
-use super::*;
-use crate::behavior::canvas_workspace::tests::{Mounted, key};
-use iced::advanced::widget::{Operation, operation};
-use iced::{Point, Rectangle, Size, Vector, keyboard::key::Named, mouse};
-
-struct FocusField(Rectangle);
-impl Operation for FocusField {
-    fn traverse(&mut self, visit: &mut dyn FnMut(&mut dyn Operation)) {
-        visit(self);
-    }
-    fn focusable(
-        &mut self,
-        _: Option<&iced::advanced::widget::Id>,
-        bounds: Rectangle,
-        state: &mut dyn operation::Focusable,
-    ) {
-        if bounds == self.0 {
-            state.focus();
-        } else {
-            state.unfocus();
-        }
-    }
-}
-
-async fn f2(mounted: &mut Mounted, app: &mut App) -> Vec<Message> {
-    mounted
-        .batch(app, &[key(Named::F2)], mouse::Cursor::Unavailable)
-        .await
-}
-
-fn rename_emitted(messages: &[Message]) -> bool {
-    messages.iter().any(|message| {
-        matches!(
-            message,
-            Message::Architecture(architecture_authoring::Event::Rename(..))
-        )
-    })
-}
-
-#[tokio::test]
-async fn mounted_f2_requires_canvas_focus_and_yields_to_clean_inspector() {
-    for layer in [Layer::Oa, Layer::Sa] {
-        for programmatic in [true, false] {
-            let mut project = Project::empty();
-            let object = project
-                .add_element(
-                    if layer == Layer::Oa {
-                        Kind::Entity
-                    } else {
-                        Kind::System
-                    },
-                    layer,
-                    "Original team",
-                    None,
-                )
-                .unwrap();
-            let diagram = project.ensure_diagram(layer);
-            project.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Overview;
-            let node = project.place(diagram, object, Position { x: 80., y: 80. });
-            let mut app = App::with_project(project);
-            app.page = Page::Diagram;
-            app.layer = layer;
-            app.active_diagram = Some(diagram);
-            app.window_size = Size::new(2000., 1400.);
-            let _ = app.update(Message::Select(object));
-            let before = app.document.snapshot();
-            let mut mounted = Mounted::new(&mut app).await;
-            app.zoom = 1.;
-            app.pan = Vector::ZERO;
-            app.fit_to_view = false;
-            mounted.settle(&mut app).await;
-
-            // Selection alone does not grant the canvas keyboard ownership.
-            assert!(!rename_emitted(&f2(&mut mounted, &mut app).await));
-            assert!(app.architecture.is_none());
-            assert_eq!(app.document.bundle(), &before.bundle);
-
-            let bounds = mounted
-                .geometry(&app)
-                .bounds(crate::allocation_input::CANVAS_ID);
-            let projected = projection::project_view(app.project(), diagram)
-                .nodes
-                .into_iter()
-                .find(|item| item.id == node)
-                .unwrap();
-            let point = Point::new(
-                bounds.x + projected.position.x + 40.,
-                bounds.y + projected.position.y + 35.,
-            );
-            mounted.click(&mut app, point).await;
-            assert_eq!((app.selected, app.selected_node), (object, Some(node)));
-            assert!(rename_emitted(&f2(&mut mounted, &mut app).await));
-            let rename = app.architecture.as_ref().expect("canvas F2 opens rename");
-            assert!(rename.inline());
-            assert!(matches!(
-                &rename.saved.intent,
-                architecture_authoring::Intent::Rename { element, name }
-                    if *element == object && name == "Original team"
-            ));
-            assert_eq!(app.document.bundle(), &before.bundle);
-            assert!(
-                !app.document.can_undo(),
-                "opening rename is not a model edit"
-            );
-
-            let task = app.update(Message::Escape);
-            mounted.perform(&mut app, task).await;
-            assert!(app.architecture.is_none());
-            mounted.click(&mut app, point).await;
-            let field = mounted
-                .geometry(&app)
-                .text_inputs
-                .into_iter()
-                .filter(|bounds| bounds.x > app.window_size.width - 320.)
-                .min_by(|a, b| a.y.total_cmp(&b.y))
-                .expect("Inspector name field is mounted");
-            if programmatic {
-                mounted.operate(&app, &mut FocusField(field));
-            } else {
-                let messages = mounted
-                    .batch(
-                        &mut app,
-                        &[key(Named::Tab), key(Named::F2)],
-                        mouse::Cursor::Unavailable,
-                    )
-                    .await;
-                assert!(
-                    !rename_emitted(&messages),
-                    "Tab must retire F2 admission before its queued focus task"
-                );
-            }
-            let geometry = mounted.geometry(&app);
-            assert!(
-                geometry
-                    .focused
-                    .iter()
-                    .any(|(_, bounds, focused)| { *bounds == field && *focused })
-            );
-            assert!(geometry.focused.iter().any(|(id, _, focused)| {
-                id.as_ref() == Some(&iced::advanced::widget::Id::from("diagram-keyboard-owner"))
-                    && !*focused
-            }));
-            assert!(!app.draft_dirty(), "the Inspector is still clean");
-            assert!(!rename_emitted(&f2(&mut mounted, &mut app).await));
-            assert!(app.architecture.is_none());
-            assert_eq!(
-                app.draft.as_ref().unwrap().inputs["/name"].raw,
-                "Original team"
-            );
-            assert_eq!(app.project(), &before.decoded.project);
-            assert_eq!(app.document.bundle(), &before.bundle);
-            assert!(!app.document.can_undo());
-        }
-    }
-}
-async fn modifier_focus_fixture() -> (App, Mounted, Id, Id, Id) {
-    let mut project = Project::empty();
-    let a = project
-        .add_element(Kind::Entity, Layer::Oa, "First team", None)
-        .unwrap();
-    let b = project
-        .add_element(Kind::Entity, Layer::Oa, "Second team", None)
-        .unwrap();
-    let diagram = project.ensure_diagram(Layer::Oa);
-    let first = project.place(diagram, a, Position { x: 80., y: 80. });
-    let second = project.place(diagram, b, Position { x: 500., y: 80. });
-    let mut app = App::with_project(project);
-    app.page = Page::Diagram;
-    app.layer = Layer::Oa;
-    app.active_diagram = Some(diagram);
-    app.window_size = Size::new(2000., 1400.);
-    let _ = app.update(Message::Select(a));
-    let mut mounted = Mounted::new(&mut app).await;
-    app.zoom = 1.;
-    app.pan = Vector::ZERO;
-    app.fit_to_view = false;
-    mounted.settle(&mut app).await;
-    (app, mounted, diagram, first, second)
-}
-
-fn modifier_node_point(mounted: &mut Mounted, app: &App, diagram: Id, placement: Id) -> Point {
-    let bounds = mounted
-        .geometry(app)
-        .bounds(crate::allocation_input::CANVAS_ID);
-    let node = projection::project_view(app.project(), diagram)
-        .nodes
-        .into_iter()
-        .find(|n| n.id == placement)
-        .unwrap();
-    Point::new(
-        bounds.x + node.position.x + 40.,
-        bounds.y + node.position.y + 35.,
-    )
-}
-
-fn modifier_canvas_focused(mounted: &mut Mounted, app: &App) -> bool {
-    mounted
-        .geometry(app)
-        .focused
-        .iter()
-        .find(|(id, _, _)| {
-            id.as_ref() == Some(&iced::advanced::widget::Id::from("diagram-keyboard-owner"))
-        })
-        .expect("production focus::Owner is mounted")
-        .2
-}
-
-fn modifier_event(shift: bool) -> iced::Event {
-    iced::Event::Keyboard(iced::keyboard::Event::ModifiersChanged(if shift {
-        iced::keyboard::Modifiers::SHIFT
-    } else {
-        iced::keyboard::Modifiers::default()
-    }))
-}
-
-#[tokio::test]
-async fn mounted_shift_before_canvas_focus_toggles_exact_node_without_granting_keyboard_focus() {
-    use crate::diagram_usage::Target;
-    let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-    let before = app.document.snapshot();
-    let field = mounted
-        .geometry(&app)
-        .text_inputs
-        .into_iter()
-        .filter(|bounds| bounds.x > app.window_size.width - 320.)
-        .min_by(|a, b| a.y.total_cmp(&b.y))
-        .expect("clean Inspector name input");
-    mounted.operate(&app, &mut FocusField(field));
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first)]
-    );
-    mounted
-        .batch(
-            &mut app,
-            &[modifier_event(true)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(
-        !modifier_canvas_focused(&mut mounted, &app),
-        "modifier tracking must not acquire focus"
-    );
-    let at = modifier_node_point(&mut mounted, &app, diagram, second);
-    let messages = mounted.click(&mut app, at).await;
-    assert!(messages.iter().any(|m| matches!(m,
-        Message::DiagramSelection(multiselect::Event::Choose(_, Target::Placement(id), multiselect::Choice::Toggle)) if *id == second
-    )), "Shift already held before the first canvas press must reach its exact-target adapter");
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first), Target::Placement(second)]
-    );
-    assert_eq!(app.selected_node, Some(second));
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-    assert!(!app.draft_dirty());
-}
-
-#[tokio::test]
-async fn mounted_unfocused_typing_and_delete_remain_denied_after_passive_modifiers() {
-    use crate::diagram_usage::Target;
-    let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-    mounted
-        .batch(
-            &mut app,
-            &[modifier_event(true)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    let at = modifier_node_point(&mut mounted, &app, diagram, second);
-    mounted.click(&mut app, at).await;
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first), Target::Placement(second)]
-    );
-    // Revoke every field's focus through the real widget operation. No widget
-    // has this off-window rectangle, so neither Inspector nor canvas owns keys.
-    mounted.operate(
-        &app,
-        &mut FocusField(Rectangle {
-            x: -1000.,
-            y: -1000.,
-            width: 1.,
-            height: 1.,
-        }),
-    );
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    let before = app.document.snapshot();
-    let selection = app.multiselect_snapshot().unwrap();
-    let messages = mounted
-        .batch(
-            &mut app,
-            &[
-                modifier_event(false),
-                crate::behavior::canvas_workspace::tests::character("x"),
-                key(Named::Delete),
-                key(Named::F2),
-            ],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(!messages.iter().any(|m| matches!(
-        m,
-        Message::DiagramSelection(_)
-            | Message::DiagramRemove(_)
-            | Message::HideSelected
-            | Message::Delete
-    )));
-    assert!(!rename_emitted(&messages));
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        selection.targets()
-    );
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-    assert!(!app.draft_dirty());
-    assert!(!app.delete_pending);
-}
-
-#[tokio::test]
-async fn mounted_suspended_modifiers_are_passive_and_survive_until_resumed_click() {
-    use crate::diagram_usage::Target;
-    let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-    let before = app.document.snapshot();
-    let at = modifier_node_point(&mut mounted, &app, diagram, second);
-    app.busy = true;
-    mounted.settle(&mut app).await;
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    mounted
-        .batch(
-            &mut app,
-            &[modifier_event(true), key(Named::Delete)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    mounted.click(&mut app, at).await;
-    assert!(
-        !modifier_canvas_focused(&mut mounted, &app),
-        "passive I/O cannot grant canvas focus"
-    );
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first)]
-    );
-    assert_eq!(app.document.bundle(), &before.bundle);
-    app.busy = false;
-    mounted.settle(&mut app).await;
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    mounted.click(&mut app, at).await;
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first), Target::Placement(second)]
-    );
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-}
-
-#[tokio::test]
-async fn mounted_shift_held_before_suspension_survives_without_another_modifier_event() {
-    use crate::diagram_usage::Target;
-    let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-    let before = app.document.snapshot();
-    let field = mounted
-        .geometry(&app)
-        .text_inputs
-        .into_iter()
-        .filter(|bounds| bounds.x > app.window_size.width - 320.)
-        .min_by(|a, b| a.y.total_cmp(&b.y))
-        .expect("clean Inspector name input");
-    mounted.operate(&app, &mut FocusField(field));
-    mounted
-        .batch(
-            &mut app,
-            &[modifier_event(true)],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    app.busy = true;
-    mounted.settle(&mut app).await;
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    app.busy = false;
-    mounted.settle(&mut app).await;
-    assert!(
-        !modifier_canvas_focused(&mut mounted, &app),
-        "restoring passive modifiers must not grant keyboard focus"
-    );
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first)]
-    );
-    // No modifier transition follows the subtree replacement during I/O.
-    let at = modifier_node_point(&mut mounted, &app, diagram, second);
-    let messages = mounted.click(&mut app, at).await;
-    assert!(messages.iter().any(|m| matches!(m,
-        Message::DiagramSelection(multiselect::Event::Choose(_, Target::Placement(id), multiselect::Choice::Toggle)) if *id == second
-    )));
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(first), Target::Placement(second)]
-    );
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-    assert!(!app.draft_dirty());
-}
-
-#[tokio::test]
-async fn mounted_shift_release_or_window_unfocus_during_suspension_does_not_restore_stale_shift() {
-    use crate::diagram_usage::Target;
-    for release in [
-        modifier_event(false),
-        iced::Event::Window(iced::window::Event::Unfocused),
-    ] {
-        let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-        let before = app.document.snapshot();
-        mounted
-            .batch(
-                &mut app,
-                &[modifier_event(true)],
-                mouse::Cursor::Unavailable,
-            )
-            .await;
-        app.busy = true;
-        mounted.settle(&mut app).await;
-        mounted
-            .batch(&mut app, &[release], mouse::Cursor::Unavailable)
-            .await;
-        assert!(!modifier_canvas_focused(&mut mounted, &app));
-        app.busy = false;
-        mounted.settle(&mut app).await;
-        // A further I/O cycle must restore the updated owner state too.
-        app.busy = true;
-        mounted.settle(&mut app).await;
-        app.busy = false;
-        mounted.settle(&mut app).await;
-        assert!(!modifier_canvas_focused(&mut mounted, &app));
-        assert_eq!(
-            app.multiselect_snapshot().unwrap().targets(),
-            &[Target::Placement(first)]
-        );
-        let at = modifier_node_point(&mut mounted, &app, diagram, second);
-        let messages = mounted.click(&mut app, at).await;
-        assert!(!messages.iter().any(|m| matches!(
-            m,
-            Message::DiagramSelection(multiselect::Event::Choose(
-                _,
-                _,
-                multiselect::Choice::Toggle
-            ))
-        )));
-        assert_eq!(
-            app.multiselect_snapshot().unwrap().targets(),
-            &[Target::Placement(second)]
-        );
-        assert_eq!(app.project(), &before.decoded.project);
-        assert_eq!(app.document.bundle(), &before.bundle);
-        assert!(!app.document.can_undo());
-        assert!(!app.draft_dirty());
-    }
-}
-
-#[tokio::test]
-async fn mounted_window_unfocus_resets_held_shift_before_next_canvas_press() {
-    use crate::diagram_usage::Target;
-    let (mut app, mut mounted, diagram, first, second) = modifier_focus_fixture().await;
-    let at_first = modifier_node_point(&mut mounted, &app, diagram, first);
-    mounted.click(&mut app, at_first).await;
-    let before = app.document.snapshot();
-    mounted
-        .batch(
-            &mut app,
-            &[
-                modifier_event(true),
-                iced::Event::Window(iced::window::Event::Unfocused),
-            ],
-            mouse::Cursor::Unavailable,
-        )
-        .await;
-    assert!(!modifier_canvas_focused(&mut mounted, &app));
-    // No ModifiersChanged(empty) follows: a lost window must itself reset it.
-    let at_second = modifier_node_point(&mut mounted, &app, diagram, second);
-    mounted.click(&mut app, at_second).await;
-    assert_eq!(
-        app.multiselect_snapshot().unwrap().targets(),
-        &[Target::Placement(second)]
-    );
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-}
-
-#[tokio::test]
-async fn mounted_selection_strip_keeps_canvas_and_fitted_camera_fixed_for_empty_single_group_and_mixed()
- {
-    use crate::diagram_usage::Target;
-    let mut project = Project::empty();
-    let a = project
-        .add_element(Kind::Activity, Layer::Oa, "First activity", None)
-        .unwrap();
-    let b = project
-        .add_element(
-            Kind::Activity,
-            Layer::Oa,
-            &format!(
-                "Second activity {}",
-                "with a very long primary name ".repeat(20)
-            ),
-            None,
-        )
-        .unwrap();
-    let edge = project.relate(RelationKind::Interaction, "Activity exchange", a, b);
-    let diagram = project.ensure_diagram(Layer::Oa);
-    project.diagrams.get_mut(&diagram).unwrap().projection = ProjectionKind::Overview;
-    let first = project.place(diagram, a, Position { x: 80., y: 80. });
-    let second = project.place(diagram, b, Position { x: 500., y: 80. });
-    let mut app = App::with_project(project);
-    app.page = Page::Diagram;
-    app.layer = Layer::Oa;
-    app.active_diagram = Some(diagram);
-    app.window_size = Size::new(1442., 932.);
-    let _ = app.update(Message::Select(diagram));
-    app.fit_to_view = true;
-    let mut mounted = Mounted::new(&mut app).await;
-    let baseline = app.document.snapshot();
-    let bounds = mounted
-        .geometry(&app)
-        .bounds(crate::allocation_input::CANVAS_ID);
-    let camera = (app.zoom, app.pan, app.fit_to_view, app.canvas_size);
-    assert!(camera.2, "exercise the native resize-triggered refit path");
-    assert!(app.multiselect_snapshot().unwrap().targets().is_empty());
-    assert!(bounds.width > 500. && bounds.height > 300.);
-    for (target, expected) in [
-        (
-            Some(Target::Placement(first)),
-            vec![Target::Placement(first)],
-        ),
-        (
-            Some(Target::Placement(second)),
-            vec![Target::Placement(first), Target::Placement(second)],
-        ),
-        (
-            Some(Target::Edge(edge)),
-            vec![
-                Target::Placement(first),
-                Target::Placement(second),
-                Target::Edge(edge),
-            ],
-        ),
-        (
-            Some(Target::Edge(edge)),
-            vec![Target::Placement(first), Target::Placement(second)],
-        ),
-        (
-            Some(Target::Placement(second)),
-            vec![Target::Placement(first)],
-        ),
-        (None, vec![]),
-    ] {
-        let context = app.multiselect_context().unwrap();
-        let event = match target {
-            Some(target) => {
-                multiselect::Event::Choose(context, target, multiselect::Choice::Toggle)
-            }
-            None => multiselect::Event::Clear(context),
-        };
-        let task = app.update(Message::DiagramSelection(event));
-        mounted.perform(&mut app, task).await;
-        mounted.settle(&mut app).await;
-        assert_eq!(app.multiselect_snapshot().unwrap().targets(), expected);
-        assert_eq!(
-            mounted
-                .geometry(&app)
-                .bounds(crate::allocation_input::CANVAS_ID),
-            bounds,
-            "selection feedback must not change the measured canvas rectangle"
-        );
-        assert_eq!(
-            (app.zoom, app.pan, app.fit_to_view, app.canvas_size),
-            camera
-        );
-        assert_eq!(app.project(), &baseline.decoded.project);
-        assert_eq!(app.document.bundle(), &baseline.bundle);
-        assert!(!app.document.can_undo());
-        assert!(!app.draft_dirty());
-    }
-}

crates/oa-desktop/src/app/diagram_removal.rs

@@ -1,240 +0,0 @@
-//! Captured diagram removal and model-confirmation lifetimes.
-use super::*;
-use crate::{model_menu, route_edit::Context};
-
-#[derive(Debug, Clone)]
-pub struct Intent {
-    pub context: Context,
-    pub object: Id,
-    pub placement: Option<Id>,
-    pub model: bool,
-}
-
-pub struct Confirmation {
-    pub snapshot: model_menu::Opened,
-    pub selection: Id,
-    pub placement: Option<Id>,
-    pub behavior_owner: Option<Id>,
-}
-
-pub fn enabled(app: &App) -> bool {
-    !app.busy && focus_enabled(app)
-}
-
-pub(crate) fn focus_enabled(app: &App) -> bool {
-    crate::behavior::canvas_workspace::keyboard_owner_enabled(app)
-        && !app.draft_dirty()
-        && !app.source_dirty()
-        && !app.behavior.has_pending()
-        && app
-            .architecture
-            .as_ref()
-            .is_none_or(|state| !state.inline())
-}
-
-pub(crate) fn behavior_owner(app: &App) -> Option<Id> {
-    app.topology_context()
-        .map(|context| context.owner)
-        .or_else(|| app.scenario_context().map(|context| context.scenario))
-}
-
-fn placement(app: &App) -> Option<Id> {
-    if behavior_owner(app).is_some() {
-        None
-    } else if app.page == Page::Behavior {
-        app.behavior.diagram.placement
-    } else {
-        app.selected_node
-    }
-}
-
-/// The derived canvases remove semantic occurrences, not reusable definitions.
-/// Kept beside target capture so confirmation rendering uses the same meaning.
-pub(crate) fn explanation(app: &App, object: Id) -> &'static str {
-    if app
-        .project()
-        .diagrams
-        .values()
-        .any(|diagram| diagram.nodes.contains_key(&object))
-    {
-        return "Remove only this diagram placement. The model element and its placements in other diagrams remain. Undo restores this placement.";
-    }
-    if app
-        .project()
-        .relations
-        .get(&object)
-        .is_some_and(|relation| {
-            matches!(
-                relation.kind(),
-                RelationKind::StateAction | RelationKind::StateTransition
-            )
-        })
-    {
-        return "Remove this state relation. Its states and referenced activities or functions remain. Undo restores the relation.";
-    }
-    if app
-        .project()
-        .relations
-        .get(&object)
-        .is_some_and(|relation| {
-            matches!(
-                relation.kind(),
-                RelationKind::SequenceLink | RelationKind::ContextualLink
-            )
-        })
-    {
-        return "Remove this process link. Its endpoint occurrences and referenced reusable model elements are preserved. Undo restores the deletion.";
-    }
-    match app
-        .project()
-        .elements
-        .get(&object)
-        .and_then(|element| element.shared())
-    {
-        Some(SharedBody::Lifeline { .. }) => {
-            "Remove this participant from the scenario. Its represented model element is preserved. Messages and other occurrences remain with affected participant references cleared. Undo restores the deletion."
-        }
-        Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Fragment { .. } | OccurrenceBody::Branch { .. },
-            ..
-        }) => {
-            "Remove this occurrence and its owned branches and steps. Referenced reusable model elements are preserved. Undo restores the deletion."
-        }
-        Some(SharedBody::Occurrence { .. }) => {
-            "Remove this occurrence and its dependent links. Referenced reusable model elements are preserved. Undo restores the deletion."
-        }
-        _ => {
-            "Owned children, incident relations, occurrences, placements and trace links will also be removed. The traced counterpart itself is preserved. Undo restores the deletion."
-        }
-    }
-}
-
-impl App {
-    pub(super) fn remove_from_diagram(&mut self, intent: Intent) {
-        if !enabled(self) || self.connection.is_some() || self.selected_bend.is_some() {
-            return;
-        }
-        let current = match self.page {
-            Page::Diagram if self.architecture.as_ref().is_none_or(|s| !s.saved.placing) => {
-                self.route_context()
-            }
-            Page::Behavior
-                if self.behavior.diagram.tool == crate::behavior::state_edit::Tool::Select =>
-            {
-                self.state_context()
-            }
-            _ => None,
-        };
-        let selected_object = self
-            .project()
-            .diagrams
-            .get(&intent.context.diagram)
-            .and_then(|diagram| diagram.nodes.get(&self.selected))
-            .map_or(self.selected, |node| node.element);
-        if current != Some(intent.context) || selected_object != intent.object {
-            return;
-        }
-        let view = projection::project_view(self.project(), intent.context.diagram);
-        let placement = if self.page == Page::Behavior {
-            self.behavior.diagram.placement
-        } else {
-            self.selected_node
-        };
-        if intent.placement != placement || intent.object == intent.context.diagram {
-            return;
-        }
-        let visible = if let Some(id) = intent.placement {
-            self.project().diagrams[&intent.context.diagram]
-                .nodes
-                .get(&id)
-                .is_some_and(|node| node.element == intent.object)
-                && view
-                    .nodes
-                    .iter()
-                    .any(|node| node.id == id && node.element == intent.object)
-        } else {
-            view.edges.iter().any(|edge| edge.id == intent.object)
-                || view.ports.iter().any(|port| port.element == intent.object)
-                || (self.page == Page::Behavior
-                    && crate::behavior::state_canvas::visible_row_relation(
-                        self.project(),
-                        intent.context.diagram,
-                        &view,
-                        intent.object,
-                    ))
-        };
-        if !visible {
-            return;
-        }
-        if !intent.model
-            && let Some(placement) = intent.placement
-        {
-            if self.execute(Command::Delete(placement)) {
-                self.selected_node = None;
-                self.behavior.diagram.placement = None;
-                self.selected_bend = None;
-                self.status = "Hidden from this diagram · Model element preserved · Undo restores the placement".into();
-            }
-        } else {
-            self.begin_model_delete_target(intent.object, Some(intent.context));
-        }
-    }
-
-    pub(super) fn begin_model_delete(&mut self, canvas: Option<Context>) {
-        self.begin_model_delete_target(self.selected, canvas);
-    }
-
-    fn begin_model_delete_target(&mut self, object: Id, canvas: Option<Context>) {
-        if object == self.project().id || self.behavior.has_pending() {
-            return;
-        }
-        let mut request = model_menu::Request::object(object, iced::Point::ORIGIN);
-        request.canvas = canvas;
-        request.placement = placement(self);
-        // Opening a modal retires any pending canvas intent before capturing
-        // the confirmation; every new dialog receives its own replay token.
-        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-        if canvas.is_some() {
-            request.canvas = if self.page == Page::Behavior {
-                self.state_context()
-            } else {
-                self.route_context()
-            };
-        }
-        self.menu_sequence = self.menu_sequence.wrapping_add(1);
-        self.delete_target =
-            model_menu::Opened::new(self, request, self.menu_sequence).map(|snapshot| {
-                Confirmation {
-                    snapshot,
-                    selection: self.selected,
-                    placement: placement(self),
-                    behavior_owner: behavior_owner(self),
-                }
-            });
-        self.delete_pending = self.delete_target.is_some();
-    }
-
-    pub(super) fn confirm_model_delete(&mut self, token: u64) {
-        let Some(target) = self.delete_target.as_ref() else {
-            return;
-        };
-        if target.snapshot.token != token {
-            return;
-        }
-        let valid = self.delete_pending
-            && target.snapshot.valid(self)
-            && target.selection == self.selected
-            && target.placement == placement(self)
-            && target.behavior_owner == behavior_owner(self)
-            && !self.behavior.has_pending()
-            && !self.source_dirty()
-            && !self.draft_dirty();
-        let id = target.snapshot.request.object;
-        self.delete_pending = false;
-        self.delete_target = None;
-        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-        if valid {
-            self.execute(Command::Delete(id));
-        }
-    }
-}

crates/oa-desktop/src/app/diagram_removal_tests/navigation_union.rs

@@ -1,146 +0,0 @@
-//! Navigate first, then remove through the mounted root canvas and history.
-use super::*;
-use crate::diagram_usage::{self as usage, Target};
-
-async fn navigate_then_remove(project: Project, subject: Id, owner: Id, row: bool) {
-    let mut app = App::with_project(project);
-    app.window_size = Size::new(2000., 1400.);
-    let before = app.document.snapshot();
-    let message = app.diagram_usage_message(subject);
-    let _ = app.update(message);
-    let panel = app.diagram_usages.as_ref().unwrap();
-    let token = panel.token;
-    let context = panel.context;
-    // Complete the same query independently without polling its worker Task.
-    let process = app.behavior.topology.usage_snapshot().into_query_state();
-    let completion = usage::Completion {
-        token,
-        context,
-        result: Ok(usage::collect(
-            app.project(),
-            subject,
-            &process,
-            &behavior::scenario::State::default(),
-        )),
-    };
-    let _ = app.update(Message::DiagramUsagesReady(completion));
-    let found = app
-        .diagram_usages
-        .as_ref()
-        .unwrap()
-        .usages
-        .iter()
-        .find(|usage| {
-            if row {
-                matches!(usage.target, Target::StateRow { relation, .. } if relation == subject)
-            } else {
-                matches!(usage.target, Target::Port { port, .. } if port == subject)
-            }
-        })
-        .unwrap()
-        .clone();
-    let _ = app.update(Message::DiagramUsage(usage::Event::Choose(
-        token,
-        found.clone(),
-    )));
-    assert_eq!(app.selected, subject);
-    // refresh_draft normalizes the owner's presentation placement; navigation
-    // must not leave it armed as a removal target.
-    assert!(app.selected_node.is_none());
-    assert!(app.behavior.diagram.placement.is_none());
-    assert_eq!(
-        app.diagram_focus(found.surface).unwrap().target,
-        found.target
-    );
-
-    let mut mounted = Mounted::new(&mut app).await;
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(app.pending_diagram_reveal.is_none());
-    for model in [false, true] {
-        mounted
-            .perform(
-                &mut app,
-                iced::widget::operation::focus(iced::advanced::widget::Id::from(
-                    "diagram-keyboard-owner",
-                )),
-            )
-            .await;
-        let messages = delete(&mut mounted, &mut app, model).await;
-        let request = messages
-            .iter()
-            .find_map(|message| match message {
-                Message::DiagramRemove(intent)
-                | Message::StateDiagram(behavior::state_edit::Event::Remove(intent)) => {
-                    Some(intent)
-                }
-                _ => None,
-            })
-            .expect("actual focused canvas emitted a removal intent");
-        assert_eq!(request.object, subject);
-        assert_eq!(request.placement, None);
-        assert_eq!(request.model, model);
-        assert_eq!(
-            app.delete_target.as_ref().unwrap().snapshot.request.object,
-            subject
-        );
-        assert_eq!(app.project(), &before.decoded.project);
-        assert_eq!(app.document.bundle(), &before.bundle);
-        if !model {
-            let task = app.update(Message::CancelDelete);
-            mounted.perform(&mut app, task).await;
-        }
-    }
-    let token = app.delete_target.as_ref().unwrap().snapshot.token;
-    let task = app.update(Message::ConfirmDelete(token));
-    mounted.perform(&mut app, task).await;
-    let expected = execute_batch(&before.decoded.project, &[Command::Delete(subject)]).unwrap();
-    assert_eq!(app.project(), &expected);
-    assert!(app.project().contains(owner));
-    consistent(&app);
-    let task = app.update(Message::Undo);
-    mounted.perform(&mut app, task).await;
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-}
-
-#[tokio::test]
-async fn port_navigation_then_canvas_delete_preserves_owner_and_restores_exact_history() {
-    let mut project = Project::empty();
-    let owner = project.add(Kind::Function, "Compute", 1200., 1500.);
-    let port = Id::new_v4();
-    let element = oa_core::ports::make_port(
-        &project,
-        port,
-        owner,
-        "Input",
-        oa_core::PortContract::FunctionInput {
-            incoming_items: vec![],
-        },
-    )
-    .unwrap();
-    project = execute_batch(&project, &[Command::CreateElement(element)]).unwrap();
-    navigate_then_remove(project, port, owner, false).await;
-}
-
-#[tokio::test]
-async fn state_row_navigation_then_canvas_delete_preserves_work_and_restores_exact_history() {
-    let mut project = Project::empty();
-    let machine = project
-        .add_element(Kind::StateMachine, Layer::Sa, "Modes", None)
-        .unwrap();
-    let region = project
-        .add_element(Kind::Region, Layer::Sa, "Main", Some(machine))
-        .unwrap();
-    let state = project
-        .add_element(Kind::State, Layer::Sa, "Running", Some(region))
-        .unwrap();
-    let work = project
-        .add_element(Kind::Function, Layer::Sa, "Monitor", None)
-        .unwrap();
-    let relation = project.relate(RelationKind::StateAction, "Entry", state, work);
-    let plan = crate::behavior::state_edit::create_view(&project, machine).unwrap();
-    project = execute_batch(&project, &[plan.command]).unwrap();
-    navigate_then_remove(project, relation, work, true).await;
-}

crates/oa-desktop/src/app/diagram_reveal.rs

@@ -1,161 +0,0 @@
-//! Complete a navigation camera after the destination reports its real viewport.
-use super::*;
-use crate::behavior::scenario_layout::Representation;
-use crate::diagram_usage::{Context, Surface};
-#[cfg(test)]
-mod tests;
-
-impl App {
-    pub(super) fn is_diagram_viewport(message: &Message) -> bool {
-        matches!(
-            message,
-            Message::CanvasResized(_)
-                | Message::DiagramRevealViewport(..)
-                | Message::TopologyCanvas(behavior::topology::CanvasEvent::Viewport(..))
-                | Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Viewport(..))
-                | Message::StateDiagram(behavior::state_edit::Event::Viewport(..))
-        )
-    }
-    pub(crate) fn architecture_reveal_stamp(&self, diagram: Id) -> Option<(Context, u64)> {
-        self.pending_diagram_reveal
-            .as_ref()
-            .filter(|(_, u, _)| u.surface == Surface::Saved(diagram))
-            .map(|(context, _, epoch)| (*context, *epoch))
-    }
-
-    pub(super) fn diagram_reveal_viewport(&self, message: &Message) -> Option<Surface> {
-        let (context, usage, epoch) = self.pending_diagram_reveal.as_ref()?;
-        if context.document != self.canvas_document
-            || context.revision != self.document.revision()
-            || *epoch != self.canvas_epoch
-        {
-            return None;
-        }
-        let (surface, size, valid) = match message {
-            Message::DiagramRevealViewport(c, e, size) => (
-                usage.surface,
-                *size,
-                c == context
-                    && e == epoch
-                    && self.page == Page::Diagram
-                    && Some(usage.surface.id()) == self.active_diagram,
-            ),
-            Message::TopologyCanvas(behavior::topology::CanvasEvent::Viewport(c, size)) => (
-                Surface::Process(c.owner),
-                *size,
-                c.document == context.document
-                    && c.revision == context.revision
-                    && c.epoch == *epoch,
-            ),
-            Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Viewport(c, size)) => (
-                match c.representation {
-                    Representation::Derived { owner } => Surface::Scenario(owner),
-                    Representation::Saved { diagram } => Surface::Saved(diagram),
-                },
-                *size,
-                c.document == context.document
-                    && c.revision == context.revision
-                    && c.epoch == *epoch
-                    && self.pending_scenario_reveal_visit == Some(c.visit)
-                    && self.page == Page::Behavior
-                    && self.behavior.active_owner == Some(c.scenario)
-                    && self.behavior.scenario.context(
-                        self.canvas_document,
-                        c.scenario,
-                        self.document.revision(),
-                        self.canvas_epoch,
-                    ) == Some(*c),
-            ),
-            Message::StateDiagram(behavior::state_edit::Event::Viewport(c, size)) => (
-                Surface::Saved(c.diagram),
-                *size,
-                c.document == context.document
-                    && c.revision == context.revision
-                    && c.epoch == *epoch,
-            ),
-            _ => return None,
-        };
-        (valid
-            && surface == usage.surface
-            && size.width.is_finite()
-            && size.height.is_finite()
-            && size.width > 0.
-            && size.height > 0.)
-            .then_some(surface)
-    }
-
-    pub(super) fn reconcile_pending_diagram_reveal(&mut self, message: &Message) {
-        if !matches!(
-            message,
-            Message::CheckpointTick
-                | Message::CheckpointWritten(..)
-                | Message::Lint(_)
-                | Message::Linted(..)
-                | Message::SourceViewport(_)
-                | Message::WindowResized(_)
-                | Message::CanvasResized(_)
-                | Message::DiagramRevealViewport(..)
-                | Message::DiagramUsage(_)
-                | Message::DiagramUsagesReady(_)
-                | Message::SourceSymbolsReady(_)
-                | Message::SourceRenameReady(_)
-                | Message::WorkDrag(allocation_drag::Event::KeyboardBoundary)
-                | Message::WorkDrag(allocation_drag::Event::Unfocused)
-                | Message::TopologyCanvas(behavior::topology::CanvasEvent::Viewport(..))
-                | Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Viewport(..))
-                | Message::StateDiagram(behavior::state_edit::Event::Viewport(..))
-        ) {
-            self.pending_diagram_reveal = None;
-            self.pending_scenario_reveal_visit = None;
-            if !Self::is_navigation_camera(message) {
-                self.diagram_navigation_focus = None;
-            }
-        }
-    }
-
-    fn is_navigation_camera(message: &Message) -> bool {
-        if let Message::BehaviorControl(intent) = message {
-            return Self::is_navigation_camera(&intent.message);
-        }
-        matches!(
-            message,
-            Message::Pan(_)
-                | Message::Zoom(_)
-                | Message::Fit
-                | Message::TopologyCanvas(
-                    behavior::topology::CanvasEvent::Camera(..)
-                        | behavior::topology::CanvasEvent::Zoom(..)
-                        | behavior::topology::CanvasEvent::Scrolled(..)
-                )
-                | Message::ScenarioCanvas(
-                    behavior::scenario::CanvasEvent::Camera(..)
-                        | behavior::scenario::CanvasEvent::Zoom(..)
-                        | behavior::scenario::CanvasEvent::Scrolled(..)
-                )
-                | Message::StateDiagram(
-                    behavior::state_edit::Event::Pan(..)
-                        | behavior::state_edit::Event::Zoom(..)
-                        | behavior::state_edit::Event::Fit(..)
-                )
-        )
-    }
-
-    pub(super) fn finish_diagram_reveal(&mut self, surface: Surface) {
-        let Some((context, usage, _)) = self.pending_diagram_reveal.take() else {
-            return;
-        };
-        if context.document == self.canvas_document
-            && context.revision == self.document.revision()
-            && usage.surface == surface
-            && !self.draft_dirty()
-            && !self.source_dirty()
-            && !self.behavior.has_pending()
-        {
-            // The normal viewport handler has now stored the measured size.
-            // Target identity was validated for this revision before navigation.
-            self.reveal_diagram_usage(&usage);
-        }
-        self.pending_diagram_reveal = None;
-        self.pending_scenario_reveal_visit = None;
-    }
-}

crates/oa-desktop/src/app/diagram_reveal/tests.rs

@@ -1,418 +0,0 @@
-//! Independent first-layout navigation oracles, through the real App boundary.
-use super::*;
-use crate::diagram_usage::{self as usage, Target, Usage};
-use iced::{Size, Vector};
-use std::collections::BTreeMap;
-
-#[derive(Clone, Copy, Debug)]
-enum Canvas {
-    Architecture,
-    Process,
-    Scenario,
-    State,
-}
-const CANVASES: [Canvas; 4] = [
-    Canvas::Architecture,
-    Canvas::Process,
-    Canvas::Scenario,
-    Canvas::State,
-];
-const WIDE: Size = Size::new(1200., 700.);
-const ACTUAL: Size = Size::new(500., 300.);
-
-fn send(app: &mut App, message: Message) {
-    let _ = app.update(message);
-}
-
-fn fixture(canvas: Canvas) -> (App, Usage) {
-    let mut p = Project::empty();
-    let work = p
-        .add_element(Kind::Activity, Layer::Oa, "Respond", None)
-        .unwrap();
-    let (surface, subject) = match canvas {
-        Canvas::Architecture => {
-            let diagram = p.ensure_diagram(Layer::Oa);
-            p.place(
-                diagram,
-                work,
-                Position {
-                    x: 12_000.,
-                    y: 9_000.,
-                },
-            );
-            (Surface::Saved(diagram), work)
-        }
-        Canvas::Process | Canvas::Scenario => {
-            let kind = if matches!(canvas, Canvas::Process) {
-                Kind::Process
-            } else {
-                Kind::Scenario
-            };
-            let owner = p.add_element(kind, Layer::Oa, "Response", None).unwrap();
-            let occurrence = p
-                .add_element(Kind::Occurrence, Layer::Oa, "Respond here", Some(owner))
-                .unwrap();
-            *p.elements
-                .get_mut(&occurrence)
-                .unwrap()
-                .shared_mut()
-                .unwrap() = SharedBody::Occurrence {
-                body: OccurrenceBody::Action {
-                    action: Some(work),
-                    lifeline: None,
-                },
-                precondition: String::new(),
-                postcondition: String::new(),
-            };
-            let steps = p.elements.get_mut(&owner).unwrap().steps_mut().unwrap();
-            if !steps.contains(&occurrence) {
-                steps.push(occurrence);
-            }
-            (
-                if matches!(canvas, Canvas::Process) {
-                    Surface::Process(owner)
-                } else {
-                    Surface::Scenario(owner)
-                },
-                occurrence,
-            )
-        }
-        Canvas::State => {
-            let machine = p
-                .add_element(Kind::StateMachine, Layer::Oa, "Modes", None)
-                .unwrap();
-            let region = p
-                .add_element(Kind::Region, Layer::Oa, "Main", Some(machine))
-                .unwrap();
-            let state = p
-                .add_element(Kind::State, Layer::Oa, "Ready", Some(region))
-                .unwrap();
-            let diagram = Id::new_v4();
-            p.diagrams.insert(
-                diagram,
-                Diagram {
-                    id: diagram,
-                    alias: "ready_view".into(),
-                    name: "Ready view".into(),
-                    description: String::new(),
-                    layer: Layer::Oa,
-                    projection: ProjectionKind::StateMachine { machine },
-                    nodes: BTreeMap::new(),
-                    layout: None,
-                    routes: vec![],
-                    view_options: Default::default(),
-                },
-            );
-            p.place(
-                diagram,
-                state,
-                Position {
-                    x: 8_000.,
-                    y: 11_000.,
-                },
-            );
-            (Surface::Saved(diagram), state)
-        }
-    };
-    let mut app = App::with_project(p);
-    let found = usage::collect(
-        app.project(),
-        subject,
-        &app.behavior.topology,
-        &app.behavior.scenario,
-    )
-    .into_iter()
-    .find(|u| u.surface == surface && u.target != Target::Whole)
-    .unwrap();
-    app.canvas_size = Some(WIDE);
-    app.behavior.diagram.viewport = Some(WIDE);
-    if let Surface::Process(owner) = surface {
-        app.behavior.topology.enter(app.canvas_document, owner);
-        app.behavior.topology.viewport(WIDE);
-    }
-    if let Surface::Scenario(owner) = surface {
-        app.behavior.scenario.enter(app.canvas_document, owner);
-        app.behavior.scenario.viewport(WIDE);
-    }
-    app.page = Page::Text;
-    (app, found)
-}
-
-fn measurement(
-    canvas: Canvas,
-    context: Context,
-    epoch: u64,
-    surface: Surface,
-    size: Size,
-    visit: Id,
-) -> Message {
-    match canvas {
-        Canvas::Architecture => Message::DiagramRevealViewport(context, epoch, size),
-        Canvas::Process => Message::TopologyCanvas(behavior::topology::CanvasEvent::Viewport(
-            behavior::topology::Context {
-                document: context.document,
-                owner: surface.id(),
-                revision: context.revision,
-                epoch,
-            },
-            size,
-        )),
-        Canvas::Scenario => Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Viewport(
-            behavior::scenario::Context {
-                document: context.document,
-                scenario: surface.id(),
-                representation: Representation::Derived {
-                    owner: surface.id(),
-                },
-                visit,
-                revision: context.revision,
-                epoch,
-            },
-            size,
-        )),
-        Canvas::State => Message::StateDiagram(behavior::state_edit::Event::Viewport(
-            behavior::state_edit::Context {
-                document: context.document,
-                diagram: surface.id(),
-                revision: context.revision,
-                epoch,
-            },
-            size,
-        )),
-    }
-}
-
-fn stamp(app: &App) -> (Context, u64, Id) {
-    let (context, _, epoch) = app
-        .pending_diagram_reveal
-        .as_ref()
-        .expect("reveal awaits measured destination");
-    (
-        *context,
-        *epoch,
-        app.pending_scenario_reveal_visit.unwrap_or(Id::nil()),
-    )
-}
-
-fn assert_centered(app: &App, canvas: Canvas, target: &Usage) {
-    // All independently authored fixture targets fit ACTUAL at the readable cap.
-    // This oracle does not call the production camera/reveal implementation.
-    let zoom = 1.25;
-    let pan = Vector::new(
-        250. - target.bounds.center_x() * zoom,
-        150. - target.bounds.center_y() * zoom,
-    );
-    match canvas {
-        Canvas::Architecture => {
-            assert_eq!(app.canvas_size, Some(ACTUAL));
-            assert_eq!(app.zoom, zoom);
-            assert_eq!(app.pan, pan);
-            assert!(!app.fit_to_view);
-        }
-        Canvas::State => {
-            assert_eq!(app.behavior.diagram.viewport, Some(ACTUAL));
-            assert_eq!(app.behavior.diagram.zoom, zoom);
-            assert_eq!(app.behavior.diagram.pan, pan);
-            assert!(!app.behavior.diagram.fit);
-        }
-        Canvas::Process => {
-            let mut expected = behavior::topology::State::default();
-            expected.enter(app.canvas_document, target.surface.id());
-            expected.viewport(ACTUAL);
-            expected.zoom(Some(zoom));
-            expected.camera(behavior::canvas_workspace::Event::Pan(pan));
-            assert!(app.behavior.topology.camera_boundary() == expected.camera_boundary());
-        }
-        Canvas::Scenario => {
-            let mut expected = behavior::scenario::State::default();
-            expected.enter(app.canvas_document, target.surface.id());
-            expected.choose_tool(target.surface.id(), behavior::scenario::CanvasTool::Select);
-            expected.viewport(ACTUAL);
-            expected.zoom(Some(zoom));
-            expected.camera(
-                app.project(),
-                target.surface.id(),
-                behavior::canvas_workspace::Event::Pan(pan),
-            );
-            assert!(app.behavior.scenario.camera_boundary() == expected.camera_boundary());
-        }
-    }
-}
-
-#[test]
-fn all_reveal_surfaces_recenter_once_after_the_real_viewport_and_preserve_authored_state() {
-    for canvas in CANVASES {
-        let (mut app, target) = fixture(canvas);
-        let accepted = app.document.snapshot();
-        let drafts = app.source_workspace.bundle();
-        let revision = app.document.revision();
-        let history = (
-            app.document.can_undo(),
-            app.document.can_redo(),
-            app.document.dirty(),
-        );
-        assert!(app.reveal_diagram_usage(&target));
-        let (context, epoch, visit) = stamp(&app);
-        send(
-            &mut app,
-            measurement(canvas, context, epoch, target.surface, ACTUAL, visit),
-        );
-        assert!(app.pending_diagram_reveal.is_none());
-        assert_centered(&app, canvas, &target);
-        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
-        assert_eq!(app.source_workspace.bundle(), drafts);
-        assert_eq!(app.document.revision(), revision);
-        assert_eq!(
-            (
-                app.document.can_undo(),
-                app.document.can_redo(),
-                app.document.dirty()
-            ),
-            history
-        );
-        // The exact delivered callback is a replay after the one-shot is consumed.
-        let camera = app.camera_boundary();
-        send(
-            &mut app,
-            measurement(canvas, context, epoch, target.surface, ACTUAL, visit),
-        );
-        assert!(app.pending_diagram_reveal.is_none());
-        assert!(app.camera_boundary() == camera);
-        assert_centered(&app, canvas, &target);
-    }
-}
-
-#[test]
-fn malformed_or_wrong_stamp_measurements_cannot_poison_a_pending_reveal() {
-    for canvas in CANVASES {
-        for invalid in 0..6 {
-            let (mut app, target) = fixture(canvas);
-            assert!(app.reveal_diagram_usage(&target));
-            let (context, epoch, visit) = stamp(&app);
-            let camera = app.camera_boundary();
-            let mut stale = context;
-            let mut wrong_epoch = epoch;
-            let mut size = Size::new(111., 122.);
-            match invalid {
-                0 => stale.document = Id::new_v4(),
-                1 => stale.revision = stale.revision.wrapping_add(1),
-                2 => wrong_epoch = wrong_epoch.wrapping_add(1),
-                3 => size.width = f32::NAN,
-                4 => size.height = f32::INFINITY,
-                _ => size.width = 0.,
-            }
-            send(
-                &mut app,
-                measurement(canvas, stale, wrong_epoch, target.surface, size, visit),
-            );
-            assert!(
-                app.pending_diagram_reveal.is_some(),
-                "{canvas:?} invalid case {invalid}"
-            );
-            assert_eq!(stamp(&app), (context, epoch, visit));
-            assert_eq!(app.canvas_epoch, epoch);
-            assert!(
-                app.camera_boundary() == camera,
-                "{canvas:?} invalid case {invalid}"
-            );
-            send(
-                &mut app,
-                measurement(canvas, context, epoch, target.surface, ACTUAL, visit),
-            );
-            assert!(app.pending_diagram_reveal.is_none());
-            assert_centered(&app, canvas, &target);
-        }
-    }
-}
-
-#[test]
-fn actual_window_resize_before_first_measurement_retains_focus_for_the_new_context() {
-    for canvas in CANVASES {
-        let (mut app, target) = fixture(canvas);
-        let accepted = app.document.snapshot();
-        assert!(app.reveal_diagram_usage(&target));
-        let (context, old_epoch, visit) = stamp(&app);
-        send(&mut app, Message::WindowResized(Size::new(1100., 700.)));
-        let (current, epoch, current_visit) = stamp(&app);
-        assert_eq!(current_visit, visit);
-        assert_eq!(current, context);
-        assert_eq!(epoch, app.canvas_epoch);
-        if matches!(canvas, Canvas::Process | Canvas::Scenario) {
-            assert_ne!(epoch, old_epoch);
-            let camera = app.camera_boundary();
-            send(
-                &mut app,
-                measurement(canvas, context, old_epoch, target.surface, ACTUAL, visit),
-            );
-            assert_eq!(stamp(&app), (current, epoch, visit));
-            assert!(app.camera_boundary() == camera);
-        }
-        send(
-            &mut app,
-            measurement(canvas, current, epoch, target.surface, ACTUAL, visit),
-        );
-        assert!(app.pending_diagram_reveal.is_none());
-        assert_centered(&app, canvas, &target);
-        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
-    }
-}
-
-#[test]
-fn user_camera_edit_and_navigation_cancel_deferred_focus_without_late_snapping() {
-    for canvas in CANVASES {
-        for action in 0..3 {
-            let (mut app, target) = fixture(canvas);
-            let accepted = app.document.snapshot();
-            assert!(app.reveal_diagram_usage(&target));
-            let (context, epoch, visit) = stamp(&app);
-            let event = match action {
-                0 => match canvas {
-                    Canvas::Architecture => Message::Pan(Vector::new(31., -17.)),
-                    Canvas::State => Message::StateDiagram(behavior::state_edit::Event::Pan(
-                        app.state_context().unwrap(),
-                        Vector::new(31., -17.),
-                    )),
-                    Canvas::Process => {
-                        Message::TopologyCanvas(behavior::topology::CanvasEvent::Camera(
-                            app.topology_context().unwrap(),
-                            app.camera_epoch,
-                            behavior::canvas_workspace::Event::Pan(Vector::new(31., -17.)),
-                        ))
-                    }
-                    Canvas::Scenario => {
-                        Message::ScenarioCanvas(behavior::scenario::CanvasEvent::Camera(
-                            app.scenario_context().unwrap(),
-                            app.camera_epoch,
-                            behavior::canvas_workspace::Event::Pan(Vector::new(31., -17.)),
-                        ))
-                    }
-                },
-                1 => Message::Field("/name".into(), "Pending title edit".into()),
-                _ => Message::Page(Page::Catalog),
-            };
-            send(&mut app, event);
-            assert!(
-                app.pending_diagram_reveal.is_none(),
-                "{canvas:?} action {action}"
-            );
-            let camera = app.camera_boundary();
-            let page = app.page;
-            // A stale layout callback at the already retained size cannot
-            // restore the old navigation camera after deliberate user input.
-            send(
-                &mut app,
-                measurement(canvas, context, epoch, target.surface, WIDE, visit),
-            );
-            assert!(app.pending_diagram_reveal.is_none());
-            assert!(
-                app.camera_boundary() == camera,
-                "{canvas:?} action {action}"
-            );
-            assert_eq!(app.page, page);
-            assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
-            if action == 1 {
-                assert!(app.draft_dirty());
-            }
-        }
-    }
-}

crates/oa-desktop/src/app/diagram_usages.rs

@@ -1,533 +0,0 @@
-//! Navigation-only adapter: validates destinations before changing presentation.
-use super::*;
-use crate::behavior::scenario_layout::{Representation, presentation};
-use crate::diagram_usage::{self as usage, Context, Event, Panel, Surface, Target, Usage};
-#[cfg(test)]
-mod tests;
-
-impl App {
-    pub(crate) fn diagram_usage_message(&self, subject: Id) -> Message {
-        Message::DiagramUsage(Event::Open(Context {
-            document: self.canvas_document,
-            revision: self.document.revision(),
-            subject,
-        }))
-    }
-
-    fn usage_navigation_available(&self) -> bool {
-        !self.busy
-            && !self.source_rename.open()
-            && self.pending.is_none()
-            && self.file_prompt.is_none()
-            && !self.delete_pending
-            && self.workflow.is_none()
-            && !self.hosted.visible
-            && self.architecture.is_none()
-            && !self.reference_input_active()
-            && !self.behavior.has_pending()
-            && !self.draft_dirty()
-            && !self.source_dirty()
-    }
-
-    /// Admit at most one expensive lookup, including one accepted Project clone.
-    /// A replacement panel waits for the previous worker's exact completion.
-    fn start_diagram_lookup(&mut self) -> Task<Message> {
-        let Some(panel) = self.diagram_usages.as_ref() else {
-            return Task::none();
-        };
-        if !panel.loading || self.diagram_lookup_in_flight.is_some() {
-            return Task::none();
-        }
-        let (token, context) = (panel.token, panel.context);
-        if context.document != self.canvas_document
-            || context.revision != self.document.revision()
-            || !self.usage_navigation_available()
-        {
-            let panel = self.diagram_usages.as_mut().unwrap();
-            panel.loading = false;
-            panel.notice = Some(
-                "The model or pending edits changed. Reopen diagram navigation when ready.".into(),
-            );
-            return Task::none();
-        }
-        let project = self.project().clone();
-        let presentation = self.behavior.topology.usage_snapshot();
-        self.diagram_lookup_in_flight = Some(token);
-        Task::perform(
-            async move {
-                let result = tokio::task::spawn_blocking(move || {
-                    let process = presentation.into_query_state();
-                    let scenario = behavior::scenario::State::default();
-                    usage::collect(&project, context.subject, &process, &scenario)
-                })
-                .await
-                .map_err(|error| format!("Diagram lookup failed: {error}. Close and try again."));
-                usage::Completion {
-                    token,
-                    context,
-                    result,
-                }
-            },
-            Message::DiagramUsagesReady,
-        )
-    }
-
-    fn refresh_diagram_lookup(&mut self, notice: &str) -> Task<Message> {
-        let Some(panel) = self.diagram_usages.as_mut() else {
-            return Task::none();
-        };
-        panel.token = Id::new_v4();
-        panel.context.revision = self.document.revision();
-        panel.usages.clear();
-        panel.loading = true;
-        panel.page = 0;
-        panel.cursor = 0;
-        panel.destination = None;
-        panel.notice = Some(notice.into());
-        self.start_diagram_lookup()
-    }
-
-    /// Must run before modal/input dispatch. A closed or replaced panel still
-    /// owns its worker slot until this exact completion arrives.
-    pub(super) fn diagram_usages_ready(&mut self, completion: usage::Completion) -> Task<Message> {
-        if self.diagram_lookup_in_flight != Some(completion.token) {
-            return Task::none();
-        }
-        self.diagram_lookup_in_flight = None;
-        let Some(panel) = self.diagram_usages.as_ref() else {
-            return Task::none();
-        };
-        if panel.context.document != self.canvas_document {
-            self.diagram_usages = None;
-            return Task::none();
-        }
-        if panel.context.revision != self.document.revision() {
-            return self
-                .refresh_diagram_lookup("The model changed. Review the refreshed destinations.");
-        }
-        if panel.token != completion.token {
-            // A newer Open/refresh waited without cloning or spawning a second job.
-            return self.start_diagram_lookup();
-        }
-        let panel = self.diagram_usages.as_mut().unwrap();
-        if panel.context != completion.context || !panel.loading {
-            panel.loading = false;
-            panel.notice = Some(
-                "This lookup no longer matches the requested model. Close and try again.".into(),
-            );
-            return Task::none();
-        }
-        panel.loading = false;
-        match completion.result {
-            Ok(usages) => panel.usages = usages,
-            Err(error) => panel.notice = Some(error),
-        }
-        Task::none()
-    }
-
-    /// Selection validates one destination only; opening the chooser does the
-    /// whole-project scan on its worker, never on the GUI thread.
-    fn current_surface_usages(&self, subject: Id, surface: Surface) -> Vec<Usage> {
-        match surface {
-            Surface::Saved(diagram) => {
-                usage::saved_usages_for(self.project(), subject, Some(diagram))
-            }
-            Surface::Process(owner) => {
-                self.behavior
-                    .topology
-                    .diagram_usages(self.project(), owner, subject)
-            }
-            Surface::Scenario(owner) => {
-                self.behavior
-                    .scenario
-                    .diagram_usages(self.project(), owner, subject)
-            }
-        }
-    }
-
-    pub(super) fn diagram_usage_envelope(&self, event: &Event) -> bool {
-        match event {
-            Event::Open(context) => {
-                context.document == self.canvas_document
-                    && context.revision == self.document.revision()
-                    && self.project().contains(context.subject)
-            }
-            Event::Close(token)
-            | Event::Search(token, _)
-            | Event::Page(token, _)
-            | Event::Move(token, _)
-            | Event::Activate(token)
-            | Event::Destination(token, _)
-            | Event::Choose(token, _) => self
-                .diagram_usages
-                .as_ref()
-                .is_some_and(|panel| panel.token == *token),
-        }
-    }
-
-    pub(super) fn diagram_usage_event(&mut self, event: Event) -> Task<Message> {
-        if !self.diagram_usage_envelope(&event) {
-            return Task::none();
-        }
-        if let Event::Open(context) = event {
-            if !self.usage_navigation_available() {
-                self.status = "Apply or revert pending edits before opening diagram navigation. Your inputs are retained.".into();
-                return Task::none();
-            }
-            let mut panel = Panel::new(context, Vec::new());
-            panel.loading = true;
-            let filter_id = format!("diagram-usage-filter-{}", panel.token);
-            self.diagram_usages = Some(panel);
-            self.model_menu = None;
-            // Only an accepted new chooser supersedes the previous reveal.
-            // Rejected/stale panel envelopes leave its first measurement intact.
-            self.pending_diagram_reveal = None;
-            self.pending_scenario_reveal_visit = None;
-            self.diagram_navigation_focus = None;
-            self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-            return Task::batch([
-                self.start_diagram_lookup(),
-                iced::widget::operation::focus(filter_id),
-            ]);
-        }
-        let panel = self
-            .diagram_usages
-            .as_ref()
-            .expect("admitted chooser token");
-        if matches!(event, Event::Close(_)) {
-            self.diagram_usages = None;
-            if self.page == Page::Text {
-                self.restore_source_editor_focus();
-            }
-            return Task::none();
-        }
-        if panel.context.document != self.canvas_document {
-            self.diagram_usages = None;
-            return Task::none();
-        }
-        if panel.context.revision != self.document.revision() {
-            return self
-                .refresh_diagram_lookup("The model changed. Review the refreshed destinations.");
-        }
-        if panel.loading {
-            // Search and Close remain useful while loading; queued activation
-            // must not perform a synchronous fallback or choose an old row.
-            if let Event::Search(_, query) = event {
-                self.diagram_usages.as_mut().unwrap().search = query;
-            }
-            return Task::none();
-        }
-        match event {
-            Event::Move(_, direction) => {
-                let panel = self.diagram_usages.as_ref().unwrap();
-                let count = panel.choices(self.project()).len();
-                let panel = self.diagram_usages.as_mut().unwrap();
-                if count > 0 {
-                    panel.cursor = if direction < 0 {
-                        (panel.cursor + count - 1) % count
-                    } else {
-                        (panel.cursor + 1) % count
-                    };
-                    panel.page = panel.cursor / 6;
-                }
-            }
-            Event::Activate(_) => {
-                let panel = self.diagram_usages.as_ref().unwrap();
-                if let Some(event) = panel.choices(self.project()).get(panel.cursor).cloned() {
-                    return self.diagram_usage_event(event);
-                }
-            }
-            Event::Search(_, query) => {
-                let panel = self.diagram_usages.as_mut().unwrap();
-                panel.search = query;
-                panel.page = 0;
-                panel.cursor = 0;
-            }
-            Event::Page(_, page) => {
-                let panel = self.diagram_usages.as_mut().unwrap();
-                panel.page = page;
-                panel.cursor = page.saturating_mul(6);
-            }
-            Event::Destination(_, surface) => {
-                let panel = self.diagram_usages.as_mut().unwrap();
-                if surface.is_none() || panel.usages.iter().any(|u| Some(u.surface) == surface) {
-                    panel.destination = surface;
-                    panel.page = 0;
-                    panel.cursor = 0;
-                }
-            }
-            Event::Choose(_, requested) => {
-                if !self.usage_navigation_available() {
-                    return Task::none();
-                }
-                let subject = self.diagram_usages.as_ref().unwrap().context.subject;
-                let fresh = self
-                    .current_surface_usages(subject, requested.surface)
-                    .into_iter()
-                    .find(|u| u.subject == requested.subject && u.target == requested.target);
-                let Some(fresh) = fresh else {
-                    return self.refresh_diagram_lookup(
-                        "This representation changed. Review the refreshed destinations.",
-                    );
-                };
-                if self.reveal_diagram_usage(&fresh) {
-                    self.diagram_usages = None;
-                    self.status = format!(
-                        "{} · {} in {}",
-                        self.project().named(subject),
-                        fresh.role,
-                        self.project().named(fresh.surface.id())
-                    );
-                    return Task::batch(["model-explorer", "model-browser", "inspector"].map(
-                        |id| {
-                            iced::widget::operation::snap_to(
-                                id,
-                                iced::widget::scrollable::RelativeOffset::START,
-                            )
-                        },
-                    ));
-                }
-            }
-            Event::Open(_) | Event::Close(_) => unreachable!(),
-        }
-        Task::none()
-    }
-
-    /// Explicit saved-Scenario reveal runs before generic Apply. An absent target
-    /// never selects the owner or another saved arrangement as a fallback.
-    pub(super) fn reveal_saved_scenario(&mut self, diagram: Id, selected: Id) -> Task<Message> {
-        if self.diagram_usages.is_some() || !self.usage_navigation_available() {
-            self.status = "Apply or revert pending edits before revealing a saved Scenario. Your inputs are retained.".into();
-            return Task::none();
-        }
-        if presentation::checked_owner(self.project(), Representation::Saved { diagram }).is_none()
-        {
-            return Task::none();
-        }
-        let Some(found) = self
-            .current_surface_usages(selected, Surface::Saved(diagram))
-            .into_iter()
-            .find(|row| matches!(row.target, Target::Whole | Target::ScenarioObject(_)))
-        else {
-            self.status = "This object has no visible target in that saved Scenario.".into();
-            return Task::none();
-        };
-        self.reveal_diagram_usage(&found);
-        Task::none()
-    }
-
-    pub(super) fn reveal_diagram_usage(&mut self, usage: &Usage) -> bool {
-        if !self.usage_navigation_available() {
-            return false;
-        }
-        let previous_layer = self.layer;
-        let scenario_representation = match usage.surface {
-            Surface::Saved(diagram) if self.saved_scenario_diagram(diagram) => {
-                Some(Representation::Saved { diagram })
-            }
-            Surface::Scenario(owner) => Some(Representation::Derived { owner }),
-            _ => None,
-        };
-        if let Some(representation) = scenario_representation {
-            let Some(owner) = presentation::checked_owner(self.project(), representation) else {
-                return false;
-            };
-            if !self
-                .behavior
-                .scenario
-                .representation_usages(self.project(), representation, usage.subject)
-                .iter()
-                .any(|row| row == usage)
-            {
-                return false;
-            }
-            // Finish target/camera admission before changing the App route. The
-            // checked immutable owner also makes the following entry infallible.
-            let revealed = match representation {
-                Representation::Derived { .. } => self.behavior.scenario.reveal_usage(
-                    self.document.project(),
-                    self.canvas_document,
-                    owner,
-                    &usage.target,
-                ),
-                Representation::Saved { .. } => self.behavior.scenario.reveal_representation_usage(
-                    self.document.project(),
-                    self.canvas_document,
-                    owner,
-                    representation,
-                    &usage.target,
-                ),
-            };
-            if !revealed {
-                return false;
-            }
-            if !self.enter_scenario_representation(representation) {
-                return false;
-            }
-        }
-        let p = self.document.project();
-        let (selected, placement) = match &usage.target {
-            Target::Whole => (usage.surface.id(), None),
-            Target::Placement(id) => {
-                let Some(node) = p
-                    .diagrams
-                    .get(&usage.surface.id())
-                    .and_then(|d| d.nodes.get(id))
-                else {
-                    return false;
-                };
-                (node.element, Some(*id))
-            }
-            Target::Port { port, placement } => (*port, Some(*placement)),
-            Target::StateRow {
-                placement,
-                relation,
-            } => (*relation, Some(*placement)),
-            Target::Edge(id)
-            | Target::ProcessLink(id)
-            | Target::ScenarioObject(id)
-            | Target::AllocationGrouping { relation: id, .. }
-            | Target::ProcessPreviewLink { relation: id, .. } => (*id, None),
-            Target::ProcessOccurrence(endpoint) => (endpoint.occurrence, None),
-        };
-        match usage.surface {
-            Surface::Saved(id) => {
-                let Some(diagram) = p.diagrams.get(&id) else {
-                    return false;
-                };
-                self.layer = diagram.layer;
-                self.active_diagram = Some(id);
-                if let Some(owner) = diagram.projection.scenario() {
-                    self.behavior.active_owner = Some(owner);
-                    self.page = Page::Behavior;
-                } else if let Some(machine) = diagram.projection.state_machine() {
-                    let viewport = self.behavior.diagram.viewport.unwrap_or(iced::Size::new(
-                        (self.window_size.width - 610.).max(280.),
-                        (self.window_size.height - 320.).max(240.),
-                    ));
-                    let (zoom, pan) = usage::camera_for(&usage.target, usage.bounds, viewport);
-                    self.behavior.diagram = behavior::state_view::State {
-                        diagram: Some(id),
-                        placement,
-                        viewport: Some(viewport),
-                        zoom,
-                        pan,
-                        fit: false,
-                        ..Default::default()
-                    };
-                    self.behavior.active_owner = Some(machine);
-                    self.page = Page::Behavior;
-                } else {
-                    let viewport = self.canvas_size.unwrap_or(iced::Size::new(
-                        (self.window_size.width - 550.).max(280.),
-                        (self.window_size.height - 284.).max(240.),
-                    ));
-                    (self.zoom, self.pan) =
-                        usage::camera_for(&usage.target, usage.bounds, viewport);
-                    self.fit_to_view = false;
-                    self.page = Page::Diagram;
-                }
-            }
-            Surface::Process(owner) => {
-                if !self.behavior.topology.reveal_usage(
-                    p,
-                    self.canvas_document,
-                    owner,
-                    &usage.target,
-                ) {
-                    return false;
-                }
-                self.layer = p.elements[&owner].layer();
-                self.behavior.active_owner = Some(owner);
-                self.page = Page::Behavior;
-            }
-            Surface::Scenario(owner) => {
-                self.layer = p.elements[&owner].layer();
-                self.behavior.active_owner = Some(owner);
-                self.page = Page::Behavior;
-            }
-        }
-        if scenario_representation.is_none() {
-            self.behavior.scenario.forget_view();
-        }
-        self.selected = selected;
-        self.selected_node = placement;
-        self.model_menu = None;
-        self.canvas_epoch = self.canvas_epoch.wrapping_add(1);
-        self.selected_bend = None;
-        self.connection = None;
-        self.last_workspace_page = self.page;
-        if previous_layer != self.layer {
-            self.data_state = Default::default();
-            self.explorer_index = crate::explorer::Index::new(self.project(), self.layer);
-            self.explorer_focus = None;
-            self.explorer_group = None;
-            self.explorer_page = 0;
-        }
-        self.normalize_creation();
-        self.reveal_explorer_selection();
-        self.refresh_draft();
-        self.diagram_navigation_focus = Some(usage::Focus {
-            context: Context {
-                document: self.canvas_document,
-                revision: self.document.revision(),
-                subject: usage.subject,
-            },
-            usage: usage.clone(),
-            selected,
-        });
-        self.pending_scenario_reveal_visit = scenario_representation.and_then(|representation| {
-            let owner = presentation::checked_owner(self.project(), representation)?;
-            self.behavior
-                .scenario
-                .context(
-                    self.canvas_document,
-                    owner,
-                    self.document.revision(),
-                    self.canvas_epoch,
-                )
-                .map(|context| context.visit)
-        });
-        self.pending_diagram_reveal = Some((
-            Context {
-                document: self.canvas_document,
-                revision: self.document.revision(),
-                subject: usage.subject,
-            },
-            usage.clone(),
-            self.canvas_epoch,
-        ));
-        true
-    }
-
-    /// Validated presentation identity. Edit selection and Delete capture remain
-    /// semantic; a port owner or allocation work box is only a visual marker.
-    pub(crate) fn diagram_focus(&self, surface: Surface) -> Option<&Usage> {
-        let focus = self.diagram_navigation_focus.as_ref()?;
-        let current_surface = match surface {
-            Surface::Saved(id) => {
-                self.active_diagram == Some(id)
-                    && matches!(self.page, Page::Diagram | Page::Behavior)
-                    && (!self.saved_scenario_diagram(id)
-                        || (self.page == Page::Behavior
-                            && self.behavior.scenario.representation()
-                                == Some(Representation::Saved { diagram: id })))
-            }
-            Surface::Process(owner) => {
-                self.page == Page::Behavior && self.behavior.active_owner == Some(owner)
-            }
-            Surface::Scenario(owner) => {
-                self.page == Page::Behavior
-                    && self.behavior.active_owner == Some(owner)
-                    && self.behavior.scenario.representation()
-                        == Some(Representation::Derived { owner })
-            }
-        };
-        (current_surface
-            && focus.usage.surface == surface
-            && focus.context.document == self.canvas_document
-            && focus.context.revision == self.document.revision()
-            && focus.selected == self.selected)
-            .then_some(&focus.usage)
-    }
-}

crates/oa-desktop/src/app/diagram_usages/tests/saved_scenario.arcadia

@@ -1,108 +0,0 @@
-arcadia 7;
-project incident_workspace "Incident report review" id "70200000-0000-4000-8000-000000000001" {
-    // Two operational activities, with one lifeline appearance per Scenario.
-    oa_activity report_incident "Report incident" id "70200000-0000-4000-8000-000000000002" {}
-    oa_activity assess_incident "Assess incident" id "70200000-0000-4000-8000-000000000003" {}
-    interaction incident_report "Incident report" id "70200000-0000-4000-8000-000000000004" {
-        source @report_incident;
-        target @assess_incident;
-    }
-
-    oa_scenario incident_response "Review a reported incident" id "70200000-0000-4000-8000-000000000010" {
-        viewpoint OperationalActivity;
-        steps [@initial_report, @updated_report, @assess_call, @assess_reply, @unfinished_notice, @use_review];
-    }
-    oa_lifeline reporter "Reporting activity" id "70200000-0000-4000-8000-000000000011" {
-        parent @incident_response; represented @report_incident;
-    }
-    oa_lifeline assessor "Assessment activity" id "70200000-0000-4000-8000-000000000012" {
-        parent @incident_response; represented @assess_incident;
-    }
-    // Both appearances reuse one definition. Navigation must retain the occurrence.
-    oa_occurrence initial_report "Initial incident report" id "70200000-0000-4000-8000-000000000020" {
-        parent @incident_response;
-        body { Exchange { exchange @incident_report; sender @reporter; receiver @assessor; message_kind Asynchronous; }; };
-    }
-    oa_occurrence updated_report "Updated incident report" id "70200000-0000-4000-8000-000000000021" {
-        parent @incident_response;
-        body { Exchange { exchange @incident_report; sender @reporter; receiver @assessor; message_kind Asynchronous; }; };
-    }
-    // A correlated self call/reply with deliberately unassigned exchange definitions.
-    oa_occurrence assess_call "Assess report details" id "70200000-0000-4000-8000-000000000022" {
-        parent @incident_response;
-        body { Exchange { exchange none; sender @assessor; receiver @assessor; message_kind Call; }; };
-    }
-    oa_occurrence assess_reply "Assessment ready" id "70200000-0000-4000-8000-000000000023" {
-        parent @incident_response;
-        body { Exchange { exchange none; sender @assessor; receiver @assessor; message_kind Reply; reply_to @assess_call; }; };
-    }
-    // Intentional unfinished work: no receiver and therefore no fabricated arrow.
-    oa_occurrence unfinished_notice "Follow-up recipient undecided" id "70200000-0000-4000-8000-000000000024" {
-        parent @incident_response;
-        body { Exchange { exchange @incident_report; sender @reporter; receiver none; message_kind Asynchronous; }; };
-    }
-    oa_occurrence use_review "Use the reviewed reporting procedure" id "70200000-0000-4000-8000-000000000025" {
-        parent @incident_response;
-        body { ScenarioUse {
-            bindings [{ local @reporter; referenced @review_reporter; }, { local @assessor; referenced @review_assessor; }];
-            scenario @reporting_review;
-        }; };
-    }
-
-    // This definition stays opaque in the caller. Open it, then Back to the saved view.
-    oa_scenario reporting_review "Reporting procedure detail" id "70200000-0000-4000-8000-000000000030" {
-        viewpoint OperationalActivity;
-        steps [@review_delivery];
-    }
-    oa_lifeline review_reporter "Reporting activity in detail" id "70200000-0000-4000-8000-000000000031" {
-        parent @reporting_review; represented @report_incident;
-    }
-    oa_lifeline review_assessor "Assessment activity in detail" id "70200000-0000-4000-8000-000000000032" {
-        parent @reporting_review; represented @assess_incident;
-    }
-    oa_occurrence review_delivery "Check the incident report" id "70200000-0000-4000-8000-000000000033" {
-        parent @reporting_review;
-        body { Exchange { exchange @incident_report; sender @review_reporter; receiver @review_assessor; message_kind Asynchronous; }; };
-    }
-
-    diagram incident_readable "A - Incident review readable" id "70200000-0000-4000-8000-000000000040" {
-        layer Oa;
-        projection { Scenario { scenario @incident_response; }; };
-        layout { Scenario {
-            lanes [{ lifeline @reporter; x 160; }, { lifeline @assessor; x 640; }];
-            messages [
-                { address { references []; occurrence @initial_report; }; send_y 160; },
-                { address { references []; occurrence @updated_report; }; send_y 252; },
-                { address { references []; occurrence @assess_call; }; send_y 344; },
-                { address { references []; occurrence @assess_reply; }; send_y 436; }
-            ];
-        }; };
-    }
-    diagram incident_wide "B - Incident review negative and far" id "70200000-0000-4000-8000-000000000041" {
-        layer Oa;
-        projection { Scenario { scenario @incident_response; }; };
-        layout { Scenario {
-            lanes [{ lifeline @reporter; x -500; }, { lifeline @assessor; x 50000; }];
-            messages [
-                { address { references []; occurrence @initial_report; }; send_y 160; },
-                { address { references []; occurrence @updated_report; }; send_y 252; },
-                { address { references []; occurrence @assess_call; }; send_y 344; },
-                { address { references []; occurrence @assess_reply; }; send_y 436; }
-            ];
-        }; };
-    }
-    diagram incident_repair "C - Incident review needs layout repair" id "70200000-0000-4000-8000-000000000042" {
-        layer Oa;
-        projection { Scenario { scenario @incident_response; }; };
-        layout { Scenario {
-            // These valid authored lanes must remain saved during complete fallback.
-            lanes [{ lifeline @reporter; x 900; }, { lifeline @assessor; x -500; }];
-            messages [
-                // REPAIR: change only this 300 to 424, then Undo and Redo the edit.
-                { address { references []; occurrence @assess_reply; }; send_y 300; },
-                // This authored value stays latent while the receiver is missing.
-                { address { references []; occurrence @unfinished_notice; }; send_y 2000; }
-            ];
-        }; };
-    }
-}

crates/oa-desktop/src/app/diagram_usages/tests/saved_scenario.rs

@@ -1,362 +0,0 @@
-//! Actual App chooser/explicit-reveal checks for saved Scenario identity and source history.
-use super::*;
-use crate::behavior::scenario::{CanvasEvent, State};
-use crate::behavior::scenario_layout::{
-    Representation,
-    presentation::{self, PresentationStatus},
-};
-use iced::{Size, Vector};
-
-fn fixture() -> App {
-    let p = language::parse(include_str!("saved_scenario.arcadia")).unwrap();
-    let errors: Vec<_> = oa_core::validation::validate(&p)
-        .into_iter()
-        .filter(|d| d.severity == oa_core::validation::Severity::Error)
-        .collect();
-    assert!(errors.is_empty(), "{errors:?}");
-    App::with_project(p)
-}
-fn id(app: &App, alias: &str) -> Id {
-    app.project()
-        .identities()
-        .into_iter()
-        .find(|(_, a)| *a == alias)
-        .unwrap()
-        .0
-}
-fn representation(view: Id) -> Representation {
-    Representation::Saved { diagram: view }
-}
-fn find(app: &App, subject: Id, view: Id) -> Usage {
-    usage::saved_usages_for(app.project(), subject, Some(view))
-        .into_iter()
-        .find(|row| row.target == Target::ScenarioObject(subject))
-        .expect("exact saved occurrence")
-}
-fn context(app: &App) -> behavior::scenario::Context {
-    let owner = app.behavior.active_owner.unwrap();
-    app.behavior
-        .scenario
-        .context(
-            app.canvas_document,
-            owner,
-            app.document.revision(),
-            app.canvas_epoch,
-        )
-        .unwrap()
-}
-fn navigate(app: &mut App, subject: Id, view: Id) -> Id {
-    let (token, rows) = open(app, subject);
-    let found = rows
-        .into_iter()
-        .find(|u| u.surface == Surface::Saved(view) && u.target == Target::ScenarioObject(subject))
-        .expect("saved chooser destination");
-    choose(app, token, found);
-    assert!(app.diagram_usages.is_none());
-    assert_eq!(app.page, Page::Behavior);
-    assert_eq!(app.active_diagram, Some(view));
-    assert_eq!(
-        app.behavior.scenario.representation(),
-        Some(representation(view))
-    );
-    assert_eq!(app.selected, subject);
-    token
-}
-
-#[test]
-fn saved_queries_use_each_actual_presentation_and_keep_repeated_appearances_and_references_opaque()
-{
-    let app = fixture();
-    let owner = id(&app, "incident_response");
-    let first = id(&app, "initial_report");
-    let second = id(&app, "updated_report");
-    let exchange = id(&app, "incident_report");
-    let latent = id(&app, "unfinished_notice");
-    let callee_message = id(&app, "review_delivery");
-    let views = ["incident_readable", "incident_wide", "incident_repair"].map(|a| id(&app, a));
-    let derived = app
-        .behavior
-        .scenario
-        .diagram_usages(app.project(), owner, first)
-        .pop()
-        .unwrap();
-    let rows = views.map(|view| find(&app, first, view));
-    assert_eq!(rows[0].bounds.y - derived.bounds.y, 12.);
-    assert_ne!(rows[0].bounds, rows[1].bounds);
-    assert_eq!(
-        rows[2].bounds, derived.bounds,
-        "complete fallback cannot retain the authored lane override"
-    );
-    for view in views {
-        let represented = usage::saved_usages_for(app.project(), exchange, Some(view));
-        assert_eq!(represented.len(), 2);
-        assert!(
-            represented
-                .iter()
-                .any(|u| u.target == Target::ScenarioObject(first))
-        );
-        assert!(
-            represented
-                .iter()
-                .any(|u| u.target == Target::ScenarioObject(second))
-        );
-        assert!(
-            represented
-                .iter()
-                .all(|u| u.surface == Surface::Saved(view))
-        );
-        assert!(usage::saved_usages_for(app.project(), callee_message, Some(view)).is_empty());
-        assert_eq!(
-            find(&app, latent, view).target,
-            Target::ScenarioObject(latent)
-        );
-        let shown = presentation::present(app.project(), representation(view), owner);
-        let whole = usage::saved_usages_for(app.project(), view, Some(view));
-        assert_eq!(whole.len(), 1);
-        assert_eq!(whole[0].target, Target::Whole);
-        assert_eq!(Some(whole[0].bounds), shown.bounds());
-    }
-    let wide = presentation::present(app.project(), representation(views[1]), owner)
-        .bounds()
-        .unwrap();
-    assert!(wide.x < -500. && wide.x + wide.width > 50000.);
-    let fallback = presentation::present(app.project(), representation(views[2]), owner);
-    assert!(matches!(
-        fallback.status(),
-        PresentationStatus::Fallback { .. }
-    ));
-    assert_eq!(fallback.latent_messages(), &[latent]);
-    assert!(!fallback.capabilities().coordinate_input);
-}
-
-#[test]
-fn saved_chooser_and_explicit_reveal_preserve_complete_source_and_actual_undo_redo() {
-    for alias in ["incident_readable", "incident_wide", "incident_repair"] {
-        let mut app = fixture();
-        let view = id(&app, alias);
-        let first = id(&app, "initial_report");
-        let owner = id(&app, "incident_response");
-        let original = app.document.snapshot();
-        app.document
-            .execute(Command::Rename(first, "Reviewed incident report".into()))
-            .unwrap();
-        let edited = app.document.snapshot();
-        app.sync_source();
-        app.refresh_draft();
-        let before = authored(&app);
-        navigate(&mut app, first, view);
-        assert_eq!(app.behavior.active_owner, Some(owner));
-        assert_eq!(authored(&app), before);
-        send(&mut app, Message::RevealInDiagram(view, first));
-        assert_eq!(app.active_diagram, Some(view));
-        assert_eq!(authored(&app), before);
-        assert!(app.document.undo());
-        assert_eq!(app.project(), &original.decoded.project);
-        assert_eq!(app.document.bundle(), &original.bundle);
-        assert!(app.document.redo());
-        assert_eq!(app.project(), &edited.decoded.project);
-        assert_eq!(app.document.bundle(), &edited.bundle);
-    }
-}
-
-#[test]
-fn saved_reveal_and_chooser_refuse_source_property_and_behavior_drafts() {
-    for chooser in [false, true] {
-        for block in 0..3 {
-            let mut app = fixture();
-            let view = id(&app, "incident_repair");
-            let first = id(&app, "initial_report");
-            let choice = chooser.then(|| {
-                let (token, rows) = open(&mut app, first);
-                (
-                    token,
-                    rows.into_iter()
-                        .find(|u| u.surface == Surface::Saved(view))
-                        .unwrap(),
-                )
-            });
-            match block {
-                0 => {
-                    let cursor = app.source_editor.cursor();
-                    app.source_workspace
-                        .edit("? preserve unfinished source".into(), cursor);
-                }
-                1 => {
-                    app.draft
-                        .as_mut()
-                        .unwrap()
-                        .input("/name", "Unapplied inspector value".into());
-                    assert!(app.draft_dirty());
-                }
-                _ => {
-                    let p = app.project().clone();
-                    app.behavior
-                        .creation
-                        .update(&p, behavior::creation::Event::Open(Layer::Oa))
-                        .unwrap();
-                    assert!(app.behavior.has_pending());
-                }
-            }
-            let before = authored(&app);
-            let prior = location(&app);
-            let draft = app
-                .draft
-                .as_ref()
-                .map(|d| serde_json::to_value(d.recovery_snapshot()).unwrap());
-            if let Some((token, row)) = choice {
-                choose(&mut app, token, row);
-            } else {
-                send(&mut app, Message::RevealInDiagram(view, first));
-            }
-            assert_eq!(authored(&app), before);
-            assert_eq!(location(&app), prior);
-            assert_eq!(
-                app.draft
-                    .as_ref()
-                    .map(|d| serde_json::to_value(d.recovery_snapshot()).unwrap()),
-                draft
-            );
-        }
-    }
-}
-
-#[test]
-fn saved_a_b_a_rejects_old_visit_and_panel_callbacks_before_deferred_measurement() {
-    let mut app = fixture();
-    let a = id(&app, "incident_readable");
-    let b = id(&app, "incident_wide");
-    let first = id(&app, "initial_report");
-    let before = authored(&app);
-    let old_token = navigate(&mut app, first, a);
-    let old = context(&app);
-    navigate(&mut app, first, b);
-    navigate(&mut app, first, a);
-    let current = context(&app);
-    assert_ne!(old.visit, current.visit);
-    let held = behavior::scenario::Context {
-        epoch: current.epoch,
-        ..old
-    };
-    let camera = app.behavior.scenario.camera_boundary();
-    send(
-        &mut app,
-        Message::ScenarioCanvas(CanvasEvent::Viewport(held, Size::new(900., 900.))),
-    );
-    send(
-        &mut app,
-        Message::ScenarioCanvas(CanvasEvent::Shelf(
-            held,
-            crate::behavior::scenario::Shelf::Selection,
-        )),
-    );
-    send(
-        &mut app,
-        Message::DiagramUsage(Event::Search(old_token, "obsolete filter".into())),
-    );
-    send(&mut app, Message::DiagramUsage(Event::Close(old_token)));
-    assert_eq!(app.pending_scenario_reveal_visit, Some(current.visit));
-    assert!(app.pending_diagram_reveal.is_some());
-    assert!(app.behavior.scenario.camera_boundary() == camera);
-    let bounds = find(&app, first, a).bounds;
-    send(
-        &mut app,
-        Message::ScenarioCanvas(CanvasEvent::Viewport(current, Size::new(500., 300.))),
-    );
-    assert!(app.pending_diagram_reveal.is_none());
-    assert_eq!(context(&app).visit, current.visit);
-    let mut expected = State::default();
-    expected.enter_representation(app.canvas_document, current.scenario, representation(a));
-    expected.viewport(Size::new(500., 300.));
-    expected.zoom(Some(1.25));
-    expected.camera(
-        app.project(),
-        current.scenario,
-        behavior::canvas_workspace::Event::Pan(Vector::new(
-            250. - bounds.center_x() * 1.25,
-            150. - bounds.center_y() * 1.25,
-        )),
-    );
-    assert!(app.behavior.scenario.camera_boundary() == expected.camera_boundary());
-    assert_eq!(authored(&app), before);
-}
-
-#[test]
-fn retargeted_saved_view_cannot_reveal_a_former_owner_occurrence() {
-    let mut app = fixture();
-    let first = id(&app, "initial_report");
-    let view = id(&app, "incident_readable");
-    let other = id(&app, "reporting_review");
-    let (token, rows) = open(&mut app, first);
-    let old = rows
-        .into_iter()
-        .find(|u| u.surface == Surface::Saved(view))
-        .unwrap();
-    let mut replacement = app.project().diagrams[&view].clone();
-    replacement.projection = ProjectionKind::Scenario { scenario: other };
-    replacement.layout = None;
-    app.document
-        .execute(Command::EditDiagram(view, replacement))
-        .unwrap();
-    app.sync_source();
-    app.refresh_draft();
-    let before = authored(&app);
-    let prior = location(&app);
-    choose(&mut app, token, old);
-    assert_eq!(location(&app), prior);
-    assert_eq!(authored(&app), before);
-    finish_lookup(&mut app);
-    let token = app.diagram_usages.as_ref().unwrap().token;
-    assert!(
-        app.diagram_usages
-            .as_ref()
-            .unwrap()
-            .usages
-            .iter()
-            .all(|u| u.surface != Surface::Saved(view))
-    );
-    send(&mut app, Message::DiagramUsage(Event::Close(token)));
-    send(&mut app, Message::RevealInDiagram(view, first));
-    assert_eq!(location(&app), prior);
-    assert_eq!(authored(&app), before);
-}
-
-#[test]
-fn explicit_saved_layout_repair_undo_redo_requeries_authored_and_fallback_geometry_without_extra_history()
- {
-    let mut app = fixture();
-    let view = id(&app, "incident_repair");
-    let first = id(&app, "initial_report");
-    let reply = id(&app, "assess_reply");
-    let before = app.document.snapshot();
-    let fallback = find(&app, first, view);
-    app.document
-        .execute(Command::SetScenarioMessagePosition {
-            diagram: view,
-            position: oa_core::ScenarioMessagePosition {
-                address: oa_core::OccurrenceEndpoint {
-                    references: vec![],
-                    occurrence: reply,
-                },
-                send_y: 424.,
-            },
-        })
-        .unwrap();
-    app.sync_source();
-    app.refresh_draft();
-    let repaired = app.document.snapshot();
-    let authored_row = find(&app, first, view);
-    assert_ne!(authored_row.bounds, fallback.bounds);
-    navigate(&mut app, first, view);
-    assert!(app.document.undo());
-    app.sync_source();
-    app.refresh_draft();
-    assert_eq!(app.project(), &before.decoded.project);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert_eq!(find(&app, first, view).bounds, fallback.bounds);
-    assert!(app.document.redo());
-    app.sync_source();
-    app.refresh_draft();
-    assert_eq!(app.project(), &repaired.decoded.project);
-    assert_eq!(app.document.bundle(), &repaired.bundle);
-    assert_eq!(find(&app, first, view).bounds, authored_row.bounds);
-}